--- a/tests/unit/test_x11_terminal_mode.py
+++ /dev/null
@@ -1,651 +0,0 @@
-import importlib.machinery
-import importlib.util
-from pathlib import Path
-from unittest.mock import Mock
-
-import pytest
-
-from fenrirscreenreader.inputDriver.x11Driver import X
-from fenrirscreenreader.inputDriver.x11Driver import XK
-from fenrirscreenreader.inputDriver.x11Driver import driver as X11Driver
-
-
-def load_fenrir_entrypoint():
-    fenrir_path = Path(__file__).parents[2] / "src" / "fenrir"
-    loader = importlib.machinery.SourceFileLoader(
-        "fenrir_entrypoint_x11", str(fenrir_path)
-    )
-    spec = importlib.util.spec_from_loader(loader.name, loader)
-    module = importlib.util.module_from_spec(spec)
-    loader.exec_module(module)
-    return module
-
-
-@pytest.mark.unit
-def test_x11_mode_runs_in_foreground():
-    fenrir = load_fenrir_entrypoint()
-    args = fenrir.create_argument_parser().parse_args(["-x"])
-
-    assert fenrir.should_run_foreground(args) is True
-
-
-@pytest.mark.unit
-def test_removed_emulated_pty_flag_is_rejected():
-    fenrir = load_fenrir_entrypoint()
-    with pytest.raises(SystemExit):
-        fenrir.create_argument_parser().parse_args(["-e"])
-
-
-@pytest.mark.unit
-def test_removed_emulated_evdev_flag_is_rejected():
-    fenrir = load_fenrir_entrypoint()
-    with pytest.raises(SystemExit):
-        fenrir.create_argument_parser().parse_args(["-E"])
-
-
-@pytest.mark.unit
-def test_x11_cli_accepts_window_id():
-    fenrir = load_fenrir_entrypoint()
-    args = fenrir.create_argument_parser().parse_args(
-        ["-x", "--x11-window-id", "0x123"]
-    )
-
-    assert args.x11_window_id == "0x123"
-
-
-@pytest.mark.unit
-def test_x11_window_id_requires_x11_mode():
-    fenrir = load_fenrir_entrypoint()
-    args = fenrir.create_argument_parser().parse_args(
-        ["--x11-window-id", "0x123"]
-    )
-
-    is_valid, error = fenrir.validate_arguments(args)
-
-    assert is_valid is False
-    assert "--x11-window-id requires --x11" == error
-
-
-@pytest.mark.unit
-def test_x11_key_name_mapping_for_keypad_and_capslock():
-    x11 = X11Driver()
-
-    assert x11.keysym_name_to_key_name("KP_0") == "KEY_KP0"
-    assert x11.keysym_name_to_key_name("KP_Insert") == "KEY_KP0"
-    assert x11.keysym_name_to_key_name("Caps_Lock") == "KEY_CAPSLOCK"
-    assert x11.keysym_name_to_key_name("Super_L") == "KEY_LEFTMETA"
-    assert x11.keysym_name_to_key_name("Multi_key") == "KEY_COMPOSE"
-    assert x11.keysym_name_to_key_name("Next") == "KEY_PAGEDOWN"
-    assert x11.keysym_name_to_key_name("Prior") == "KEY_PAGEUP"
-    assert x11.keysym_name_to_key_name("a") == "KEY_A"
-    assert x11.keysym_name_to_key_name("F10") == "KEY_F10"
-    assert x11.keysym_name_to_key_name("plus") == "KEY_EQUAL"
-    assert x11.keysym_name_to_key_name("+") == "KEY_EQUAL"
-    assert x11.keysym_name_to_key_name("underscore") == "KEY_MINUS"
-    assert x11.keysym_name_to_key_name("_") == "KEY_MINUS"
-
-
-@pytest.mark.unit
-@pytest.mark.parametrize(
-    ("keysym_name", "key_name"),
-    [
-        ("BackSpace", "KEY_BACKSPACE"),
-        ("Tab", "KEY_TAB"),
-        ("Return", "KEY_ENTER"),
-        ("Escape", "KEY_ESC"),
-        ("Delete", "KEY_DELETE"),
-    ],
-)
-def test_x11_special_keysyms_use_symbolic_names(keysym_name, key_name):
-    x11 = X11Driver()
-    resolved_name = x11.keysym_to_name(XK.string_to_keysym(keysym_name))
-
-    assert resolved_name == keysym_name
-    assert x11.keysym_name_to_key_name(resolved_name) == key_name
-
-
-@pytest.mark.unit
-def test_x11_keycode_mapping_prefers_keypad_aliases():
-    x11 = X11Driver()
-    x11.display = Mock()
-    keysyms = {
-        0: XK.string_to_keysym("Up"),
-        1: XK.string_to_keysym("KP_8"),
-        2: 0,
-        3: 0,
-        4: 0,
-        5: 0,
-        6: 0,
-        7: 0,
-    }
-    x11.display.keycode_to_keysym.side_effect = lambda keycode, column: keysyms[column]
-
-    assert x11.keycode_to_key_name(80) == "KEY_KP8"
-
-
-@pytest.mark.unit
-def test_x11_keycode_mapping_preserves_plain_insert():
-    x11 = X11Driver()
-    x11.display = Mock()
-    keysyms = {
-        0: XK.string_to_keysym("Insert"),
-        1: 0,
-        2: 0,
-        3: 0,
-        4: 0,
-        5: 0,
-        6: 0,
-        7: 0,
-    }
-    x11.display.keycode_to_keysym.side_effect = lambda keycode, column: keysyms[column]
-
-    assert x11.keycode_to_key_name(118) == "KEY_INSERT"
-
-
-@pytest.mark.unit
-def test_x11_keycode_mapping_detects_keypad_insert():
-    x11 = X11Driver()
-    x11.display = Mock()
-    keysyms = {
-        0: XK.string_to_keysym("Insert"),
-        1: XK.string_to_keysym("KP_Insert"),
-        2: 0,
-        3: 0,
-        4: 0,
-        5: 0,
-        6: 0,
-        7: 0,
-    }
-    x11.display.keycode_to_keysym.side_effect = lambda keycode, column: keysyms[column]
-
-    assert x11.keycode_to_key_name(90) == "KEY_KP0"
-
-
-@pytest.mark.unit
-def test_x11_key_name_to_keysym_names_includes_numlock_aliases():
-    x11 = X11Driver()
-
-    assert x11.key_name_to_keysym_names("KEY_KP0") == ["KP_0", "KP_Insert"]
-    assert "KP_Delete" in x11.key_name_to_keysym_names("KEY_KPDOT")
-    assert "Caps_Lock" in x11.key_name_to_keysym_names("KEY_CAPSLOCK")
-    assert "Super_L" in x11.key_name_to_keysym_names("KEY_META")
-    assert "Meta_R" in x11.key_name_to_keysym_names("KEY_META")
-    assert x11.key_name_to_keysym_names("KEY_COMPOSE") == ["Multi_key"]
-    assert "Next" in x11.key_name_to_keysym_names("KEY_PAGEDOWN")
-    assert "Prior" in x11.key_name_to_keysym_names("KEY_PAGEUP")
-    assert x11.key_name_to_keysym_names("KEY_EQUAL") == ["equal", "plus"]
-    assert x11.key_name_to_keysym_names("KEY_MINUS") == [
-        "minus",
-        "underscore",
-    ]
-
-
-@pytest.mark.unit
-def test_x11_should_emit_unbound_mapped_keys_for_speech_interrupt():
-    x11 = X11Driver()
-    x11.interesting_keys = set()
-
-    assert x11.should_emit_key("KEY_ESC") is True
-    assert x11.should_emit_key("KEY_ENTER") is True
-
-
-@pytest.mark.unit
-@pytest.mark.parametrize(
-    ("keysym_name", "key_name"),
-    [
-        ("-", "KEY_MINUS"),
-        ("=", "KEY_EQUAL"),
-        ("[", "KEY_LEFTBRACE"),
-        ("]", "KEY_RIGHTBRACE"),
-        ("\\", "KEY_BACKSLASH"),
-        (";", "KEY_SEMICOLON"),
-        ("'", "KEY_APOSTROPHE"),
-        ("`", "KEY_GRAVE"),
-        (",", "KEY_COMMA"),
-        (".", "KEY_DOT"),
-        ("/", "KEY_SLASH"),
-    ],
-)
-def test_x11_maps_literal_punctuation_keysyms(keysym_name, key_name):
-    x11 = X11Driver()
-
-    assert x11.keysym_name_to_key_name(keysym_name) == key_name
-
-
-@pytest.mark.unit
-def test_x11_build_passive_grabs_for_fenrir_keys_and_shortcuts():
-    x11 = X11Driver()
-    input_manager = Mock(convert_event_name=lambda key: key)
-    x11.env = {
-        "input": {
-            "fenrir_key": ["KEY_KP0", "KEY_META"],
-            "script_key": [],
-        },
-        "rawBindings": {
-            "fenrir_combo": [1, ["KEY_FENRIR", "KEY_KP8"]],
-            "bare_keypad": [1, ["KEY_KP5"]],
-            "ctrl_keypad": [1, ["KEY_CTRL", "KEY_KP2"]],
-            "meta_combo": [1, ["KEY_FENRIR", "KEY_BACKSPACE"]],
-        },
-        "runtime": {"InputManager": input_manager},
-    }
-
-    grabs = x11.build_passive_grabs()
-
-    assert ("KEY_KP0", 0, True) in grabs
-    assert ("KEY_META", 0, True) in grabs
-    assert ("KEY_NUMLOCK", 0, True) in grabs
-    assert ("KEY_KP5", 0, False) in grabs
-    assert ("KEY_KP2", X.ControlMask, False) in grabs
-    assert ("KEY_BACKSPACE", X.Mod4Mask, True) in grabs
-
-
-@pytest.mark.unit
-@pytest.mark.parametrize(
-    "modifier_mask",
-    [X.ControlMask, X.ShiftMask, X.Mod1Mask],
-)
-def test_x11_poll_modifier_interrupt_keys_interrupts_without_input_events(
-    modifier_mask,
-):
-    x11 = X11Driver()
-    x11.active = True
-    x11.modifier_interrupt_state = 0
-    x11.modifier_state = 0
-    x11.root = Mock()
-    x11.root.query_pointer.return_value = Mock(mask=modifier_mask)
-    settings_manager = Mock()
-    settings_manager.get_setting_as_bool.return_value = True
-    settings_manager.get_setting.return_value = ""
-    output_manager = Mock()
-    x11.env = {
-        "input": {"event_buffer": []},
-        "runtime": {
-            "SettingsManager": settings_manager,
-            "OutputManager": output_manager,
-            "DebugManager": Mock(),
-        },
-    }
-
-    x11.poll_modifier_interrupt_keys()
-
-    output_manager.interrupt_output_async.assert_called_once()
-    assert x11.env["input"]["event_buffer"] == []
-
-    output_manager.interrupt_output_async.reset_mock()
-    x11.root.query_pointer.return_value = Mock(mask=0)
-
-    x11.poll_modifier_interrupt_keys()
-
-    output_manager.interrupt_output_async.assert_not_called()
-    assert x11.env["input"]["event_buffer"] == []
-
-
-@pytest.mark.unit
-def test_x11_optional_modifier_masks_can_exclude_numlock():
-    x11 = X11Driver()
-    x11.num_lock_mask = X.Mod2Mask
-
-    masks = x11.optional_modifier_masks(0, include_num_lock=False)
-
-    assert X.Mod2Mask not in masks
-    assert X.Mod2Mask | X.LockMask not in masks
-
-
-@pytest.mark.unit
-def test_x11_get_led_state_reads_cached_lock_modifiers_without_x_round_trip():
-    x11 = X11Driver()
-    x11.num_lock_mask = X.Mod2Mask
-    x11.modifier_state = X.Mod2Mask | X.LockMask
-    x11.root = Mock()
-
-    assert x11.get_led_state(0) is True
-    assert x11.get_led_state(1) is True
-    assert x11.get_led_state(2) is False
-    x11.root.query_pointer.assert_not_called()
-
-
-@pytest.mark.unit
-def test_x11_update_modifier_state_tracks_event_masks_and_lock_toggles():
-    x11 = X11Driver()
-    x11.num_lock_mask = X.Mod2Mask
-
-    x11.update_modifier_state_from_event(
-        {
-            "event_name": "KEY_KP8",
-            "event_state": 1,
-            "event_raw_state": X.Mod2Mask,
-        }
-    )
-    assert x11.get_led_state(0) is True
-
-    x11.update_modifier_state_from_event(
-        {
-            "event_name": "KEY_NUMLOCK",
-            "event_state": 1,
-            "event_raw_state": X.Mod2Mask,
-        }
-    )
-    assert x11.get_led_state(0) is False
-
-    x11.update_modifier_state_from_event(
-        {
-            "event_name": "KEY_CAPSLOCK",
-            "event_state": 1,
-            "event_raw_state": 0,
-        }
-    )
-    assert x11.get_led_state(1) is True
-
-
-@pytest.mark.unit
-def test_x11_parse_window_id_accepts_decimal_and_hex():
-    x11 = X11Driver()
-
-    assert x11.parse_window_id("123") == 123
-    assert x11.parse_window_id("0x123") == 0x123
-    assert x11.parse_window_id("") is None
-
-
-@pytest.mark.unit
-def test_x11_write_event_buffer_replays_grabbed_key_press():
-    x11 = X11Driver()
-    x11._initialized = True
-    x11.display = Mock()
-    x11.env = {
-        "input": {
-            "event_buffer": [
-                {
-                    "event_name": "KEY_LEFTMETA",
-                    "event_state": 1,
-                    "event_type": X.KeyPress,
-                    "event_x_time": 1234,
-                }
-            ]
-        }
-    }
-
-    x11.write_event_buffer()
-
-    x11.display.allow_events.assert_called_once_with(X.ReplayKeyboard, 1234)
-    assert x11.env["input"]["event_buffer"] == []
-
-
-@pytest.mark.unit
-def test_x11_write_event_buffer_does_not_replay_key_release():
-    x11 = X11Driver()
-    x11._initialized = True
-    x11.display = Mock()
-    x11.env = {
-        "input": {
-            "event_buffer": [
-                {
-                    "event_name": "KEY_LEFTMETA",
-                    "event_state": 0,
-                    "event_type": X.KeyRelease,
-                    "event_x_time": 1235,
-                }
-            ]
-        }
-    }
-
-    x11.write_event_buffer()
-
-    x11.display.allow_events.assert_not_called()
-    assert x11.env["input"]["event_buffer"] == []
-
-
-@pytest.mark.unit
-def test_x11_help_capture_grabs_and_releases_keyboard():
-    x11 = X11Driver()
-    x11._initialized = True
-    x11.window = Mock()
-    x11.window.grab_keyboard.return_value = X.GrabSuccess
-    x11.display = Mock()
-    x11.env = {"runtime": {"DebugManager": Mock()}}
-
-    assert x11.set_help_capture(True) is True
-    x11.window.grab_keyboard.assert_called_once_with(
-        False,
-        X.GrabModeAsync,
-        X.GrabModeAsync,
-        X.CurrentTime,
-    )
-    assert x11.help_keyboard_grabbed is True
-
-    assert x11.set_help_capture(False) is True
-    x11.display.ungrab_keyboard.assert_called_once_with(X.CurrentTime)
-    x11.display.sync.assert_called_once_with()
-    assert x11.help_keyboard_grabbed is False
-
-
-@pytest.mark.unit
-def test_x11_help_capture_reports_failed_grab():
-    x11 = X11Driver()
-    x11._initialized = True
-    x11.window = Mock()
-    x11.window.grab_keyboard.return_value = X.AlreadyGrabbed
-    x11.display = Mock()
-    x11.env = {"runtime": {"DebugManager": Mock()}}
-
-    assert x11.set_help_capture(True) is False
-    assert x11.help_keyboard_grabbed is False
-
-
-@pytest.mark.unit
-def test_x11_help_capture_retries_failed_keyboard_release():
-    x11 = X11Driver()
-    x11._initialized = True
-    x11.help_keyboard_grabbed = True
-    x11.window = Mock()
-    x11.display = Mock()
-    x11.display.sync.side_effect = RuntimeError("ungrab failed")
-    x11.env = {"runtime": {"DebugManager": Mock()}}
-
-    assert x11.set_help_capture(False) is False
-    assert x11.display.ungrab_keyboard.call_count == 3
-    assert x11.help_keyboard_grabbed is True
-
-
-@pytest.mark.unit
-def test_x11_map_event_keeps_x_event_time_for_replay():
-    x11 = X11Driver()
-    x11.keycode_to_key_name = Mock(return_value="KEY_LEFTMETA")
-    event = Mock(type=X.KeyPress, detail=133, state=X.Mod4Mask, time=5678)
-
-    input_event = x11.map_event(event)
-
-    assert input_event["event_x_time"] == 5678
-
-
-@pytest.mark.unit
-def test_x11_find_num_lock_mask_uses_modifier_mapping():
-    x11 = X11Driver()
-    x11.display = Mock()
-    x11.display.keysym_to_keycode.return_value = 77
-    x11.display.get_modifier_mapping.return_value = [
-        [],
-        [],
-        [],
-        [],
-        [77],
-        [],
-        [],
-        [],
-    ]
-
-    assert x11.find_num_lock_mask() == X.Mod2Mask
-
-
-@pytest.mark.unit
-def test_x11_handle_key_event_keeps_event_buffer_for_input_manager():
-    x11 = X11Driver()
-    x11.active = True
-    x11.interesting_keys = {"KEY_KP0"}
-    x11.env = {
-        "input": {
-            "curr_input": [],
-            "event_buffer": [],
-        },
-        "runtime": {
-            "InputManager": Mock(convert_event_name=lambda key: key),
-            "DebugManager": Mock(),
-        },
-    }
-    event_queue = Mock()
-    event = Mock(type=X.KeyPress, detail=90, state=0)
-    x11.keycode_to_key_name = Mock(return_value="KEY_KP0")
-
-    x11.handle_x_event(event, event_queue)
-
-    assert x11.env["input"]["event_buffer"][0]["event_name"] == "KEY_KP0"
-    event_queue.put.assert_called_once()
-
-
-@pytest.mark.unit
-@pytest.mark.parametrize(
-    ("event_type", "event_mode"),
-    [
-        (X.FocusOut, X.NotifyGrab),
-        (X.FocusIn, X.NotifyUngrab),
-    ],
-)
-def test_x11_transient_grab_focus_events_preserve_input_state(
-    event_type, event_mode
-):
-    x11 = X11Driver()
-    x11.active = True
-    x11.clear_event_buffer = Mock()
-    x11.reset_input_state = Mock()
-    event = Mock(type=event_type, mode=event_mode)
-
-    x11.handle_x_event(event, Mock())
-
-    assert x11.active is True
-    x11.clear_event_buffer.assert_not_called()
-    x11.reset_input_state.assert_not_called()
-
-
-@pytest.mark.unit
-def test_x11_normal_focus_out_resets_input_state():
-    x11 = X11Driver()
-    x11.active = True
-    x11.reset_input_state = Mock()
-    output_manager = Mock()
-    x11.env = {"runtime": {"OutputManager": output_manager}}
-    event = Mock(type=X.FocusOut, mode=X.NotifyNormal)
-
-    x11.handle_x_event(event, Mock())
-
-    assert x11.active is False
-    x11.reset_input_state.assert_called_once_with()
-    output_manager.interrupt_output_async.assert_called_once_with()
-
-
-@pytest.mark.unit
-def test_x11_reports_target_focus_state():
-    x11 = X11Driver()
-    x11.active = False
-
-    assert x11.is_active() is False
-
-    x11.active = True
-
-    assert x11.is_active() is True
-
-
-@pytest.mark.unit
-def test_x11_fenrir_press_emits_modifiers_from_raw_state_first():
-    x11 = X11Driver()
-    x11.active = True
-    x11.fenrir_keys = {"KEY_KP0"}
-    x11.interesting_keys = {"KEY_KP0"}
-    x11.env = {
-        "input": {
-            "curr_input": [],
-            "event_buffer": [],
-        },
-        "runtime": {
-            "InputManager": Mock(convert_event_name=lambda key: key),
-            "DebugManager": Mock(),
-        },
-    }
-    event_queue = Mock()
-    event = Mock(type=X.KeyPress, detail=90, state=X.ControlMask)
-    x11.keycode_to_key_name = Mock(return_value="KEY_KP0")
-
-    x11.handle_x_event(event, event_queue)
-
-    modifier_event = event_queue.put.call_args_list[0].args[0]
-    fenrir_event = event_queue.put.call_args_list[1].args[0]
-    assert modifier_event["data"]["event_name"] == "KEY_CTRL"
-    assert modifier_event["data"]["event_state"] == 1
-    assert fenrir_event["data"]["event_name"] == "KEY_KP0"
-
-
-@pytest.mark.unit
-def test_x11_fenrir_release_balances_synthesized_modifiers():
-    x11 = X11Driver()
-    x11.active = True
-    x11.fenrir_keys = {"KEY_KP0"}
-    x11.interesting_keys = {"KEY_KP0"}
-    x11.command_key_active = True
-    x11.chord_modifiers = {"KEY_CTRL"}
-    x11.env = {
-        "input": {
-            "curr_input": ["KEY_CTRL", "KEY_FENRIR"],
-            "event_buffer": [],
-        },
-        "runtime": {
-            "InputManager": Mock(convert_event_name=lambda key: key),
-            "DebugManager": Mock(),
-        },
-    }
-    event_queue = Mock()
-    event = Mock(type=X.KeyRelease, detail=90, state=X.ControlMask)
-    x11.keycode_to_key_name = Mock(return_value="KEY_KP0")
-
-    x11.handle_x_event(event, event_queue)
-
-    fenrir_event = event_queue.put.call_args_list[0].args[0]
-    modifier_event = event_queue.put.call_args_list[1].args[0]
-    assert fenrir_event["data"]["event_name"] == "KEY_KP0"
-    assert modifier_event["data"]["event_name"] == "KEY_CTRL"
-    assert modifier_event["data"]["event_state"] == 0
-
-
-@pytest.mark.unit
-def test_x11_fenrir_release_balances_held_chord_key():
-    x11 = X11Driver()
-    x11.active = True
-    x11.fenrir_keys = {"KEY_KP0"}
-    x11.interesting_keys = {"KEY_KP0", "KEY_KP9"}
-    x11.env = {
-        "input": {
-            "curr_input": [],
-            "event_buffer": [],
-        },
-        "runtime": {
-            "InputManager": Mock(convert_event_name=lambda key: key),
-            "DebugManager": Mock(),
-        },
-    }
-    event_queue = Mock()
-    key_names = {90: "KEY_KP0", 81: "KEY_KP9"}
-    x11.keycode_to_key_name = Mock(
-        side_effect=lambda keycode, state=0: key_names[keycode]
-    )
-
-    x11.handle_x_event(
-        Mock(type=X.KeyPress, detail=90, state=0), event_queue
-    )
-    x11.handle_x_event(
-        Mock(type=X.KeyPress, detail=81, state=0), event_queue
-    )
-    x11.handle_x_event(
-        Mock(type=X.KeyRelease, detail=90, state=0), event_queue
-    )
-
-    synthetic_release = event_queue.put.call_args_list[-1].args[0]
-    assert synthetic_release["data"]["event_name"] == "KEY_KP9"
-    assert synthetic_release["data"]["event_state"] == 0
