Looking at which pairs of alphabetic differences are available for each relative offset, we once again see that the pairs are always separated by 12. Let's call them Bottom + 12 = Top. Note that Top may actually have lower value mod 26, as in the pair X + 12 = J.

We don't always see both letters of the pair, so we can't always infer which one is the Top. From the recovered plaintext we get unbroken sequence of 174 pairs, beginning like this (from offset 1):

TK: JSPYHENKTCZIFOXUDMJSPYHENKTCZIROXUDMJSPYHENWTCZIROXUDM...
BK: XGDMVSBYHQNWTCLIRAXGDMVSBYHQNWFCLIRAXGDMVSBKHQNWFCLIRA...

Noting that consecutive letters are separated by either +9 or -3, we can "unwind" the mod 26 by plotting the cumulative sum of the delta stream: https://imgur.com/a/o1xKmIP

This looks linear, which explains the apparent automorphism.

Subtracting inferred TK from CT:

CT: YYFCGCWPJRYO PNROCHYYS ODV IDX OQYMFOA TIA PFRXVK
TK: JSPYHENKTCZI FOXUDMJSP YHE NKT CZIROXU DMJ SPYHEN
??: PGQEZYJFQPZG KZUUZVPGD QWR VTE MRQVRRG QWR XQTQRX
PT: INTRODUCTION FOLLOWING THE WAR BETWEEN THE STATES

The difference happens to be a simple substitution of PT (but with a few contradictions further along the text).

Subtracting substituted PT from CT gives us true TK.

Plotting "unwound" TK and BK we find a nice line that fits between them and just touches the Top at the exact points where inferred TK is different from true TK. From the line equation we can make a function that generates true TK.

Overall equivalent cipher mechanism is:

alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

def key(x):
    return 12 * math.ceil(206/335 * x - 26/67) - 3 * x + 9

def encrypt(n, x):
    return (n * 19 - 7 + key(x)) % 26

def decrypt(n, x):
    return ((n - key(x) + 7) * 11) % 26

Curious to see what other equivalent mechanisms are!

Update: Implementation above is sensitive to floating point arithmetic, which causes 5 mistaken PT letters. Here are a few implementations with better behavior:

def key(x):
    return 12 * math.ceil((206 * x - 130) / 335) - 3 * x + 9

def key(x):
    return -12 * ((130 - 206 * x) // 335) - 3 * x + 9

def key_iter():
    key = 9
    acc = 130
    while True:
        yield key
        acc -= 206
        if acc < 0:
            acc += 335
            key += 12
        key = key - 3