What is the maximum DTM with K+J vs K? What is the maximum DTM in the endgame king + janus vs king on a 10x8-board ?

The janus can move like a bishop or like a knight. Since both sides have two
 additional pieces, the board has 10 columns and (like the chess board), 8
 rows.
I don't know the exact answer for the 10x8 board (used e.g. in Capablanca Chess, where your Janus is called the Archbishop), but I have something that could get you well along toward an exact answer, though with some effort on your part (see further below). On the 8x8 board the max DTM is 17 moves (as you may already know). My conjecture is that the 10x8 answer won't be far off from that, and I'd bet a small sum that it's no more than 19 moves. (After all, if the defending king starts in the center of the 10x8 board and you start corralling it, you're almost immediately into a situation in which, as you start pushing to an edge/corner, the rest of the mating sequence will be indistinguishable from how it would play out on the 8x8 board, as the rest of the board's real estate becomes simply irrelevant.) But as for getting an exact 10x8 answer ...

A few years ago, I was toying around with generating tablebases for Seirawan Chess, which is played on the standard 8x8 board, but features the same extra pieces as Capablanca Chess. In the Seirawan variant, the Janus/Archbishop piece goes by the name Hawk. I just now placed into a github repository my old C++ source code for generating a complete KHK (or, KJK in your terminology) tablebase on the 8x8 board, along with the output files, where e.g. KHK.0 is the set of all mate positions, and KHK.34 is the set of all positions where it is 34 ply until black is mated. It hasn't undergone tons of testing, but this and similar ones for e.g. KEK (king-and-elephant/chancellor vs. king) appeared to function correctly and agree with known results. For instance, the max DTM of 17 moves on the 8x8 board indicated by my KHK stuff is the same value given at the wikipedia page for the Princess piece (yet another name for this particular fairy chess piece).

My code would need to changed a bit in order to adapt to your 10x8 board question. In particular, my code makes full use of the symmetries of the 8x8 board in order to reduce the number of positions needing to be examined, and of course the 10x8 board is less symmetric; so that would need an alteration. Additionally, my somewhat crude representation/storage of positions in this simple program would need to be changed and accounted for (in terms of some hard-coded arithmetic that's performed, for instance) in order to adapt to the 10x8 board. You can see the sort of thing I mean in the following snippets:

// Constants to name the symmetries of the board.
const int sym_id = 1;
const int sym_x = 2; // reflect across x axis
const int sym_y = 3;
const int sym_d1 = 4; // reflect across a1-h8 diagonal
const int sym_d2 = 5;
const int sym_r90 = 6; // rotate 90 degrees clockwise
const int sym_r180 = 7;
const int sym_r270 = 8;


int Apply_Symmetry (int sym, int square)
{
    // Applies the specified symmetry of the board to the specified square
    //     (in 0x88 terms).

    if (sym == sym_d1) {
        return (square / 16) + ((square % 16) * 16);
    }

    else if (sym == sym_y) {
        return ((square / 16) * 16) + (7 - (square % 16));
    }

    else if (sym == sym_d2) {
        return (7 - (square / 16)) + ((7 - (square % 16)) * 16);
    }

    else if (sym == sym_x) {
        return (square % 16) + ((7 - (square / 16)) * 16);
    }

    else
        return 0;
}


But anyway, the structure and the functionality is there if you wanted to modify the code to produce an answer for the max DTM on the 10x8 board, and all told there's only a few hundred lines of code.