image: single dd-able system.img replaces vvfat+data-disk pair

mksystem.sh stages one FAT32 image: \bzImage + \initramfs.cpio.gz
(rsbl paths), \EFI\BOOT\BOOTX64.EFI (kernel direct by default,
--chain for rsboot), \etc\motd.txt, empty \bin\cli + \bin\gui,
seed files at the root.  --gpt wraps it in a partition table for real
USB dd targets.

Makefile: run/run-gui/debug attach only system.img on ide.0 (vvfat
lines deleted); stamp-based 'system' target rebuilds only when the
kernel is newer, so runtime writes survive reboots; system-fresh
wipes; inspect lists via mtools.  build-image.sh/mkdisk.sh removed.

test-disk.sh boots system.img with a throwaway OVMF varstore — a
stale NvVars makes the firmware skip the \EFI\BOOT fallback.
sendkeys.py pacing 50ms->250ms/1.5s: keystroke loss under host load
corrupted typed lines (guest-side PS/2 ring overflow).

Gate: test-disk PASS (fsck clean, file survives poweroff).

6 files changed, 226 insertions, 238 deletions

diff --git a/Makefile b/Makefile
index 4c57ac2..6f7f545 100644
--- a/Makefile
+++ b/Makefile
@@ -10,15 +10,14 @@ export INITRD=$(ESP_DIR)/initramfs.cpio.gz
 export BOOTLOADER=rsboot/rsboot.efi
 export OVMF=/usr/share/edk2/x64/OVMF.4m.fd
 export BOOT_EFI=$(ESP_DIR)/EFI/BOOT/BOOTX64.EFI
-# Attach a raw disk image as the SATA drive (disk.img -> ide.0, ESP -> ide.1).
-# Create one with: make disk   (or: ./scripts/mkdisk.sh)
-export DISK_IMG ?= /tmp/disk.img
+# Attach the single dd-able system image as the SATA drive (ide.0).
+# Create/re-create with: make system-fresh   (or: ./scripts/mksystem.sh --force)
+export SYSTEM_IMG ?= /tmp/system.img
 
-.PHONY: all run run-gui clean image debug release fmt bootloader boot-image disk disk-fresh inspect test-disk test-mouse test-gfx test-fault test-msg
 
 # ---- Build ---------------------------------------------------------------
 
-all: $(BZIMAGE) $(INITRD)
+.PHONY: all run run-gui clean image debug release fmt bootloader boot-image system system-fresh inspect test-disk test-mouse test-gfx test-fault test-msg
 
 release: PROFILE=release
 release: export PROFILE=release
@@ -43,13 +42,11 @@ $(INITRD): | $(ESP_DIR)
 
 # ---- QEMU runners --------------------------------------------------------
 
-run: all disk
+run: all system
         qemu-system-x86_64 \
           -bios $(OVMF) \
-          -drive file=$(DISK_IMG),format=raw,if=none,id=disk \
+          -drive file=$(SYSTEM_IMG),format=raw,if=none,id=disk \
           -device ide-hd,drive=disk,bus=ide.0 \
-          -drive file=fat:rw:$(ESP_DIR),format=raw,if=none,id=esp \
-          -device ide-hd,drive=esp,bus=ide.1 \
           -serial stdio \
           -m 256M \
           -machine q35 \
@@ -57,13 +54,11 @@ run: all disk
           -no-reboot \
           -display none
 
-run-gui: all disk
+run-gui: all system
         qemu-system-x86_64 \
           -bios $(OVMF) \
-          -drive file=$(DISK_IMG),format=raw,if=none,id=disk \
+          -drive file=$(SYSTEM_IMG),format=raw,if=none,id=disk \
           -device ide-hd,drive=disk,bus=ide.0 \
-          -drive file=fat:rw:$(ESP_DIR),format=raw,if=none,id=esp \
-          -device ide-hd,drive=esp,bus=ide.1 \
           -serial stdio \
           -m 256M \
           -machine q35 \
@@ -72,13 +67,11 @@ run-gui: all disk
           -vga std
 
 # GDB stub on :1234
-debug: all disk
+debug: all system
         qemu-system-x86_64 \
           -bios $(OVMF) \
-          -drive file=$(DISK_IMG),format=raw,if=none,id=disk \
+          -drive file=$(SYSTEM_IMG),format=raw,if=none,id=disk \
           -device ide-hd,drive=disk,bus=ide.0 \
-          -drive file=fat:rw:$(ESP_DIR),format=raw,if=none,id=esp \
-          -device ide-hd,drive=esp,bus=ide.1 \
           -serial stdio \
           -m 256M \
           -machine q35 \
@@ -90,23 +83,27 @@ debug: all disk
 # Boot from a raw disk image (delegates to boot-image.sh which builds the
 # full chain if the image doesn't exist yet)
 run-image: all
-        ./scripts/boot-image.sh rs-dos.img
 
-# ---- Data disk -----------------------------------------------------------
+# ---- System image --------------------------------------------------------
 
-# Create the FAT32 data disk if it doesn't exist.  Uses mkfs.fat -C (the
-# flag that actually creates the file) and seeds it from seed/.
-disk:
-        ./scripts/mkdisk.sh "$(DISK_IMG)"
+# One dd-able FAT32 image: kernel + ESP + /etc + /bin + seed data.
+# Stamp rule: rebuilt only when the kernel or this script changes — an
+# up-to-date image is NEVER touched, so files written at runtime survive.
+system:
+        @if [ ! -f "$(SYSTEM_IMG)" ] || [ "$$(stat -c %Y $(BZIMAGE) 2>/dev/null || echo 0)" -gt "$$(stat -c %Y $(SYSTEM_IMG) 2>/dev/null || echo 0)" ]; then \
+          ./scripts/mksystem.sh --force "$(SYSTEM_IMG)"; \
+        else \
+          echo "system image up to date: $(SYSTEM_IMG)"; \
+        fi
 
-# Re-format the data disk from scratch (wipes it, then re-seeds).
-disk-fresh:
-        ./scripts/mkdisk.sh --fresh "$(DISK_IMG)"
+# Re-create the system image from scratch (wipes runtime data).
+system-fresh:
+        ./scripts/mksystem.sh --force "$(SYSTEM_IMG)"
 
-# List the data disk contents with mtools (requires mtools).
+# List the system image contents with mtools (requires mtools).
 inspect:
         @command -v mdir >/dev/null 2>&1 || (echo "inspect needs mtools: sudo apt install mtools"; exit 1)
-        @mdir -i "$(DISK_IMG)"
+        @mdir -i "$(SYSTEM_IMG)" ::
 
 # Full automated round trip: build -> boot -> shell commands -> poweroff
 # -> fsck + mtools verification.
@@ -152,7 +149,7 @@ fmt:
 
 clean:
         cargo clean
-        rm -rf $(ESP_DIR) rs-dos.img
+        rm -rf $(ESP_DIR)
 
 help:
         @echo "rs-dos — Make targets"
@@ -163,16 +160,13 @@ help:
         @echo "  make image          build full chain disk image (bootloader + kernel)"
         @echo "  make boot-image     build + boot full chain via QEMU"
         @echo "  make run            QEMU serial console (direct boot, no bootloader)"
-        @echo "  make run-gui        QEMU with graphical window (GOP/PS2)"
-        @echo "  make debug          QEMU + GDB stub on :1234"
-        @echo "  make disk           create the data disk if missing (default /tmp/disk.img)"
-        @echo "  make disk-fresh     re-format the data disk (wipes it)"
-        @echo "  make inspect        list data disk contents (mtools)"
+        @echo "  make system         create the system image if stale/missing (/tmp/system.img)"
+        @echo "  make system-fresh   re-create the system image (wipes runtime data)"
+        @echo "  make inspect        list system image contents (mtools)"
         @echo "  make test-disk      automated disk round trip (build->boot->fsck)"
         @echo "  make clean          remove build artifacts"
         @echo "  make fmt            format Rust source"
-        @echo ""
-        @echo "Scripts:"
+        @echo "  ./scripts/mksystem.sh          build the dd-able system image"
         @echo "  ./scripts/boot.sh              quick direct boot (dev loop)"
         @echo "  ./scripts/mkdisk.sh            create/re-format the data disk"
         @echo "  ./scripts/test-disk.sh         automated disk round trip"
diff --git a/scripts/build-image.sh b/scripts/build-image.sh
deleted file mode 100755
index 02672ad..0000000
--- a/scripts/build-image.sh
+++ /dev/null
@@ -1,99 +0,0 @@
-#!/usr/bin/env bash
-#
-# scripts/build-image.sh — assemble a bootable rs-dos disk image (UEFI/GPT)
-#
-# Layout:
-#   Partition 1: ESP (FAT32) — rsboot bootloader + kernel
-#
-# Output:
-#   rs-dos.img (or custom path) — bootable raw disk image for UEFI
-#
-# Usage:
-#   ./scripts/build-image.sh [output.img]
-#
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
-
-cd "$PROJECT_DIR"
-
-BUILD_DIR="$PROJECT_DIR/build"
-ESP_DIR="$PROJECT_DIR/esp"
-
-IMAGE="${1:-$PROJECT_DIR/rs-dos.img}"
-TARGET=x86_64-unknown-uefi
-PROFILE=debug
-OUT_DIR="target/${TARGET}/${PROFILE}"
-
-BOOTLOADER="$BUILD_DIR/bootloader/BOOTX64.EFI"
-KERNEL="$OUT_DIR/rsdos.efi"
-BZIMAGE="$ESP_DIR/bzImage"
-INITRD="$ESP_DIR/initramfs.cpio.gz"
-BOOT_EFI="$ESP_DIR/EFI/BOOT/BOOTX64.EFI"
-
-ESP_START=2048 # 1 MiB offset (standard alignment)
-ESP_SIZE_MB=64
-
-IMAGE_SIZE_MB=$((ESP_SIZE_MB + 2)) # ESP + GPT gap + backup
-
-# ---- checks ----
-for cmd in sfdisk mkfs.vfat mcopy truncate dd; do
-        if ! command -v "$cmd" &>/dev/null; then
-                echo "Error: $cmd not found"
-                exit 1
-        fi
-done
-
-# ---- build kernel ----
-echo "[1/4] Building kernel..."
-cargo build --package rsdos --target x86_64-unknown-uefi ${CARGO_FLAGS:-}
-
-# ---- build bootloader ----
-echo "[2/4] Building bootloader..."
-if [ ! -f "$BOOTLOADER" ]; then
-        "$SCRIPT_DIR/build-bootloader.sh"
-fi
-
-# ---- assemble ESP ----
-echo "[3/4] Assembling ESP..."
-mkdir -p "$ESP_DIR/EFI/BOOT"
-cp "$KERNEL" "$BZIMAGE"
-cp "$BOOTLOADER" "$BOOT_EFI"
-if [ ! -f "$INITRD" ]; then
-        printf '' | gzip >"$INITRD"
-fi
-
-# ---- create disk image ----
-echo "[4/4] Writing disk image..."
-rm -f "$IMAGE"
-truncate -s "${IMAGE_SIZE_MB}M" "$IMAGE"
-
-# GPT partition table: single EFI System partition
-sfdisk --quiet "$IMAGE" <<EOF
-label: gpt
-type=U, start=$ESP_START, size=+
-EOF
-
-# Build FAT32 image with ESP contents
-ESP_IMG=$(mktemp)
-truncate -s "${ESP_SIZE_MB}M" "$ESP_IMG"
-mkfs.vfat -F 32 -n "RS-DOS" "$ESP_IMG" >/dev/null 2>&1
-
-# Copy files into FAT
-mmd -i "$ESP_IMG" ::/EFI 2>/dev/null || true
-mmd -i "$ESP_IMG" ::/EFI/BOOT 2>/dev/null || true
-mcopy -i "$ESP_IMG" "$BOOT_EFI" ::/EFI/BOOT/BOOTX64.EFI
-mcopy -i "$ESP_IMG" "$BZIMAGE" ::/bzImage 2>/dev/null || true
-mcopy -i "$ESP_IMG" "$INITRD" ::/initramfs.cpio.gz 2>/dev/null || true
-
-# Inject FAT into image at partition offset
-dd if="$ESP_IMG" of="$IMAGE" bs=512 seek="$ESP_START" conv=notrunc 2>/dev/null
-rm -f "$ESP_IMG"
-
-echo ""
-echo "=== Done: $IMAGE ==="
-ls -lh "$IMAGE"
-echo ""
-echo "Boot with:  ./scripts/boot-image.sh"
-echo "USB:        sudo dd if=$IMAGE of=/dev/sdX bs=4M status=progress"
diff --git a/scripts/mkdisk.sh b/scripts/mkdisk.sh
deleted file mode 100755
index 2c62f76..0000000
--- a/scripts/mkdisk.sh
+++ /dev/null
@@ -1,91 +0,0 @@
-#!/usr/bin/env bash
-#
-# scripts/mkdisk.sh — create (or re-create) the FAT32 data disk that the
-# kernel mounts at /disk.
-#
-# Usage:
-#   ./scripts/mkdisk.sh                 # create /tmp/disk.img (64M) if missing
-#   ./scripts/mkdisk.sh --fresh         # re-format (wipes the image!)
-#   ./scripts/mkdisk.sh --size 128M     # different size (default 64M)
-#   ./scripts/mkdisk.sh /path/img       # custom image path
-#   ./scripts/mkdisk.sh --no-seed       # skip the seed/ directory
-#   ./scripts/mkdisk.sh --label CRASHLOG # volume label (default RSDOS)
-#
-# The image is created with `mkfs.fat -C`, which is the option that
-# actually creates the file — plain `mkfs.fat` only writes into an
-# existing one.  Files from seed/ (if present) are copied in with mtools.
-#
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
-
-IMG="/tmp/disk.img"
-SIZE="64M"
-FRESH=0
-SEED_DIR="$PROJECT_DIR/seed"
-LABEL="RSDOS"
-
-while [ $# -gt 0 ]; do
-        case "$1" in
-        --fresh) FRESH=1 ;;
-        --size)
-                shift
-                SIZE="$1"
-                ;;
-        --no-seed) SEED_DIR="" ;;
-        --label)
-                shift
-                LABEL="$1"
-                ;;
-        --help | -h)
-                head -20 "$0" | grep "^#" | sed 's/^# \?//'
-                exit 0
-                ;;
-        *)
-                IMG="$1"
-                ;;
-        esac
-        shift
-done
-
-if [ -f "$IMG" ] && [ "$FRESH" -eq 0 ]; then
-        echo "mkdisk: $IMG already exists (use --fresh to re-format)"
-        exit 0
-fi
-
-if ! command -v mkfs.fat >/dev/null 2>&1; then
-        echo "mkdisk: mkfs.fat not found — install dosfstools (sudo apt install dosfstools)" >&2
-        exit 1
-fi
-
-# mkfs.fat sizes are 1024-byte blocks; accept M/G/K suffixes too.
-case "$SIZE" in
-*G) SIZE_BLOCKS=$((${SIZE%G} * 1024 * 1024)) ;;
-*M) SIZE_BLOCKS=$((${SIZE%M} * 1024)) ;;
-*K) SIZE_BLOCKS=$((${SIZE%K})) ;;
-*) SIZE_BLOCKS="$SIZE" ;;
-esac
-if [ -z "$SIZE_BLOCKS" ] || [ "$SIZE_BLOCKS" -le 0 ] 2>/dev/null; then
-        echo "mkdisk: bad size '$SIZE' (use e.g. 64M or 65536)" >&2
-        exit 1
-fi
-
-echo "mkdisk: creating $IMG ($SIZE FAT32, label $LABEL)"
-rm -f "$IMG"
-mkfs.fat -C -F 32 -n "$LABEL" "$IMG" "$SIZE_BLOCKS"
-
-if [ -n "$SEED_DIR" ] && [ -d "$SEED_DIR" ]; then
-        if ! command -v mcopy >/dev/null 2>&1; then
-                echo "mkdisk: warning: mcopy not found — skipping seed files (install mtools)" >&2
-        else
-                echo "mkdisk: seeding from $SEED_DIR/"
-                for f in "$SEED_DIR"/*; do
-                        [ -f "$f" ] || continue
-                        mcopy -i "$IMG" "$f" "::/$(basename "$f")"
-                        echo "  -> $(basename "$f")"
-                done
-        fi
-fi
-
-echo "mkdisk: done — boot with: make run   (or: ./scripts/boot.sh)"
diff --git a/scripts/mksystem.sh b/scripts/mksystem.sh
new file mode 100755
index 0000000..dfa481c
--- /dev/null
+++ b/scripts/mksystem.sh
@@ -0,0 +1,184 @@
+#!/usr/bin/env bash
+#
+# scripts/mksystem.sh — assemble the single dd-able rs-dos system image
+#
+# Replaces the old two-source setup (vvfat `esp/` directory for boot +
+# separate /tmp/disk.img for data).  One FAT32 image holds EVERYTHING:
+#
+#   \bzImage                 kernel (rsbl requires this exact path)
+#   \initramfs.cpio.gz       empty initramfs (rsbl requires it)
+#   \EFI\BOOT\BOOTX64.EFI    boot entry: the kernel (default) or rsboot
+#   \etc\motd.txt            seed config
+#   \bin\cli\  \bin\gui\     binary tree (empty until Phase 2/4 migrate tools)
+#   \*.txt                   seed files (seed/)
+#
+# The firmware boots from this image and the kernel mounts the same
+# volume at /disk/<UID>/ — boot medium and data medium are one disk.
+#
+# Usage:
+#   ./scripts/mksystem.sh [options] [output.img]     # default /tmp/system.img
+#
+# Options:
+#   --force        rebuild even if the image exists (Makefile stamps handle
+#                  normal freshness; without --force an existing image is kept,
+#                  so user files survive across reboots)
+#   --size NM      image size in MB (default 64)
+#   --chain        \EFI\BOOT\BOOTX64.EFI = rsboot bootloader (full chain:
+#                  firmware → rsboot → rsnix).  Default is the kernel itself
+#                  (direct: firmware → rsnix), matching the old dev loop.
+#   --gpt          wrap the FAT volume in a GPT partition table (for dd-ing
+#                  to real USB sticks whose firmware refuses superfloppies)
+#   --label NAME   FAT volume label (default RSDOS)
+#
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+PROJECT_DIR="$(dirname "$SCRIPT_DIR")"
+cd "$PROJECT_DIR"
+
+IMG="/tmp/system.img"
+SIZE_MB=64
+FORCE=0
+CHAIN=0
+GPT=0
+LABEL="RSDOS"
+
+while [ $# -gt 0 ]; do
+        case "$1" in
+        --force | --fresh)
+                FORCE=1
+                ;;
+        --size)
+                shift
+                SIZE_MB="$1"
+                ;;
+        --chain)
+                CHAIN=1
+                ;;
+        --gpt)
+                GPT=1
+                ;;
+        --label)
+                shift
+                LABEL="$1"
+                ;;
+        --help | -h)
+                head -30 "$0" | grep "^#" | sed 's/^# \?//'
+                exit 0
+                ;;
+        -*)
+                echo "mksystem: unknown option: $1" >&2
+                exit 1
+                ;;
+        *)
+                IMG="$1"
+                ;;
+        esac
+        shift
+done
+
+TARGET=x86_64-unknown-uefi
+PROFILE=debug
+OUT_DIR="target/$TARGET/$PROFILE"
+KERNEL="$OUT_DIR/rsdos.efi"
+BZIMAGE="esp/bzImage"
+INITRD="esp/initramfs.cpio.gz"
+BOOTLOADER="build/bootloader/BOOTX64.EFI"
+
+# ---- checks ----
+for cmd in mkfs.fat mcopy mmd; do
+        if ! command -v "$cmd" >/dev/null 2>&1; then
+                echo "mksystem: $cmd not found (install dosfstools + mtools)" >&2
+                exit 1
+        fi
+done
+if [ "$GPT" -eq 1 ]; then
+        for cmd in sfdisk truncate dd; do
+                if ! command -v "$cmd" >/dev/null 2>&1; then
+                        echo "mksystem: --gpt needs $cmd" >&2
+                        exit 1
+                fi
+        done
+fi
+
+if [ -f "$IMG" ] && [ "$FORCE" -eq 0 ]; then
+        echo "mksystem: $IMG already exists (use --force to re-create)"
+        exit 0
+fi
+
+# ---- build kernel ----
+if [ ! -f "$KERNEL" ]; then
+        echo "mksystem: building kernel..."
+        cargo build --package rsdos --target "$TARGET"
+fi
+
+# ---- build bootloader (chain mode only) ----
+if [ "$CHAIN" -eq 1 ] && [ ! -f "$BOOTLOADER" ]; then
+        echo "mksystem: building bootloader..."
+        "$SCRIPT_DIR/build-bootloader.sh"
+fi
+
+# ---- deploy kernel artifacts to esp/ (shared with the old layout) ----
+mkdir -p esp/EFI/BOOT
+cp "$KERNEL" "$BZIMAGE"
+[ -f "$INITRD" ] || printf '' | gzip >"$INITRD"
+
+# ---- create the FAT volume ----
+rm -f "$IMG"
+SIZE_BLOCKS=$((SIZE_MB * 1024)) # mkfs.fat counts 1024-byte blocks
+echo "mksystem: creating $IMG (${SIZE_MB}M FAT32, label $LABEL)"
+mkfs.fat -C -F 32 -n "$LABEL" "$IMG" "$SIZE_BLOCKS" >/dev/null
+
+echo "mksystem: staging system tree"
+mmd -i "$IMG" ::/EFI ::/EFI/BOOT ::/etc ::/bin ::/bin/cli ::/bin/gui
+mcopy -i "$IMG" "$BZIMAGE" ::/bzImage
+mcopy -i "$IMG" "$INITRD" ::/initramfs.cpio.gz
+if [ "$CHAIN" -eq 1 ]; then
+        mcopy -i "$IMG" "$BOOTLOADER" ::/EFI/BOOT/BOOTX64.EFI
+        echo "  \\EFI\\BOOT\\BOOTX64.EFI  <- rsboot (full chain)"
+else
+        mcopy -i "$IMG" "$KERNEL" ::/EFI/BOOT/BOOTX64.EFI
+        echo "  \\EFI\\BOOT\\BOOTX64.EFI  <- kernel (direct)"
+fi
+echo "  \\bzImage  \\initramfs.cpio.gz  \\bin{\\cli,\\gui}  \\etc"
+
+# Seed files: motd lives in \etc, everything else at the volume root.
+SEED_DIR="$PROJECT_DIR/seed"
+if [ -d "$SEED_DIR" ]; then
+        for f in "$SEED_DIR"/*; do
+                [ -f "$f" ] || continue
+                name="$(basename "$f")"
+                if [ "$name" = "motd.txt" ]; then
+                        mcopy -i "$IMG" "$f" ::/etc/"$name"
+                        echo "  \\etc\\$name"
+                else
+                        mcopy -i "$IMG" "$f" ::/"$name"
+                        echo "  \\$name"
+                fi
+        done
+fi
+
+# ---- optional GPT wrapper (real-hardware dd target) ----
+if [ "$GPT" -eq 1 ]; then
+        GPT_START=2048 # 1 MiB offset (standard alignment)
+        GPT_IMG="$(mktemp)"
+        truncate -s "${SIZE_MB}M" "$GPT_IMG"
+        dd if="$IMG" of="$GPT_IMG" bs=512 seek="$GPT_START" conv=notrunc 2>/dev/null
+        FINAL="$(mktemp)"
+        truncate -s "$((SIZE_MB + 2))M" "$FINAL"
+        sfdisk --quiet "$FINAL" <<EOF
+label: gpt
+type=U, start=$GPT_START, size=
+EOF
+        dd if="$GPT_IMG" of="$FINAL" bs=512 seek="$GPT_START" conv=notrunc 2>/dev/null
+        rm -f "$GPT_IMG"
+        mv "$FINAL" "$IMG"
+        echo "mksystem: wrapped in GPT (partition at LBA $GPT_START)"
+fi
+
+echo ""
+echo "=== Done: $IMG ==="
+ls -lh "$IMG"
+echo "Boot with:  make run   (or: make boot-image)"
+[ "$GPT" -eq 0 ] && echo "USB dd tip: add --gpt for firmwares that refuse superfloppies"
+exit 0
diff --git a/scripts/sendkeys.py b/scripts/sendkeys.py
index 1c97b33..a67903d 100755
--- a/scripts/sendkeys.py
+++ b/scripts/sendkeys.py
@@ -72,9 +72,9 @@ def type_line(sock, line):
         else:
             sys.stderr.write("warning: no sendkey mapping for %r\n" % ch)
             continue
-        time.sleep(0.05)
+        time.sleep(0.25)
     sendkey(sock, "ret")
-    time.sleep(0.7)
+    time.sleep(1.5)
 
 
 def main():
diff --git a/scripts/test-disk.sh b/scripts/test-disk.sh
index 0268fff..9ffb3c8 100755
--- a/scripts/test-disk.sh
+++ b/scripts/test-disk.sh
@@ -26,7 +26,7 @@ FRESH=0
 
 OVMF="${OVMF:-/usr/share/edk2/x64/OVMF.4m.fd}"
 QEMU="${QEMU:-qemu-system-x86_64}"
-IMG="${DISK_IMG:-/tmp/disk.img}"
+IMG="${SYSTEM_IMG:-/tmp/system.img}"
 ESP_DIR="$PROJECT_DIR/esp"
 QPID=/tmp/rsdos-test-qpid
 SOCK=/tmp/rsdos-test-qmon.sock
@@ -69,29 +69,29 @@ wait_qemu_exit() {
 echo "==> 1/6 build kernel (debug)"
 cargo build --package rsdos --target x86_64-unknown-uefi
 
-echo "==> 2/6 deploy to ESP + ensure disk image"
-mkdir -p "$ESP_DIR/EFI/BOOT"
-cp target/x86_64-unknown-uefi/debug/rsdos.efi "$ESP_DIR/EFI/BOOT/BOOTX64.EFI"
+echo "==> 2/6 ensure system image"
 if [ "$FRESH" -eq 1 ]; then
-        "$SCRIPT_DIR/mkdisk.sh" --fresh "$IMG"
+        "$SCRIPT_DIR/mksystem.sh" --force "$IMG"
 else
-        "$SCRIPT_DIR/mkdisk.sh" "$IMG"
+        "$SCRIPT_DIR/mksystem.sh" "$IMG"
 fi
 
 echo "==> 3/6 boot QEMU (headless)"
 kill "$(cat "$QPID" 2>/dev/null)" 2>/dev/null || true
 sleep 1
 rm -f "$SOCK" "$LOG"
-"$QEMU" -bios "$OVMF" \
+# Throwaway OVMF varstore: a stale/poisoned NvVars (e.g. left by the old
+# vvfat setup) makes the firmware skip the \EFI\BOOT fallback entirely.
+NV="/tmp/rsdos-test-ovmf-vars.fd"
+rm -f "$NV"
+cp /usr/share/edk2/x64/OVMF.4m.fd "$NV"
+"$QEMU" -bios "$NV" \
         -drive file="$IMG",format=raw,if=none,id=disk \
         -device ide-hd,drive=disk,bus=ide.0 \
-        -drive file=fat:rw:"$ESP_DIR",format=raw,if=none,id=esp \
-        -device ide-hd,drive=esp,bus=ide.1 \
         -serial file:"$LOG" \
         -monitor unix:"$SOCK",server,nowait \
         -m 256M -machine q35 -cpu qemu64 -no-reboot -display none \
         >"$QLOG" 2>&1 &
-echo $! >"$QPID"
 
 wait_log "$LOG" "boot: entering shell" 90 || fail "kernel never reached the shell"
 sleep 1