# Seam: the frank-secondary llama.cpp root unit on dankclaw.
# frank-secondary is the RTX 3090 endpoint; since 2026-10-06 (evening) it
# serves ajgazin/Swift-1.5-Qwen3.8-27B-Uncensored-Dynamic-MTP-GGUF at
# RCO-IQ3_XXS (27B dense qwen3_5 hybrid) via a CUDA (sm_86) build of
# llama.cpp master: TWO 131,072-token conversations at Frank's 128k cap
# (pool 262144 / parallel 2), q8_0 K + q8_0 V (FP8 class), the
# publisher's own BF16 vision projector, and MTP back ON (draft-mtp
# depth 3 — the head is in the file; the lighter quant funds the draft
# ctx plus the second slot). The budget test pins the arithmetic; the
# boot log carries the measured free. This seam runs the serve script
# against a stub engine and asserts on the argv it actually execs, so
# what is pinned is the command the operator gets.

load helpers

UNIT="$REPO_ROOT/scripts/frank-secondary.service"
SERVE="$REPO_ROOT/scripts/serve-frank-secondary.sh"
ENV_FILE="$REPO_ROOT/scripts/frank-secondary.env"
REMOTE_DEPLOY="$REPO_ROOT/scripts/deploy-remote.sh"
ENV_LARGE="$REPO_ROOT/scripts/frank-large.env"
TARGET_STUB="Swift-1.5-Qwen3.8-27B-Uncensored-Dynamic-MTP-RCO-IQ3_XXS.gguf"
# Same basename as the shipped projector: the test env repoints it into $STAGE.
MM_STUB="mmproj-BF16.gguf"

setup() {
    STAGE="$(mktemp -d)"
    RUNTIME_DIR="$STAGE/llama"
    MODEL_DIR="$STAGE/models"
    mkdir -p "$RUNTIME_DIR/bin" "$MODEL_DIR"
    cat > "$RUNTIME_DIR/bin/llama-server" <<'STUB'
#!/usr/bin/env bash
printf '%s\n' "$@"
STUB
    chmod +x "$RUNTIME_DIR/bin/llama-server" "$RUNTIME_DIR/bin" 2>/dev/null || chmod +x "$RUNTIME_DIR/bin/llama-server"
    touch "$MODEL_DIR/$TARGET_STUB" "$MODEL_DIR/$MM_STUB"
}

teardown() {
    rm -rf "$STAGE"
}

# serve_argv [env-file] — run the serve script and capture the engine's
# argv, one token per line, in $output.
serve_argv() {
    local envf="${1:-$STAGE/test.env}"
    local mmproj
    mmproj="$(sed -nE 's/^MMPROJ_FILE=(.+)$/\1/p' "$ENV_FILE")"
    cat > "$envf" <<EOF
LLAMA_BIN=$RUNTIME_DIR/bin/llama-server
MODEL_FILE=$MODEL_DIR/$TARGET_STUB
MMPROJ_FILE=$MODEL_DIR/${mmproj##*/}
ALIAS=frank-secondary
BIND_ADDR=0.0.0.0
LISTEN_PORT=7771
CTX_SIZE=$(sed -nE 's/^CTX_SIZE=([0-9]+)$/\1/p' "$ENV_FILE")
PARALLEL=$(sed -nE 's/^PARALLEL=([0-9]+)$/\1/p' "$ENV_FILE")
BATCH_SIZE=$(sed -nE 's/^BATCH_SIZE=([0-9]+)$/\1/p' "$ENV_FILE")
UBATCH_SIZE=$(sed -nE 's/^UBATCH_SIZE=([0-9]+)$/\1/p' "$ENV_FILE")
CACHE_TYPE_K=$(sed -nE 's/^CACHE_TYPE_K=(.+)$/\1/p' "$ENV_FILE")
CACHE_TYPE_V=$(sed -nE 's/^CACHE_TYPE_V=(.+)$/\1/p' "$ENV_FILE")
NGL=$(sed -nE 's/^NGL=([0-9]+)$/\1/p' "$ENV_FILE")
EOF
    run env FRANK_SECONDARY_ENV_FILE="$envf" nvidia-modprobe=true bash "$SERVE"
}

argv_value() {
    grep -A1 -xF -- "$1" <<<"$output" | tail -1
}

@test "frank-secondary unit, serve script and env exist in scripts/" {
    [ -f "$UNIT" ]
    [ -f "$SERVE" ]
    [ -f "$ENV_FILE" ]
}

@test "frank-secondary is boot-persistent, self-healing and unprivileged" {
    grep -q '^WantedBy=multi-user.target$' "$UNIT"
    grep -q '^Restart=on-failure$' "$UNIT"
    grep -q '^RestartSec=' "$UNIT"
    grep -q '^User=dank$' "$UNIT"
    grep -q '^LimitMEMLOCK=infinity$' "$UNIT"
    grep -q '^ExecStart=/home/dank/serverAppConfigs/scripts/serve-frank-secondary.sh$' "$UNIT"
    grep -q 'FRANK_SECONDARY_ENV_FILE=/home/dank/serverAppConfigs/scripts/frank-secondary.env' "$UNIT"
}

@test "the shipped env points at the llama.cpp runtime and the Swift-1.5-27B Uncensored RCO-IQ3_XXS GGUF" {
    # The payload path IS the endpoint's identity.
    grep -qE '^LLAMA_BIN=/home/dank/GitPackages/llama-master/build-cuda/bin/llama-server$' "$ENV_FILE"
    grep -qE "^MODEL_FILE=/home/dank/models/Swift15-UncIQ3XXS/$TARGET_STUB$" "$ENV_FILE"
}

@test "the deployer gates on exactly the payload paths the env file ships" {
    # Anti-drift: the deploy handler checks files by its own defaults. If
    # those ever differ from what the unit actually loads, a green deploy
    # would be gating on a file nobody reads — and a missing projector would
    # ship a blind endpoint.
    local env_v dep_v path pair
    for pair in "MODEL_FILE LLM_SECONDARY_MODEL_FILE" "MMPROJ_FILE LLM_SECONDARY_MMPROJ"; do
        read -r env_v dep_v <<<"$pair"
        path="$(sed -nE "s/^${env_v}=(.+)\$/\1/p" "$ENV_FILE" | tail -1)"
        [ -n "$path" ]
        grep -qF -- "${dep_v}=\"\${${dep_v}:-${path}}\"" "$REMOTE_DEPLOY"
    done
}

@test "the pool is 229376, so each of the two conversations is 114688" {
    serve_argv
    [ "$status" -eq 0 ]
    [ "$(argv_value --alias)" = "frank-secondary" ]
    [ "$(argv_value --port)" = "7771" ]
    [ "$(argv_value --host)" = "0.0.0.0" ]
    [ "$(argv_value --model)" = "$MODEL_DIR/$TARGET_STUB" ]
    [ "$(argv_value --n-gpu-layers)" -gt 0 ]
    # llama.cpp divides --ctx-size across slots and a mamba hybrid cannot
    # share one cache, so the observable contract is the per-slot window.
    # 2026-10-06 evening (Frank): lower per-slot to 114,688 (112k) to fund
    # the ubatch 512 -> 1024 increase — pool 229376, parallel 2, per-slot
    # 114688 (the cap).
    [ "$(argv_value --parallel)" -eq 2 ]
    ctx="$(argv_value --ctx-size)"
    par="$(argv_value --parallel)"
    [ $((ctx % par)) -eq 0 ]
    [ $((ctx / par)) -eq 114688 ]
}

@test "the KV contract is q8_0 both halves (FP8 class), flash-attn on" {
    serve_argv
    [ "$status" -eq 0 ]
    # Frank, 2026-10-05 evening: "k/v at FP8" for the Swift-1.5 swap —
    # llama.cpp's FP8 class is q8_0 (1.0625 B/elem => 8.5 effective bits;
    # there is no true fp8 KV dtype). This SUPERSEDES the same-day f16/f16
    # rule written for the Ornith 9B fit. The flag pair is what makes this
    # observable — a build without the FA path silently falls back, so both
    # must appear in the argv the supervisor runs.
    [ "$(argv_value --cache-type-k)" = "q8_0" ]
    [ "$(argv_value --cache-type-v)" = "q8_0" ]
    [ "$(argv_value --flash-attn)" = "on" ]
}

@test "the KV budget fits two 114688 slots at q8_0 and forbids a third" {
    # Rate, from the RCO-IQ3_XXS GGUF header (same qwen35 architecture):
    # SIXTEEN full-attention layers (block_count 65 = 64 real layers + the
    # blk.64 MTP head, full_attention_interval 4) x 4 kv heads x 256 dim x
    # 1.0625 B = 17 KiB/token for K and the same for V => 34 KiB/token at
    # q8_0 (budgeted 37 with slack; f16 would be 64). The non-KV half:
    # RCO-IQ3_XXS weights 10,148 MiB (10,442,827,392 B) — 1.56 GiB LIGHTER
    # than the IQ3_S-mtp predecessor — + vision tower ~1.4 GiB (931,145,888
    # B BF16 mmproj at the measured ~1.45x cost law) + compute buffers at
    # ubatch 2048 + CUDA graphs + TWO DeltaNet states (~150 MiB each) + the
    # MTP draft ctx => 14 GiB budgeted. Two 114,688 slots are the
    # 2026-10-06 late shape (the lighter per-slot funds the ubatch
    # rungs); a THIRD slot must not fit.
    # change CTX_SIZE and this bites before the deploy does; the boot's
    # nvidia-smi free is the measured truth.
    ctx="$(sed -nE 's/^CTX_SIZE=([0-9]+)$/\1/p' "$ENV_FILE")"
    kv_gib=$((ctx * 37 / 1048576))
    third_slot_kv=$(( (ctx + 114688) * 37 / 1048576 ))
    [ $((kv_gib + 14)) -le 24 ]
    [ $((third_slot_kv + 14)) -gt 24 ]
}

@test "the compute-buffer pair follows the env file and stays self-consistent" {
    # This endpoint ran on llama.cpp's own defaults until 2026-10-03, so the
    # contract is: whatever rung the repo carries is the rung the engine is
    # exec'd with — the number a benchmark attributes a prefill rate to must be
    # a repo value, never an engine default nobody wrote down. Asserted against
    # the env rather than a literal so a retune moves one file, not two.
    local env_batch env_ubatch
    env_batch="$(sed -nE 's/^BATCH_SIZE=([0-9]+)$/\1/p' "$ENV_FILE")"
    env_ubatch="$(sed -nE 's/^UBATCH_SIZE=([0-9]+)$/\1/p' "$ENV_FILE")"
    serve_argv
    [ "$status" -eq 0 ]
    [ "$(argv_value --batch-size)" = "$env_batch" ]
    [ "$(argv_value --ubatch-size)" = "$env_ubatch" ]
    # llama.cpp refuses ubatch > batch, so a retune that inverts the pair has
    # to fail here instead of at boot on a live endpoint.
    [ "$env_batch" -ge "$env_ubatch" ]

    # And an env that names neither flag still ships an explicit pair: the
    # serve script's fallbacks are written-down values, not blanks the engine
    # fills in silently.
    sed -i '/^BATCH_SIZE=/d;/^UBATCH_SIZE=/d' "$STAGE/test.env"
    serve_argv
    [ "$status" -eq 0 ]
    argv_value --batch-size | grep -qE '^[0-9]+$'
    argv_value --ubatch-size | grep -qE '^[0-9]+$'
}

@test "speculation is on: the full draft-mtp pair reaches the argv" {
    # Frank, 2026-10-06 evening: MTP back on. The head is IN the file, so
    # draft-mtp drafts against the main model's weights (no second model
    # copy). ngram-mod stays skipped: on a qwen35 hybrid it disables
    # recurrent-state rollback — a rejected draft corrupts the DeltaNet
    # state. The flags move as a set: the pair is present together or
    # absent together — assert both in the argv, and the env carries the
    # same contract. The serve script's defaults ship the pair even for an
    # env that names no drafter.
    serve_argv
    [ "$status" -eq 0 ]
    [ "$(argv_value --spec-type)" = "draft-mtp" ]
    [ "$(argv_value --spec-draft-n-max)" = "3" ]
    grep -qE '^SPEC_TYPE=draft-mtp$' "$ENV_FILE"
    grep -qE '^SPEC_DRAFT_N_MAX=3$' "$ENV_FILE"
}

@test "vision ships by default and MMPROJ_FILE empty opts out of the image path" {
    # The Swift GGUF carries no vision tensors, so the projector argument IS
    # the vision capability: no flag, no eyes.
    serve_argv
    [ "$status" -eq 0 ]
    [ "$(argv_value --mmproj)" = "$MODEL_DIR/$MM_STUB" ]

    # The documented opt-out must reach the engine as ABSENCE of the flag,
    # not as an argument pointing at an empty string.
    sed -i 's|^MMPROJ_FILE=.*|MMPROJ_FILE=|' "$STAGE/test.env"
    run env FRANK_SECONDARY_ENV_FILE="$STAGE/test.env" nvidia-modprobe=true bash "$SERVE"
    [ "$status" -eq 0 ]
    ! grep -qxF -- '--mmproj' <<<"$output"
}

@test "the fleet reasoning contract survives the reslice to two wide contexts" {
    serve_argv
    [ "$status" -eq 0 ]
    # deepseek format = thinking lands in reasoning_content, the field the
    # harness reads on this endpoint; --jinja is what makes
    # chat_template_kwargs reach the template at all.
    [ "$(argv_value --reasoning-format)" = "deepseek" ]
    argv_value --jinja >/dev/null
    grep -qxF -- '--jinja' <<<"$output"
}

@test "the serve script refuses a missing runtime, GGUF or projector" {
    rm -f "$MODEL_DIR/$MM_STUB"
    serve_argv
    [ "$status" -ne 0 ]
    [[ "$output" == *"frank-secondary: missing"* ]]

    rm -f "$RUNTIME_DIR/bin/llama-server"
    serve_argv
    [ "$status" -ne 0 ]
    [[ "$output" == *"frank-secondary: missing"* ]]
}

@test "the deploy handler gates on binary, GGUF and projector, then MainPID-hardens health" {
    grep -q 'deploy_llm_secondary' "$REMOTE_DEPLOY"
    grep -q 'LLM_SECONDARY_RUNTIME' "$REMOTE_DEPLOY"
    grep -q 'LLM_SECONDARY_MODEL_FILE' "$REMOTE_DEPLOY"
    grep -q 'LLM_SECONDARY_MMPROJ' "$REMOTE_DEPLOY"
    grep -q 'relink_unit frank-secondary' "$REMOTE_DEPLOY"
    grep -q 'systemctl enable frank-secondary.service' "$REMOTE_DEPLOY"
    grep -q '127.0.0.1:7771/health' "$REMOTE_DEPLOY"
    grep -q 'frank-secondary.service has no MainPID' "$REMOTE_DEPLOY"
}

@test "the two endpoints keep separate ports and the large handler never pkills llama-server" {
    # frank-large's gufo sweep must not take down frank-secondary, whose
    # process is llama-server on the SAME host since this swap.
    grep -q '^LISTEN_PORT=7771$' "$ENV_FILE"
    local large
    large="$(sed -n '/^deploy_llm_large() {/,/^}/p' "$REMOTE_DEPLOY")"
    ! grep -q 'pkill -x llama-server' <<<"$large"
}