fix(telnetd): convert to proper daemon mode

- Remove MAX_ATTEMPTS limit in accept loop (was causing timeout)
- Remove MAX_CYCLES limit in relay loop (was limiting session time)
- Accept connections forever in daemon mode
- Continue listening after connection closes

Also add docs/planning/INIT_SYSTEM_PLAN.md documenting the next
major milestone: proper init system with virtual consoles.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: ryanbreen

docs/planning/INIT_SYSTEM_PLAN.md

@@ -0,0 +1,230 @@
+# Init System & Virtual Consoles Implementation Plan
+
+## Overview
+
+Replace `init_shell` as PID 1 with a proper init system that:
+1. Manages system services (telnetd, etc.)
+2. Supports multiple interaction modes (console, telnet, serial)
+3. Spawns shells on virtual consoles like Linux
+4. Handles process supervision and cleanup
+
+## Current State
+
+- `init_shell` runs as PID 1 (interactive mode)
+- No service management
+- No virtual console support
+- telnetd exists but has test limits and must be manually started
+
+## Architecture
+
+### Init Process Responsibilities
+
+```
+/sbin/init (PID 1)
+├── Parse /etc/inittab or built-in config
+├── Mount filesystems (future)
+├── Start services
+│   ├── telnetd on port 2323
+│   └── (future: sshd, httpd, etc.)
+├── Spawn getty on virtual consoles
+│   ├── /dev/tty1 → getty → login → shell
+│   ├── /dev/tty2 → getty → login → shell
+│   └── /dev/ttyS0 → getty (serial console)
+├── Reap orphaned processes (wait for zombies)
+└── Handle shutdown signals
+```
+
+### Virtual Console Model (Linux-style)
+
+```
+/dev/console  - System console (kernel messages)
+/dev/tty0     - Current virtual console
+/dev/tty1-6   - Virtual text consoles (Alt+F1 through Alt+F6)
+/dev/ttyS0    - Serial console (QEMU -serial stdio)
+/dev/pts/*    - Pseudo-terminals (telnet, ssh, screen)
+```
+
+## Implementation Phases
+
+### Phase 1: Basic Init Structure
+
+**Goal:** Create init binary that starts services and shells
+
+**Files:**
+- `userspace/tests/init.rs` - Main init process
+- `kernel/src/main.rs` - Load init instead of init_shell
+
+**Behavior:**
+```rust
+// init.rs pseudocode
+fn main() {
+    // We are PID 1
+    println!("Breenix init starting...");
+
+    // Start telnetd in background
+    if fork() == 0 {
+        exec("/bin/telnetd");
+    }
+
+    // Start shell on console
+    if fork() == 0 {
+        exec("/bin/init_shell");
+    }
+
+    // Reap zombies forever
+    loop {
+        waitpid(-1, WNOHANG);
+        yield();
+    }
+}
+```
+
+### Phase 2: Virtual Console Infrastructure
+
+**Goal:** Implement /dev/ttyN virtual consoles
+
+**Kernel Changes:**
+- `kernel/src/tty/vt.rs` - Virtual terminal multiplexer
+- `kernel/src/tty/console.rs` - Console output routing
+- Support Alt+Fn switching between consoles
+
+**Each VT has:**
+- Input buffer (keyboard → VT)
+- Output buffer (VT → screen)
+- Foreground process group
+- Termios settings
+
+### Phase 3: Getty/Login
+
+**Goal:** Proper login flow on consoles
+
+**Files:**
+- `userspace/tests/getty.rs` - Open TTY, prompt for login
+- `userspace/tests/login.rs` - Authenticate and exec shell (future)
+
+**Flow:**
+```
+init spawns: getty /dev/tty1
+getty: opens /dev/tty1, sets termios, prints "login: "
+getty: reads username, execs login
+login: (future: authenticate), execs shell
+shell: runs as user session
+```
+
+For now (single-user): getty → shell directly
+
+### Phase 4: Service Management
+
+**Goal:** Structured service start/stop
+
+**Config format (simple):**
+```
+# /etc/inittab or built-in
+::sysinit:/bin/mount -a
+::respawn:/sbin/getty /dev/tty1
+::respawn:/sbin/getty /dev/tty2
+::once:/sbin/telnetd
+```
+
+**Respawn logic:**
+- If service exits, restart it
+- Rate-limit restarts (don't spin)
+
+### Phase 5: Serial Console Support
+
+**Goal:** Shell accessible via QEMU serial
+
+**Current:** Kernel output goes to serial
+**Needed:** Bidirectional serial I/O for shell
+
+**Approach:**
+- `/dev/ttyS0` backed by UART 0x3F8
+- getty spawns on ttyS0
+- Serial becomes interactive shell
+
+## File Structure
+
+```
+userspace/tests/
+├── init.rs          # PID 1 init process
+├── getty.rs         # TTY login prompt
+├── init_shell.rs    # Interactive shell (unchanged)
+└── telnetd.rs       # Telnet server (remove test limits)
+
+kernel/src/tty/
+├── mod.rs           # TTY subsystem
+├── pty/             # Pseudo-terminals (done)
+├── vt.rs            # Virtual terminal multiplexer (new)
+└── console.rs       # Console driver (new)
+```
+
+## Migration Path
+
+### Step 1: Create init binary
+- Copy minimal logic from init_shell
+- Fork telnetd and shell
+- Reap zombies
+
+### Step 2: Update kernel to load init
+- Change `kernel_main_continue()` to load `/sbin/init`
+- Keep init_shell as fallback
+
+### Step 3: Fix telnetd
+- Remove MAX_ATTEMPTS/MAX_CYCLES limits
+- Run as proper daemon
+
+### Step 4: Add virtual consoles
+- Implement /dev/tty1-6
+- Add console switching
+
+### Step 5: Add getty
+- Simple program: open tty, print prompt, exec shell
+
+## Success Criteria
+
+1. **Boot sequence:**
+   ```
+   Kernel starts
+   init (PID 1) starts
+   telnetd starts (PID 2)
+   getty/shell starts on console (PID 3)
+   ```
+
+2. **Telnet works:**
+   ```bash
+   # From host
+   telnet localhost 2323
+   # Get shell prompt
+   breenix>
+   ```
+
+3. **Process tree:**
+   ```
+   PID 1: init
+   ├── PID 2: telnetd
+   │   └── PID N: init_shell (per connection)
+   └── PID 3: init_shell (console)
+   ```
+
+4. **Zombie reaping:**
+   - Exited processes don't accumulate
+   - init waits on children
+
+## Open Questions
+
+1. **Config format:** Built-in vs /etc/inittab file?
+   - Start built-in, add file support later
+
+2. **Console switching:** How to handle Alt+Fn in QEMU?
+   - QEMU may intercept these; may need different keys
+
+3. **Serial vs VGA console:** Which is primary?
+   - Serial for now (easier in QEMU)
+   - VGA console requires framebuffer work
+
+## References
+
+- Linux init(8) man page
+- systemd architecture (for modern comparison)
+- SysV init behavior
+- FreeBSD init/rc system

userspace/tests/telnetd.rs

@@ -153,16 +153,13 @@ fn handle_connection(client_fd: i32) {
     ];
 
     let mut buf = [0u8; 1024];
-    let mut cycles = 0;
-    const MAX_CYCLES: i32 = 100; // Limit for test - run for limited time
-
     loop {
         // Clear revents before polling
         for pfd in &mut fds {
             pfd.revents = 0;
         }
 
-        let ready = poll(&mut fds, 100); // 100ms timeout
+        let ready = poll(&mut fds, 1000); // 1 second timeout
 
         if ready < 0 {
             break;
@@ -205,12 +202,6 @@ fn handle_connection(client_fd: i32) {
                 break;
             }
         }
-
-        cycles += 1;
-        if cycles >= MAX_CYCLES {
-            io::print("TELNETD_RELAY_TIMEOUT\n");
-            break;
-        }
     }
 
     io::print("TELNETD_RELAY_DONE\n");
@@ -248,30 +239,28 @@ pub extern "C" fn _start() -> ! {
 
     io::print("TELNETD_LISTENING\n");
 
-    // Accept one connection (for test purposes)
-    let mut attempts = 0;
-    const MAX_ATTEMPTS: i32 = 1000;
-
+    // Accept connections forever (daemon mode)
     loop {
         match accept(listen_fd, None) {
             Ok(client_fd) => {
                 io::print("TELNETD_CONNECTED\n");
                 handle_connection(client_fd);
-                break;
+                // After connection closes, continue accepting
+                io::print("TELNETD_LISTENING\n");
             }
             Err(_) => {
-                attempts += 1;
-                if attempts >= MAX_ATTEMPTS {
-                    io::print("TELNETD_TIMEOUT: no connection\n");
-                    break;
-                }
+                // EAGAIN or other error - just yield and retry
                 process::yield_now();
             }
         }
     }
 
-    io::print("TELNETD_TEST_COMPLETE\n");
-    process::exit(0);
+    // Unreachable in daemon mode, but keep for completeness
+    #[allow(unreachable_code)]
+    {
+        io::print("TELNETD_SHUTDOWN\n");
+        process::exit(0);
+    }
 }
 
 #[panic_handler]