Fix ASCII mode input — defer VT I/O to alternate screen, add WriteInPlace

- Move EnableVirtualTerminalIO from InitAsync to EnterAlternateScreen so
  Console.ReadKey works correctly in normal (non-alternate) mode
- Make EnableVirtualTerminalIO idempotent with a guard flag
- Use ReadKey(intercept: true) in normal mode — callers control echo
- Add TerminalViewportExtensions.WriteInPlace for in-place line updates
- MenuBase: show "> " prompt and echo selection in normal mode

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: sebgod

CLAUDE.md

@@ -17,3 +17,9 @@ The version is defined in two places — both must be updated together:
 The CI workflow composes the full package version from `VERSION_PREFIX`, `VERSION_REV`, and `VERSION_HASH`.
 
 When bumping the version, update both files to keep them in sync.
+
+## Key design notes
+
+- **Windows VT I/O** (`WindowsConsoleInput.EnableVirtualTerminalIO`) is only activated when entering alternate screen mode, not during `InitAsync()`. This keeps `Console.ReadKey` working correctly in normal (non-alternate) mode for ASCII/text-based UIs.
+- **`TryReadInput`** uses `intercept: true` in normal mode — keystrokes are never echoed. Callers control display feedback (e.g., via `WriteInPlace`).
+- **`MenuBase<T>`** in normal mode shows a `> ` prompt and echoes the selected item on confirmation.

src/Console.Lib/ITerminalViewport.cs

@@ -25,3 +25,16 @@ public interface ITerminalViewport
     /// <summary>Color mode supported by this terminal. Defaults to SGR-16.</summary>
     ColorMode ColorMode => ColorMode.Sgr16;
 }
+
+public static class TerminalViewportExtensions
+{
+    /// <summary>
+    /// Overwrites the current line with <paramref name="text"/> using carriage return,
+    /// padding with spaces to erase any previous content. Does not advance to the next line.
+    /// </summary>
+    public static void WriteInPlace(this ITerminalViewport terminal, string text)
+    {
+        var padding = Math.Max(0, terminal.Size.Width - text.Length);
+        terminal.Write($"\r{text}{new string(' ', padding)}\r{text}");
+    }
+}

src/Console.Lib/MenuBase.cs

@@ -36,6 +36,8 @@ protected async Task<int> ShowMenuAsync(
             terminal.WriteLine($"  {i + 1}) {items[i]}");
         }
 
+        terminal.Write("> ");
+
         while (!cancellationToken.IsCancellationRequested)
         {
             if (!terminal.HasInput())
@@ -49,7 +51,7 @@ protected async Task<int> ShowMenuAsync(
             var digit = input.Key - ConsoleKey.D1;
             if (digit >= 0 && digit < items.Length)
             {
-                terminal.WriteLine(items[digit]);
+                terminal.WriteLine($"{digit + 1}) {items[digit]}");
                 return digit;
             }
         }

src/Console.Lib/README.md

@@ -118,6 +118,16 @@ public interface ITerminalViewport
 
 `TermCell` holds the pixel dimensions of a single terminal character cell, queried from the terminal during initialization via the `\e[16t` control sequence.
 
+### TerminalViewportExtensions
+
+Extension methods for `ITerminalViewport`:
+
+```csharp
+// Overwrite the current line in-place using \r, padding with spaces to erase stale content.
+// Does not advance to the next line — ideal for status prompts and progress indicators.
+terminal.WriteInPlace("> waiting...");
+```
+
 ### IVirtualTerminal
 
 Extends `ITerminalViewport` with full terminal lifecycle: initialization, input reading, alternate screen buffer, and Sixel capability detection.
@@ -141,9 +151,10 @@ public interface IVirtualTerminal : ITerminalViewport, IAsyncDisposable
 1. Sets UTF-8 encoding for stdin/stdout
 2. Sends a Device Attributes request (`\e[0c`) to detect terminal capabilities (including Sixel support)
 3. Sends a cell size query (`\e[16t`) to determine pixel dimensions per character cell
-4. On Windows, enables virtual terminal I/O and mouse input via `WindowsConsoleInput`
 
-When entering the alternate screen, it enables VT200 mouse tracking with SGR extended coordinates (`\e[?1000h`, `\e[?1006h`), parses SGR mouse events from raw stdin, and normalizes cell coordinates to pixel coordinates using the cell size.
+When entering the alternate screen, it enables virtual terminal I/O and mouse input via `WindowsConsoleInput` (Windows only), then enables VT200 mouse tracking with SGR extended coordinates (`\e[?1000h`, `\e[?1006h`), parses SGR mouse events from raw stdin, and normalizes cell coordinates to pixel coordinates using the cell size.
+
+In normal (non-alternate) screen mode, `TryReadInput()` uses `Console.ReadKey(intercept: true)` — keystrokes are not echoed, giving the caller full control over display feedback.
 
 ### TerminalViewport
 

src/Console.Lib/VirtualTerminal.cs

@@ -46,11 +46,6 @@ public async Task InitAsync()
             }
         }
 
-        if (OperatingSystem.IsWindows())
-        {
-            WindowsConsoleInput.EnableVirtualTerminalIO();
-        }
-
         _initialized = true;
     }
 
@@ -82,6 +77,11 @@ public bool HasColorSupport
     /// </summary>
     public void EnterAlternateScreen()
     {
+        if (OperatingSystem.IsWindows())
+        {
+            WindowsConsoleInput.EnableVirtualTerminalIO();
+        }
+
         System.Console.Write("\e[?1049h"); // Enter alternate buffer
         System.Console.Write("\e[?25l");   // Hide cursor
         System.Console.Write("\e[?1000h"); // VT200 mouse tracking (basic button press/release and wheel)
@@ -138,7 +138,7 @@ public ConsoleInputEvent TryReadInput()
         }
         else
         {
-            var first = System.Console.ReadKey(intercept: false);
+            var first = System.Console.ReadKey(intercept: true);
 
             if (first.Key == ConsoleKey.F1)
             {

src/Console.Lib/WindowsConsoleInput.cs

@@ -41,13 +41,20 @@ private enum ConsoleMode : uint
     private static nint _outputHandle;
     private static ConsoleMode _originalInputMode;
     private static ConsoleMode _originalOutputMode;
+    private static bool _enabled;
 
     /// <summary>
     /// Enables virtual terminal input and output processing.
+    /// Only takes effect on the first call; subsequent calls are no-ops.
     /// </summary>
     /// <returns>True if virtual terminal input and output processing was enabled successfully.</returns>
     public static bool EnableVirtualTerminalIO()
     {
+        if (_enabled)
+        {
+            return true;
+        }
+
         _inputHandle = GetStdHandle(STD_INPUT_HANDLE);
         if (_inputHandle == nint.Zero || _inputHandle == new nint(-1))
         {
@@ -73,8 +80,9 @@ public static bool EnableVirtualTerminalIO()
             | ConsoleMode.ExtendedFlags
         ) & ~ConsoleMode.QuickEditMode;
 
-        return SetConsoleMode(_inputHandle, newInputMode)
+        _enabled = SetConsoleMode(_inputHandle, newInputMode)
             && SetConsoleMode(_outputHandle, _originalOutputMode | ConsoleMode.Processed | ConsoleMode.VirtualTerminalProcessing);
+        return _enabled;
     }
 
     /// <summary>