tty: AltGr+F1..F6 by default, and AltGr+-/+ to step

The sweet spot was available the whole time and I ruled it out by writing
"AltGr+anything" when the true statement is "AltGr+*letter*".

A Polish layout wants AltGr with a letter -- ą ć ę ł ń ó ś ź ż. AltGr with a
function key produces nothing on any layout, no window manager binds it, and
no application asks for it. It is the one combination the host, applications
and the keyboard layout all leave alone, and the previous three commits talked
themselves out of it on a technicality that was mine, not the hardware's.

Verified rather than argued, with QEMU sendkey and screendump hashes:

    AltGr+F2   -> tty2
    AltGr+F1   -> back, pixel-identical to the start
    AltGr+a    -> reaches zsh, so ą still types

That distinction is only expressible because Right Alt became its own modifier
bit two commits ago. Sharing ALT is harmless for typing -- neither is used to
look up a character -- and made this impossible to say.

Also added, since it was asked for in the same breath: minus and equals step
to the previous and next terminal, on whatever the chord's modifiers are. They
skip terminals that are not in use -- the same `opened` count VT_GETSTATE
reports -- because six terminals with two shells on them means four blank
screens in between, and cycling past those is worse than not having the key.

    AltGr+=  -> tty2, again -> wraps to tty1   (only two in use)
    AltGr+-  -> tty2

chvt -c still moves all of it, and `chvt` reports both halves.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VQ7Qx8E1q1M1bbCq8QLHS2

kernel/core/console.c

@@ -368,7 +368,8 @@ erase_one(struct vt *v)
 int
 console_vt_hotkey(int key)
 {
-  if (key < KEY_VT_SWITCH || key >= KEY_VT_SWITCH + NVT)
+  if (key != KEY_VT_PREV && key != KEY_VT_NEXT &&
+      (key < KEY_VT_SWITCH || key >= KEY_VT_SWITCH + NVT))
     return 0;
   // A program that called VT_SETMODE(VT_PROCESS) owns switching on this
   // terminal. Dropping the chord entirely would be worse than not binding it:
@@ -376,7 +377,9 @@ console_vt_hotkey(int key)
   // falls through to the line discipline as an ordinary key.
   if (!vt_kernel_switches())
     return 0;
-  vt_switch(key - KEY_VT_SWITCH);
+  if (key == KEY_VT_PREV)      vt_cycle(-1);
+  else if (key == KEY_VT_NEXT) vt_cycle(+1);
+  else                         vt_switch(key - KEY_VT_SWITCH);
   return 1;
 }
 
@@ -392,7 +395,8 @@ consoleintr(int (*getc)(void))
 
     // Terminal switching happens before the line discipline sees anything:
     // the chord is not input for the terminal you are leaving.
-    if (c >= KEY_VT_SWITCH && c < KEY_VT_SWITCH + NVT) {
+    if (c == KEY_VT_PREV || c == KEY_VT_NEXT ||
+        (c >= KEY_VT_SWITCH && c < KEY_VT_SWITCH + NVT)) {
       release(&input_lock);
       int taken = console_vt_hotkey(c);
       acquire(&input_lock);

kernel/dev/kbd.c

@@ -6,14 +6,19 @@
 #include "vt.h"   /* NVT -- how many terminals the chords reach */
 #include "input.h"
 
-// The chord, settable at run time through VT_SETCHORD. Defaults to
-// Ctrl+Shift+F1..F6: the host's display manager binds Ctrl+Alt+F<n> and
-// matches it loosely, so anything containing Ctrl+Alt never reaches a guest,
-// whatever else is held with it. Ctrl+Shift is not a VT chord on any host and
-// is not a character on any layout.
+// The chord, settable at run time through VT_SETCHORD.
 //
-// Zero modifiers disables the chord entirely; `chvt N` still works.
-uint vt_chord_mods = CTL | SHIFT;
+// AltGr+F1..F6 by default. Every other candidate is taken by the host, by
+// applications, or by the keyboard layout -- see include/kbd.h -- and AltGr
+// with a function key is taken by none of the three: a Polish layout wants
+// AltGr+*letter*, which still reaches the shell untouched, and no window
+// manager binds AltGr with an F-key.
+//
+// AltGr+minus and AltGr+equals step to the previous and next terminal on the
+// same modifiers, for when you have two and do not care which number they are.
+//
+// Zero modifiers disables all of it; `chvt N` still works.
+uint vt_chord_mods = RALT;
 uint vt_chord_base = SCAN_F1;
 
 int
@@ -84,9 +89,12 @@ kbdgetc(void)
   // Polish keystroke -- would switch terminals behind your back. Exactly left
   // Alt, and nothing else held.
   if (vt_chord_mods != 0 &&
-      (shift & (CTL | SHIFT | ALT | RALT)) == vt_chord_mods &&
-      data >= vt_chord_base && data < vt_chord_base + NVT)
-    return KEY_VT_SWITCH + (data - vt_chord_base);
+      (shift & (CTL | SHIFT | ALT | RALT)) == vt_chord_mods) {
+    if (data >= vt_chord_base && data < vt_chord_base + NVT)
+      return KEY_VT_SWITCH + (data - vt_chord_base);
+    if (data == SCAN_MINUS)  return KEY_VT_PREV;
+    if (data == SCAN_EQUALS) return KEY_VT_NEXT;
+  }
 
   c = charcode[shift & (CTL | SHIFT)][data];
   if(shift & CAPSLOCK){

kernel/dev/vt.c

@@ -718,3 +718,30 @@ vt_kernel_switches(void)
 {
   return vt_current()->mode != VT_PROCESS;
 }
+
+// Step to the previous or next terminal that is actually in use.
+//
+// Skipping the idle ones matters: six terminals with two shells on them means
+// four blank screens between the things you wanted, and cycling past them is
+// worse than not having the key. "In use" is `opened`, the same count
+// VT_GETSTATE reports, so what the key does and what `chvt` says are the same
+// fact.
+//
+// If nothing else is open this stays put rather than wrapping to a blank one.
+int
+vt_cycle(int dir)
+{
+  if (!vt_ready)
+    return -1;
+
+  for (int step = 1; step <= NVT; step++) {
+    int i = vt_active + dir * step;
+    while (i < 0)    i += NVT;
+    while (i >= NVT) i -= NVT;
+    if (i == vt_active)
+      break;
+    if (vts[i].opened > 0)
+      return vt_switch(i);
+  }
+  return 0;                      // nowhere else to go; not an error
+}