From bdd43f43cd5fb63f0fb032f8e198fc198706f628 Mon Sep 17 00:00:00 2001
From: boreddevnl <chris@boreddev.nl>
Date: Wed, 15 Apr 2026 22:47:24 +0200
Subject: [PATCH] FEATURE: add Bsh + userspace terminal, remove legacy cmd/cli
 utils

---
 Makefile                    |    4 +
 docs/usage/terminal.md      |   29 +-
 src/core/main.c             |   13 +-
 src/dev/ps2.c               |   12 +-
 src/fs/procfs.c             |    4 +
 src/library/bsh/boot.bsh    |    4 +
 src/library/bsh/bshrc       |   35 +
 src/library/bsh/startup.bsh |    4 +
 src/{wm => sys}/cmd.h       |   13 +-
 src/sys/cmd_stub.c          |   76 ++
 src/sys/process.c           |  112 +-
 src/sys/process.h           |    3 +
 src/sys/syscall.c           |  135 +-
 src/sys/tty.c               |  158 +++
 src/sys/tty.h               |   18 +
 src/userland/cli/bsh.c      | 1449 ++++++++++++++++++++++
 src/userland/cli/cat.c      |   32 -
 src/userland/cli/cp.c       |  166 ---
 src/userland/cli/ls.c       |   66 -
 src/userland/cli/mkdir.c    |   28 -
 src/userland/cli/mv.c       |  128 --
 src/userland/cli/rm.c       |   29 -
 src/userland/cli/touch.c    |   27 -
 src/userland/gui/terminal.c |  893 ++++++++++++++
 src/userland/gui/txtedit.c  |   46 +-
 src/userland/gui/viewer.c   |   48 +-
 src/userland/libc/stdlib.c  |    2 +-
 src/userland/libc/syscall.c |   40 +
 src/userland/libc/syscall.h |   25 +
 src/userland/net/telnet.c   |   58 +-
 src/wm/cmd.c                | 2332 -----------------------------------
 src/wm/explorer.c           |    3 +-
 src/wm/explorer.h           |    1 -
 src/wm/wm.c                 |   18 +-
 34 files changed, 3099 insertions(+), 2912 deletions(-)
 create mode 100644 src/library/bsh/boot.bsh
 create mode 100644 src/library/bsh/bshrc
 create mode 100644 src/library/bsh/startup.bsh
 rename src/{wm => sys}/cmd.h (77%)
 create mode 100644 src/sys/cmd_stub.c
 create mode 100644 src/sys/tty.c
 create mode 100644 src/sys/tty.h
 create mode 100644 src/userland/cli/bsh.c
 delete mode 100644 src/userland/cli/cat.c
 delete mode 100644 src/userland/cli/cp.c
 delete mode 100644 src/userland/cli/ls.c
 delete mode 100644 src/userland/cli/mkdir.c
 delete mode 100644 src/userland/cli/mv.c
 delete mode 100644 src/userland/cli/rm.c
 delete mode 100644 src/userland/cli/touch.c
 create mode 100644 src/userland/gui/terminal.c
 delete mode 100644 src/wm/cmd.c

diff --git a/Makefile b/Makefile
index 6ec10bd..ad1d384 100644
--- a/Makefile
+++ b/Makefile
@@ -139,6 +139,7 @@ $(BUILD_DIR)/initrd.tar: $(KERNEL_ELF)
 	mkdir -p $(BUILD_DIR)/initrd/Library/images/gif
 	mkdir -p $(BUILD_DIR)/initrd/Library/Fonts/Emoji
 	mkdir -p $(BUILD_DIR)/initrd/Library/DOOM
+	mkdir -p $(BUILD_DIR)/initrd/Library/bsh
 	mkdir -p $(BUILD_DIR)/initrd/docs
 
 	@for f in $(SRC_DIR)/userland/bin/*.elf; do \
@@ -156,6 +157,9 @@ $(BUILD_DIR)/initrd.tar: $(KERNEL_ELF)
 	@for f in $(SRC_DIR)/fonts/Emoji/*.ttf; do \
 		if [ -f "$$f" ]; then cp "$$f" $(BUILD_DIR)/initrd/Library/Fonts/Emoji/; fi \
 	done
+	@if [ -f $(SRC_DIR)/library/bsh/bshrc ]; then cp $(SRC_DIR)/library/bsh/bshrc $(BUILD_DIR)/initrd/Library/bsh/; fi
+	@if [ -f $(SRC_DIR)/library/bsh/startup.bsh ]; then cp $(SRC_DIR)/library/bsh/startup.bsh $(BUILD_DIR)/initrd/Library/bsh/; fi
+	@if [ -f $(SRC_DIR)/library/bsh/boot.bsh ]; then cp $(SRC_DIR)/library/bsh/boot.bsh $(BUILD_DIR)/initrd/Library/bsh/; fi
 	@if [ -f $(SRC_DIR)/userland/games/doom/doom1.wad ]; then cp $(SRC_DIR)/userland/games/doom/doom1.wad $(BUILD_DIR)/initrd/Library/DOOM/; fi
 	@for f in $$(find docs -name '*.md' 2>/dev/null); do \
 		if [ -f "$$f" ]; then \
diff --git a/docs/usage/terminal.md b/docs/usage/terminal.md
index 223d472..c335998 100644
--- a/docs/usage/terminal.md
+++ b/docs/usage/terminal.md
@@ -4,7 +4,7 @@ The BoredOS Terminal provides a powerful command-line interface (CLI) for advanc
 
 ## The Shell
 
-The default shell in BoredOS is a custom-built, lightweight command processor integrated into the Window Manager. It features:
+The default shell in BoredOS is **BoredShell (Bsh)**, a userspace shell with a dedicated terminal app. It features:
 -   **ANSI Color Support**: Rich text output with colors and styles.
 -   **Command History**: Use the **Up** and **Down** arrow keys to navigate through your previous commands (up to 64 history entries).
 -   **Output Redirection**:
@@ -13,6 +13,33 @@ The default shell in BoredOS is a custom-built, lightweight command processor in
 -   **Piping**:
     -   `command1 | command2`: Pass the output of the first command as input to the second.
 
+### Bsh Configuration
+
+Bsh loads its configuration from:
+
+`/Library/bsh/bshrc`
+
+This file is similar to `.zshrc` and can define:
+- `PATH` for command lookup
+- `STARTUP` for interactive shell startup scripts
+- `BOOT_SCRIPT` for a once-per-boot script
+- prompt templates (`PROMPT_LEFT`, `PROMPT_RIGHT`)
+
+Prompt tokens:
+- `%n` username
+- `%h` hostname
+- `%~` cwd ("~" for `/root`)
+- `%T` time (HH:MM)
+
+Example:
+
+```
+PATH=/bin:/root/Apps
+PROMPT_LEFT=%n@%h:%~$ 
+STARTUP=/Library/bsh/startup.bsh
+BOOT_SCRIPT=/Library/bsh/boot.bsh
+```
+
 ## Common Commands
 
 Below are some of the most used commands available in `/bin`:
diff --git a/src/core/main.c b/src/core/main.c
index fdc61ff..3f4d992 100644
--- a/src/core/main.c
+++ b/src/core/main.c
@@ -242,7 +242,6 @@ void kmain(void) {
     log_ok("Graphics and Console ready");
 
     if (memmap_request.response != NULL) {
-        // The memory manager will now scan the memory map and manage all usable regions.
         memory_manager_init_from_memmap(memmap_request.response);
         log_ok("Memory manager ready");
         smp_init_bsp();
@@ -278,17 +277,15 @@ void kmain(void) {
     fat32_mkdir("/Library/images/gif");
     fat32_mkdir("/Library/Fonts");
     fat32_mkdir("/Library/DOOM");
+    fat32_mkdir("/Library/bsh");
     fat32_mkdir("/docs");
 
-    // Initialize Virtual Filesystems
     sysfs_init_subsystems();
     vfs_mount("/sys", "sysfs", "sysfs", sysfs_get_ops(), NULL);
     vfs_mount("/proc", "procfs", "procfs", procfs_get_ops(), NULL);
     
-    // Initialize bootfs with default values
     bootfs_init();
     
-    // Populate bootfs with real Limine bootloader information BEFORE mounting
     if (bootloader_info_request.response != NULL) {
         if (bootloader_info_request.response->name) {
             k_strcpy(g_bootfs_state.bootloader_name, bootloader_info_request.response->name);
@@ -298,7 +295,6 @@ void kmain(void) {
         }
     }
     
-    // Get kernel size from kernel file request
     if (kernel_file_request.response != NULL && kernel_file_request.response->kernel_file != NULL) {
         g_bootfs_state.kernel_size = kernel_file_request.response->kernel_file->size;
         serial_write("[INIT] Kernel size from bootloader: ");
@@ -306,16 +302,13 @@ void kmain(void) {
         serial_write(" bytes\n");
     }
     
-    // Set boot time to current ticks
     extern uint32_t wm_get_ticks(void);
     g_bootfs_state.boot_time_ms = wm_get_ticks();
 
-    // BEFORE mounting bootfs, capture initrd from Limine modules
     if (module_request.response != NULL) {
         g_bootfs_state.num_modules = module_request.response->module_count;
         
         serial_write("[INIT] Scanning modules for bootfs state...\n");
-        // Scan modules to find initrd
         for (uint64_t i = 0; i < module_request.response->module_count; i++) {
             struct limine_file *mod = module_request.response->modules[i];
             const char *path = mod->path;
@@ -379,12 +372,10 @@ void kmain(void) {
                     fat32_close(fh);
                 }
             }
-            // Register all discovered modules in our module manager for /sys/module
             module_manager_register(clean_path, (uint64_t)mod->address, mod->size);
         }
     }
     
-    // Initialize fonts now that FAT32 and modules are loaded
     uint64_t current_rsp;
     asm volatile("mov %%rsp, %0" : "=r"(current_rsp));
     serial_write("[INIT] Stack Alignment: 0x");
@@ -397,10 +388,8 @@ void kmain(void) {
     ps2_init();
     asm("sti");
 
-    // Initialize LAPIC for IPI support
     lapic_init();
 
-    // Initialize SMP 
     if (smp_request.response != NULL) {
         uint32_t online = smp_init(smp_request.response);
         log_ok("SMP initialized");
diff --git a/src/dev/ps2.c b/src/dev/ps2.c
index 356a363..660ec37 100644
--- a/src/dev/ps2.c
+++ b/src/dev/ps2.c
@@ -92,17 +92,7 @@ uint64_t keyboard_handler(registers_t *regs) {
         extended_scancode = false;
     }
 
-    if (ps2_ctrl_pressed && scancode == 0x2E) {
-        extern process_t* process_get_current(void);
-        process_t* proc = process_get_current();
-        if (proc && proc->is_user && proc->is_terminal_proc && proc->ui_window) {
-            if (((Window*)proc->ui_window)->focused) {
-                extern uint64_t process_terminate_current(void);
-                outb(0x20, 0x20); 
-                return process_terminate_current();
-            }
-        }
-    }
+
 
     if (scancode == 0x2A || scancode == 0x36) { // Shift Down
         shift_pressed = true;
diff --git a/src/fs/procfs.c b/src/fs/procfs.c
index 0dab24d..a45022f 100644
--- a/src/fs/procfs.c
+++ b/src/fs/procfs.c
@@ -297,6 +297,9 @@ int procfs_read(void *fs_private, void *handle, void *buf, int size) {
         if (k_strcmp(h->type, "name") == 0 || k_strcmp(h->type, "cmdline") == 0) {
             k_strcpy(out, proc->name);
             k_strcpy(out + k_strlen(out), "\n");
+        } else if (k_strcmp(h->type, "cwd") == 0) {
+            k_strcpy(out, proc->cwd);
+            k_strcpy(out + k_strlen(out), "\n");
         } else if (k_strcmp(h->type, "status") == 0) {
             k_strcpy(out, "Name: ");
             k_strcpy(out + k_strlen(out), proc->name);
@@ -387,6 +390,7 @@ int procfs_readdir(void *fs_private, const char *path, vfs_dirent_t *entries, in
         k_strcpy(entries[out++].name, "name");
         k_strcpy(entries[out++].name, "status");
         k_strcpy(entries[out++].name, "cmdline");
+        k_strcpy(entries[out++].name, "cwd");
         k_strcpy(entries[out++].name, "signal");
         for(int i=0; i<out; i++) entries[i].is_directory = 0;
         return out;
diff --git a/src/library/bsh/boot.bsh b/src/library/bsh/boot.bsh
new file mode 100644
index 0000000..d7f8b35
--- /dev/null
+++ b/src/library/bsh/boot.bsh
@@ -0,0 +1,4 @@
+# BoredShell boot script
+# Runs once on boot for the first shell.
+# Example:
+# echo "Boot script executed"
diff --git a/src/library/bsh/bshrc b/src/library/bsh/bshrc
new file mode 100644
index 0000000..225725a
--- /dev/null
+++ b/src/library/bsh/bshrc
@@ -0,0 +1,35 @@
+# BoredShell rc file
+# Location: /Library/bsh/bshrc
+#
+# Format (initial): key=value
+# Lines starting with # are comments.
+#
+# PATH controls command lookup order (colon-separated).
+PATH=/bin:/root/Apps
+
+# Scripts to run automatically.
+# STARTUP runs for interactive shells.
+# BOOT_SCRIPT runs once on boot (if enabled by the shell).
+STARTUP=/Library/bsh/startup.bsh
+BOOT_SCRIPT=/Library/bsh/boot.bsh
+
+# Prompt templates.
+# Tokens:
+#   %n = username
+#   %h = hostname
+#   %~ = cwd ("~" for /root)
+#   %T = time (HH:MM)
+PROMPT_LEFT=%n@%h:%~$ 
+PROMPT_RIGHT=%T
+
+# History settings.
+HISTORY_FILE=/Library/bsh/history
+HISTORY_SIZE=200
+
+# Feature toggles.
+GLOB=true
+COMPLETE=true
+SUGGEST=true
+
+# Example aliases (future support).
+# alias ll=ls -la
diff --git a/src/library/bsh/startup.bsh b/src/library/bsh/startup.bsh
new file mode 100644
index 0000000..3e342cf
--- /dev/null
+++ b/src/library/bsh/startup.bsh
@@ -0,0 +1,4 @@
+# BoredShell startup script
+# Runs for interactive shells.
+# Example:
+# echo "Welcome to BoredShell"
diff --git a/src/wm/cmd.h b/src/sys/cmd.h
similarity index 77%
rename from src/wm/cmd.h
rename to src/sys/cmd.h
index 51d8e60..d89236b 100644
--- a/src/wm/cmd.h
+++ b/src/sys/cmd.h
@@ -4,15 +4,15 @@
 #ifndef CMD_H
 #define CMD_H
 
-#include "wm.h"
-
-extern Window win_cmd;
+#include <stdbool.h>
+#include <stddef.h>
+#include <stdint.h>
 
 void cmd_init(void);
 void cmd_reset(void);
 
-// IO Functions
 void cmd_write(const char *str);
+void cmd_write_len(const char *str, size_t len);
 void cmd_putchar(char c);
 void cmd_write_int(int n);
 void cmd_write_hex(uint64_t n);
@@ -22,10 +22,9 @@ void cmd_screen_clear(void);
 void cmd_increment_msg_count(void);
 void cmd_reset_msg_count(void);
 
-void cmd_handle_resize(Window *win, int w, int h);
-void cmd_handle_click(Window *win, int x, int y);
-
 uint32_t cmd_get_config_value(const char *key);
 void cmd_set_current_color(uint32_t color);
+void cmd_set_raw_mode(bool enabled);
+void cmd_process_finished(void);
 
 #endif
\ No newline at end of file
diff --git a/src/sys/cmd_stub.c b/src/sys/cmd_stub.c
new file mode 100644
index 0000000..0538392
--- /dev/null
+++ b/src/sys/cmd_stub.c
@@ -0,0 +1,76 @@
+// Copyright (c) 2023-2026 Chris (boreddevnl)
+// This software is released under the GNU General Public License v3.0. See LICENSE file for details.
+// This header needs to maintain in any file it is present in, as per the GPL license terms.
+#include "cmd.h"
+#include "core/kutils.h"
+
+extern void serial_write(const char *str);
+
+static void serial_write_char(char c) {
+    char buf[2] = { c, 0 };
+    serial_write(buf);
+}
+
+void cmd_init(void) {
+}
+
+void cmd_reset(void) {
+}
+
+void cmd_write(const char *str) {
+    if (!str) return;
+    serial_write(str);
+}
+
+void cmd_write_len(const char *str, size_t len) {
+    if (!str || len == 0) return;
+    for (size_t i = 0; i < len; i++) {
+        serial_write_char(str[i]);
+    }
+}
+
+void cmd_putchar(char c) {
+    serial_write_char(c);
+}
+
+void cmd_write_int(int n) {
+    char buf[32];
+    k_itoa(n, buf);
+    cmd_write(buf);
+}
+
+void cmd_write_hex(uint64_t n) {
+    char buf[17];
+    k_itoa_hex(n, buf);
+    cmd_write("0x");
+    cmd_write(buf);
+}
+
+int cmd_get_cursor_col(void) {
+    return 0;
+}
+
+void cmd_screen_clear(void) {
+}
+
+void cmd_increment_msg_count(void) {
+}
+
+void cmd_reset_msg_count(void) {
+}
+
+uint32_t cmd_get_config_value(const char *key) {
+    (void)key;
+    return 0;
+}
+
+void cmd_set_current_color(uint32_t color) {
+    (void)color;
+}
+
+void cmd_set_raw_mode(bool enabled) {
+    (void)enabled;
+}
+
+void cmd_process_finished(void) {
+}
diff --git a/src/sys/process.c b/src/sys/process.c
index e7268f5..057e048 100644
--- a/src/sys/process.c
+++ b/src/sys/process.c
@@ -27,23 +27,24 @@ static uint64_t free_pml4_later[MAX_CPUS_SCHED] = {0};
 static spinlock_t runqueue_lock = SPINLOCK_INIT;
 static uint32_t next_cpu_assign = 1; 
 
+static void process_cleanup_inner(process_t *proc);
+
 void process_init(void) {
     for (int i = 0; i < MAX_PROCESSES; i++) {
         processes[i].pid = 0xFFFFFFFF;
     }
 
-    // Current kernel execution is PID 0
     process_t *kernel_proc = &processes[0];
     kernel_proc->pid = next_pid++;
     kernel_proc->is_user = false;
     kernel_proc->is_idle = true;
+    kernel_proc->tty_id = -1;
+    kernel_proc->kill_pending = false;
     
-    // We don't have its RSP or PML4 yet, but it's already running.
-    // The timer interrupt will naturally capture its context on the first tick!
+
     kernel_proc->pml4_phys = paging_get_pml4_phys();
     kernel_proc->kernel_stack = 0;
     
-    // Initialize FPU/SSE state for kernel (first interrupt will capture it on stack)
     kernel_proc->fpu_initialized = true;
 
     for (int i = 0; i < MAX_PROCESS_FDS; i++) kernel_proc->fds[i] = NULL;
@@ -78,11 +79,14 @@ process_t* process_create(void (*entry_point)(void), bool is_user) {
     
     new_proc->pid = next_pid++;
     new_proc->is_user = is_user;
+    new_proc->tty_id = -1;
+    new_proc->kill_pending = false;
     
     process_t *parent = process_get_current();
     if (parent) {
         extern void mem_memcpy(void *dest, const void *src, size_t len);
         mem_memcpy(new_proc->cwd, parent->cwd, 1024);
+        new_proc->tty_id = parent->tty_id;
     } else {
         mem_memset(new_proc->cwd, 0, 1024);
         new_proc->cwd[0] = '/';
@@ -207,6 +211,18 @@ process_t* process_create_elf(const char* filepath, const char* args_str) {
     new_proc->heap_start = 0x20000000; // 512MB mark
     new_proc->heap_end = 0x20000000;
     new_proc->is_terminal_proc = false;
+    new_proc->tty_id = -1;
+    new_proc->kill_pending = false;
+
+    process_t *parent = process_get_current();
+    if (parent) {
+        extern void mem_memcpy(void *dest, const void *src, size_t len);
+        mem_memcpy(new_proc->cwd, parent->cwd, 1024);
+    } else {
+        extern void mem_memset(void *dest, int val, size_t len);
+        mem_memset(new_proc->cwd, 0, 1024);
+        new_proc->cwd[0] = '/';
+    }
 
     // 2. Load ELF executable
     size_t elf_load_size = 0;
@@ -426,6 +442,69 @@ uint64_t process_schedule(uint64_t current_rsp) {
     // Save context
     cur->rsp = current_rsp;
 
+    if (cur->kill_pending && cur->pid != 0xFFFFFFFF && cur->pid != 0) {
+        process_cleanup_inner(cur);
+
+        process_t *prev = cur;
+        while (prev->next != cur) {
+            prev = prev->next;
+        }
+
+        if (prev != cur) {
+            prev->next = cur->next;
+
+            process_t *next_proc = cur->next;
+            while (next_proc != cur) {
+                if (next_proc->cpu_affinity == my_cpu && next_proc->pid != 0xFFFFFFFF && !next_proc->kill_pending) break;
+                next_proc = next_proc->next;
+            }
+
+            if (next_proc == cur || next_proc->cpu_affinity != my_cpu) {
+                for (int i = 0; i < MAX_PROCESSES; i++) {
+                    if (processes[i].pid == 0 || (processes[i].cpu_affinity == my_cpu && processes[i].is_user == false)) {
+                        next_proc = &processes[i];
+                        break;
+                    }
+                }
+            }
+
+            current_process[my_cpu] = next_proc;
+
+            cur->pid = 0xFFFFFFFF;
+            cur->cpu_affinity = 0xFFFFFFFF;
+            cur->ui_window = NULL;
+            cur->is_terminal_proc = false;
+            cur->kill_pending = false;
+
+            free_kernel_stack_later[my_cpu] = cur->kernel_stack_alloc;
+            cur->kernel_stack_alloc = NULL;
+            free_pml4_later[my_cpu] = cur->pml4_phys;
+            cur->pml4_phys = 0;
+
+            if (current_process[my_cpu]->is_user && current_process[my_cpu]->kernel_stack) {
+                tss_set_stack_cpu(my_cpu, current_process[my_cpu]->kernel_stack);
+                cpu_state_t *cpu_state = smp_get_cpu(my_cpu);
+                if (cpu_state) {
+                    cpu_state->kernel_syscall_stack = current_process[my_cpu]->kernel_stack;
+                }
+            }
+
+            paging_switch_directory(current_process[my_cpu]->pml4_phys);
+
+            current_process[my_cpu]->ticks++;
+            uint64_t next_rsp = current_process[my_cpu]->rsp;
+
+            spinlock_release_irqrestore(&runqueue_lock, rflags);
+            if (cleanup_stack) kfree(cleanup_stack);
+            if (cleanup_pml4) {
+                extern void paging_destroy_user_pml4_phys(uint64_t pml4_phys);
+                paging_destroy_user_pml4_phys(cleanup_pml4);
+            }
+
+            return next_rsp;
+        }
+    }
+
     // Switch to next ready process assigned to this CPU
     extern uint32_t wm_get_ticks(void);
     uint32_t now = wm_get_ticks();
@@ -435,7 +514,7 @@ uint64_t process_schedule(uint64_t current_rsp) {
     
     while (next_proc != start) {
         // Only consider processes assigned to our CPU and not terminated
-        if (next_proc->cpu_affinity == my_cpu && next_proc->pid != 0xFFFFFFFF) {
+        if (next_proc->cpu_affinity == my_cpu && next_proc->pid != 0xFFFFFFFF && !next_proc->kill_pending) {
             if (next_proc->pid == 0 || next_proc->sleep_until == 0 || next_proc->sleep_until <= now) {
                 break;
             }
@@ -497,12 +576,20 @@ process_t* process_get_by_pid(uint32_t pid) {
     return NULL;
 }
 
+void process_kill_by_tty(int tty_id) {
+    if (tty_id < 0) return;
+    for (int i = 0; i < MAX_PROCESSES; i++) {
+        if (processes[i].pid != 0xFFFFFFFF && processes[i].pid != 0 && processes[i].tty_id == tty_id) {
+            process_terminate(&processes[i]);
+        }
+    }
+}
+
 static void process_cleanup_inner(process_t *proc) {
     if (!proc || proc->pid == 0xFFFFFFFF) return;
 
     // 1. Cleanup side effects
-    extern Window win_cmd;
-    if (proc->ui_window && (proc->ui_window != &win_cmd)) {
+    if (proc->ui_window) {
         wm_remove_window((Window *)proc->ui_window);
         proc->ui_window = NULL;
     }
@@ -529,6 +616,14 @@ static void process_cleanup_inner(process_t *proc) {
 void process_terminate(process_t *to_delete) {
     if (!to_delete || to_delete->pid == 0xFFFFFFFF || to_delete->pid == 0) return;
 
+    uint32_t cpu_count = smp_cpu_count();
+    for (uint32_t c = 0; c < cpu_count && c < MAX_CPUS_SCHED; c++) {
+        if (current_process[c] == to_delete) {
+            to_delete->kill_pending = true;
+            return;
+        }
+    }
+
     uint64_t rflags = spinlock_acquire_irqsave(&runqueue_lock);
 
     process_cleanup_inner(to_delete);
@@ -549,7 +644,6 @@ void process_terminate(process_t *to_delete) {
     prev->next = to_delete->next;
     
     // Update per-CPU current_process if this was the current on any CPU
-    uint32_t cpu_count = smp_cpu_count();
     for (uint32_t c = 0; c < cpu_count && c < MAX_CPUS_SCHED; c++) {
         if (current_process[c] == to_delete) {
             process_t *np = to_delete->next;
@@ -571,6 +665,7 @@ void process_terminate(process_t *to_delete) {
     // Mark slot as free
     to_delete->pid = 0xFFFFFFFF; 
     to_delete->cpu_affinity = 0xFFFFFFFF;
+    to_delete->kill_pending = false;
 
     if (to_delete->user_stack_alloc) kfree(to_delete->user_stack_alloc);
     // Defer kernel stack until we switch away from it
@@ -639,6 +734,7 @@ uint64_t process_terminate_current(void) {
     to_delete->cpu_affinity = 0xFFFFFFFF;
     to_delete->ui_window = NULL;
     to_delete->is_terminal_proc = false;
+    to_delete->kill_pending = false;
 
     // 4. Load context for the NEXT process
     if (current_process[my_cpu]->is_user && current_process[my_cpu]->kernel_stack) {
diff --git a/src/sys/process.h b/src/sys/process.h
index 7fef072..d014d45 100644
--- a/src/sys/process.h
+++ b/src/sys/process.h
@@ -43,6 +43,8 @@ typedef struct process {
     void *user_stack_alloc;  
 
     bool is_terminal_proc;   
+    int tty_id;              
+    bool kill_pending;       
 
     struct process *next;
 
@@ -75,6 +77,7 @@ uint64_t process_schedule(uint64_t current_rsp);
 uint64_t process_terminate_current(void);
 void process_terminate(process_t *proc);
 process_t* process_get_by_pid(uint32_t pid);
+void process_kill_by_tty(int tty_id);
 
 // SMP: IPI handler for AP scheduling 
 uint64_t sched_ipi_handler(registers_t *regs);
diff --git a/src/sys/syscall.c b/src/sys/syscall.c
index 3f98fa4..7c96800 100644
--- a/src/sys/syscall.c
+++ b/src/sys/syscall.c
@@ -19,11 +19,16 @@
 #include "network.h"
 #include "icmp.h"
 #include "cmd.h"
+#include "tty.h"
 #include "font_manager.h"
 #include "graphics.h"
 
 extern bool ps2_ctrl_pressed;
 
+#define SPAWN_FLAG_TERMINAL 0x1
+#define SPAWN_FLAG_INHERIT_TTY 0x2
+#define SPAWN_FLAG_TTY_ID 0x4
+
 // Read MSR
 static inline uint64_t rdmsr(uint32_t msr) {
     uint32_t low, high;
@@ -180,6 +185,12 @@ static void user_window_resize(Window *win, int w, int h) {
         extern void mem_memset(void *dest, int val, size_t len);
         mem_memset(win->pixels, 0, w * h * sizeof(uint32_t));
     }
+
+    process_t *proc = process_get_by_ui_window(win);
+    if (proc) {
+        gui_event_t ev = { .type = GUI_EVENT_RESIZE, .arg1 = w, .arg2 = h };
+        process_push_gui_event(proc, &ev);
+    }
 }
 
 
@@ -197,9 +208,21 @@ static uint64_t syscall_handler_inner(registers_t *regs) {
     if (syscall_num == 1) { // SYS_WRITE
         extern void cmd_write_len(const char *str, size_t len);
         process_t *proc = process_get_current();
-        if (!proc || !proc->is_user || proc->is_terminal_proc) {
-            cmd_write_len((const char*)arg2, (size_t)arg3);
+        const char *buf = (const char*)arg2;
+        size_t len = (size_t)arg3;
+        if (!proc || !proc->is_user) {
+            cmd_write_len(buf, len);
+            return len;
         }
+        if (proc->is_terminal_proc) {
+            if (proc->tty_id >= 0) {
+                tty_write_output(proc->tty_id, buf, len);
+                return len;
+            }
+            cmd_write_len(buf, len);
+            return len;
+        }
+        return len;
     } else if (syscall_num == 3) { // SYS_GUI
         int cmd = (int)arg1;
         process_t *proc = process_get_current();
@@ -1254,6 +1277,35 @@ static uint64_t syscall_handler_inner(registers_t *regs) {
             return cmd_get_config_value(key);
         } else if (cmd == 29) { // SYSTEM_CMD_SET_TEXT_COLOR
             uint32_t color = (uint32_t)arg2;
+            if (proc->is_terminal_proc && proc->tty_id >= 0) {
+                char seq[32];
+                int pos = 0;
+                int r = (color >> 16) & 0xFF;
+                int g = (color >> 8) & 0xFF;
+                int b = color & 0xFF;
+
+                seq[pos++] = 0x1B;
+                seq[pos++] = '[';
+                seq[pos++] = '3';
+                seq[pos++] = '8';
+                seq[pos++] = ';';
+                seq[pos++] = '2';
+                seq[pos++] = ';';
+
+                char num[8];
+                k_itoa(r, num);
+                for (int i = 0; num[i] && pos < (int)sizeof(seq) - 1; i++) seq[pos++] = num[i];
+                seq[pos++] = ';';
+                k_itoa(g, num);
+                for (int i = 0; num[i] && pos < (int)sizeof(seq) - 1; i++) seq[pos++] = num[i];
+                seq[pos++] = ';';
+                k_itoa(b, num);
+                for (int i = 0; num[i] && pos < (int)sizeof(seq) - 1; i++) seq[pos++] = num[i];
+                seq[pos++] = 'm';
+
+                tty_write_output(proc->tty_id, seq, (size_t)pos);
+                return 0;
+            }
             cmd_set_current_color(color);
             return 0;
         } else if (cmd == 31) { // SYSTEM_CMD_SET_WALLPAPER_PATH
@@ -1374,6 +1426,85 @@ static uint64_t syscall_handler_inner(registers_t *regs) {
             }
             return -1;
             return -1;
+        } else if (cmd == 60) { // SYSTEM_CMD_TTY_CREATE
+            return tty_create();
+        } else if (cmd == 61) { // SYSTEM_CMD_TTY_READ_OUT
+            int tty_id = (int)arg2;
+            char *buf = (char *)arg3;
+            size_t len = (size_t)arg4;
+            if (!buf || len == 0) return 0;
+            return tty_read_output(tty_id, buf, len);
+        } else if (cmd == 62) { // SYSTEM_CMD_TTY_WRITE_IN
+            int tty_id = (int)arg2;
+            const char *buf = (const char *)arg3;
+            size_t len = (size_t)arg4;
+            if (!buf || len == 0) return 0;
+            return tty_write_input(tty_id, buf, len);
+        } else if (cmd == 63) { // SYSTEM_CMD_TTY_READ_IN
+            char *buf = (char *)arg2;
+            size_t len = (size_t)arg3;
+            if (!buf || len == 0) return 0;
+            if (proc->tty_id < 0) return 0;
+            return tty_read_input(proc->tty_id, buf, len);
+        } else if (cmd == 65) { // SYSTEM_CMD_TTY_SET_FG
+            int tty_id = (int)arg2;
+            int pid = (int)arg3;
+            return tty_set_foreground(tty_id, pid);
+        } else if (cmd == 66) { // SYSTEM_CMD_TTY_GET_FG
+            int tty_id = (int)arg2;
+            return tty_get_foreground(tty_id);
+        } else if (cmd == 67) { // SYSTEM_CMD_TTY_KILL_FG
+            int tty_id = (int)arg2;
+            int pid = tty_get_foreground(tty_id);
+            if (pid <= 0) return 0;
+            process_t *target = process_get_by_pid((uint32_t)pid);
+            if (target) process_terminate(target);
+            tty_set_foreground(tty_id, 0);
+            return 0;
+        } else if (cmd == 68) { 
+            int tty_id = (int)arg2;
+            process_kill_by_tty(tty_id);
+            tty_set_foreground(tty_id, 0);
+            return 0;
+        } else if (cmd == 69) { 
+            int tty_id = (int)arg2;
+            return tty_destroy(tty_id);
+        } else if (cmd == 64) { 
+            const char *user_path = (const char *)arg2;
+            const char *user_args = (const char *)arg3;
+            uint64_t flags = arg4;
+            int tty_id = (int)arg5;
+
+            if (!user_path) return -1;
+
+            char path_buf[256];
+            int pi = 0;
+            while (pi < 255 && user_path[pi]) {
+                path_buf[pi] = user_path[pi];
+                pi++;
+            }
+            path_buf[pi] = 0;
+
+            char args_buf[512];
+            const char *args_ptr = NULL;
+            if (user_args) {
+                int ai = 0;
+                while (ai < 511 && user_args[ai]) {
+                    args_buf[ai] = user_args[ai];
+                    ai++;
+                }
+                args_buf[ai] = 0;
+                args_ptr = args_buf;
+            }
+
+            process_t *child = process_create_elf(path_buf, args_ptr);
+            if (!child) return -1;
+
+            if (flags & SPAWN_FLAG_TERMINAL) child->is_terminal_proc = true;
+            if (flags & SPAWN_FLAG_TTY_ID) child->tty_id = tty_id;
+            else if (flags & SPAWN_FLAG_INHERIT_TTY) child->tty_id = proc->tty_id;
+
+            return (uint64_t)child->pid;
         } else if (cmd == SYSTEM_CMD_PARALLEL_RUN) {
             void (*user_fn)(void*) = (void (*)(void*))arg2;
             void **args = (void **)arg3;
diff --git a/src/sys/tty.c b/src/sys/tty.c
new file mode 100644
index 0000000..1cb81ab
--- /dev/null
+++ b/src/sys/tty.c
@@ -0,0 +1,158 @@
+// Copyright (c) 2023-2026 Chris (boreddevnl)
+// This software is released under the GNU General Public License v3.0. See LICENSE file for details.
+// This header needs to maintain in any file it is present in, as per the GPL license terms.
+#include "tty.h"
+#include "spinlock.h"
+#include <stdbool.h>
+#include <stdint.h>
+
+#define TTY_MAX 8
+#define TTY_OUT_SIZE 16384
+#define TTY_IN_SIZE 4096
+
+typedef struct {
+    bool used;
+    int id;
+    char out_buf[TTY_OUT_SIZE];
+    uint32_t out_head;
+    uint32_t out_tail;
+    char in_buf[TTY_IN_SIZE];
+    uint32_t in_head;
+    uint32_t in_tail;
+    int fg_pid;
+    spinlock_t lock;
+} tty_t;
+
+static tty_t ttys[TTY_MAX] = {0};
+
+extern void mem_memset(void *dest, int val, size_t len);
+
+static tty_t *tty_get(int tty_id) {
+    if (tty_id < 0 || tty_id >= TTY_MAX) return NULL;
+    if (!ttys[tty_id].used) return NULL;
+    return &ttys[tty_id];
+}
+
+int tty_create(void) {
+    for (int i = 0; i < TTY_MAX; i++) {
+        if (!ttys[i].used) {
+            ttys[i].used = true;
+            ttys[i].id = i;
+            ttys[i].out_head = 0;
+            ttys[i].out_tail = 0;
+            ttys[i].in_head = 0;
+            ttys[i].in_tail = 0;
+            ttys[i].fg_pid = -1;
+            ttys[i].lock = SPINLOCK_INIT;
+            mem_memset(ttys[i].out_buf, 0, sizeof(ttys[i].out_buf));
+            mem_memset(ttys[i].in_buf, 0, sizeof(ttys[i].in_buf));
+            return i;
+        }
+    }
+    return -1;
+}
+
+int tty_destroy(int tty_id) {
+    if (tty_id < 0 || tty_id >= TTY_MAX) return -1;
+    tty_t *tty = &ttys[tty_id];
+
+    uint64_t rflags = spinlock_acquire_irqsave(&tty->lock);
+    if (!tty->used) {
+        spinlock_release_irqrestore(&tty->lock, rflags);
+        return -1;
+    }
+
+    tty->used = false;
+    tty->id = -1;
+    tty->out_head = 0;
+    tty->out_tail = 0;
+    tty->in_head = 0;
+    tty->in_tail = 0;
+    tty->fg_pid = -1;
+    mem_memset(tty->out_buf, 0, sizeof(tty->out_buf));
+    mem_memset(tty->in_buf, 0, sizeof(tty->in_buf));
+
+    spinlock_release_irqrestore(&tty->lock, rflags);
+    return 0;
+}
+
+static int tty_write_ring(char *buf, uint32_t size, uint32_t *head, uint32_t *tail, const char *data, size_t len) {
+    int written = 0;
+    for (size_t i = 0; i < len; i++) {
+        uint32_t next = (*head + 1) % size;
+        if (next == *tail) break;
+        buf[*head] = data[i];
+        *head = next;
+        written++;
+    }
+    return written;
+}
+
+static int tty_read_ring(char *buf, uint32_t size, uint32_t *head, uint32_t *tail, char *out, size_t max_len) {
+    int read = 0;
+    while (*tail != *head && (size_t)read < max_len) {
+        out[read++] = buf[*tail];
+        *tail = (*tail + 1) % size;
+    }
+    return read;
+}
+
+int tty_write_output(int tty_id, const char *data, size_t len) {
+    tty_t *tty = tty_get(tty_id);
+    if (!tty || !data || len == 0) return 0;
+
+    uint64_t rflags = spinlock_acquire_irqsave(&tty->lock);
+    int written = tty_write_ring(tty->out_buf, TTY_OUT_SIZE, &tty->out_head, &tty->out_tail, data, len);
+    spinlock_release_irqrestore(&tty->lock, rflags);
+    return written;
+}
+
+int tty_read_output(int tty_id, char *buf, size_t max_len) {
+    tty_t *tty = tty_get(tty_id);
+    if (!tty || !buf || max_len == 0) return 0;
+
+    uint64_t rflags = spinlock_acquire_irqsave(&tty->lock);
+    int read = tty_read_ring(tty->out_buf, TTY_OUT_SIZE, &tty->out_head, &tty->out_tail, buf, max_len);
+    spinlock_release_irqrestore(&tty->lock, rflags);
+    return read;
+}
+
+int tty_write_input(int tty_id, const char *data, size_t len) {
+    tty_t *tty = tty_get(tty_id);
+    if (!tty || !data || len == 0) return 0;
+
+    uint64_t rflags = spinlock_acquire_irqsave(&tty->lock);
+    int written = tty_write_ring(tty->in_buf, TTY_IN_SIZE, &tty->in_head, &tty->in_tail, data, len);
+    spinlock_release_irqrestore(&tty->lock, rflags);
+    return written;
+}
+
+int tty_read_input(int tty_id, char *buf, size_t max_len) {
+    tty_t *tty = tty_get(tty_id);
+    if (!tty || !buf || max_len == 0) return 0;
+
+    uint64_t rflags = spinlock_acquire_irqsave(&tty->lock);
+    int read = tty_read_ring(tty->in_buf, TTY_IN_SIZE, &tty->in_head, &tty->in_tail, buf, max_len);
+    spinlock_release_irqrestore(&tty->lock, rflags);
+    return read;
+}
+
+int tty_set_foreground(int tty_id, int pid) {
+    tty_t *tty = tty_get(tty_id);
+    if (!tty) return -1;
+
+    uint64_t rflags = spinlock_acquire_irqsave(&tty->lock);
+    tty->fg_pid = pid;
+    spinlock_release_irqrestore(&tty->lock, rflags);
+    return 0;
+}
+
+int tty_get_foreground(int tty_id) {
+    tty_t *tty = tty_get(tty_id);
+    if (!tty) return -1;
+
+    uint64_t rflags = spinlock_acquire_irqsave(&tty->lock);
+    int pid = tty->fg_pid;
+    spinlock_release_irqrestore(&tty->lock, rflags);
+    return pid;
+}
diff --git a/src/sys/tty.h b/src/sys/tty.h
new file mode 100644
index 0000000..54800cf
--- /dev/null
+++ b/src/sys/tty.h
@@ -0,0 +1,18 @@
+// Copyright (c) 2023-2026 Chris (boreddevnl)
+// This software is released under the GNU General Public License v3.0. See LICENSE file for details.
+// This header needs to maintain in any file it is present in, as per the GPL license terms.
+#ifndef TTY_H
+#define TTY_H
+
+#include <stddef.h>
+
+int tty_create(void);
+int tty_destroy(int tty_id);
+int tty_write_output(int tty_id, const char *data, size_t len);
+int tty_read_output(int tty_id, char *buf, size_t max_len);
+int tty_write_input(int tty_id, const char *data, size_t len);
+int tty_read_input(int tty_id, char *buf, size_t max_len);
+int tty_set_foreground(int tty_id, int pid);
+int tty_get_foreground(int tty_id);
+
+#endif
diff --git a/src/userland/cli/bsh.c b/src/userland/cli/bsh.c
new file mode 100644
index 0000000..ff58f6e
--- /dev/null
+++ b/src/userland/cli/bsh.c
@@ -0,0 +1,1449 @@
+// Copyright (c) 2023-2026 Chris (boreddevnl)
+// This software is released under the GNU General Public License v3.0. See LICENSE file for details.
+// This header needs to maintain in any file it is present in, as per the GPL license terms.
+#include <stdlib.h>
+#include <syscall.h>
+#include <stdbool.h>
+
+#define MAX_LINE 512
+#define MAX_ARGS 32
+#define MAX_PATHS 16
+#define MAX_PATH_LEN 128
+#define MAX_HISTORY 256
+#define MAX_MATCHES 64
+#define MAX_MATCH_LEN 128
+#define MAX_ALIASES 32
+#define MAX_ALIAS_NAME 32
+#define MAX_ALIAS_VALUE 256
+
+#define DEFAULT_PROMPT "%n@%h:%~$ "
+
+typedef struct {
+    char path[256];
+    char startup[256];
+    char boot_script[256];
+    char prompt_left[128];
+    char prompt_right[128];
+    char history_file[128];
+    int history_size;
+    bool glob_enabled;
+    bool complete_enabled;
+    bool suggest_enabled;
+} bsh_config_t;
+
+static bsh_config_t g_cfg;
+static char g_paths[MAX_PATHS][MAX_PATH_LEN];
+static int g_path_count = 0;
+
+static char g_history[MAX_HISTORY][MAX_LINE];
+static int g_history_count = 0;
+
+typedef struct {
+    char name[MAX_ALIAS_NAME];
+    char value[MAX_ALIAS_VALUE];
+} alias_t;
+
+static alias_t g_aliases[MAX_ALIASES];
+static int g_alias_count = 0;
+
+static int g_tty_id = -1;
+static uint32_t g_color_dir = 0;
+static uint32_t g_color_file = 0;
+static uint32_t g_color_size = 0;
+static uint32_t g_color_error = 0;
+static uint32_t g_color_success = 0;
+static uint32_t g_color_default = 0;
+
+static void str_copy(char *dst, const char *src, int max_len) {
+    int i = 0;
+    if (max_len <= 0) return;
+    while (i < max_len - 1 && src && src[i]) {
+        dst[i] = src[i];
+        i++;
+    }
+    dst[i] = 0;
+}
+
+static void str_append(char *dst, const char *src, int max_len) {
+    if (!dst || !src || max_len <= 0) return;
+    int dlen = (int)strlen(dst);
+    int i = 0;
+    while (dlen + i < max_len - 1 && src[i]) {
+        dst[dlen + i] = src[i];
+        i++;
+    }
+    dst[dlen + i] = 0;
+}
+
+static bool str_eq(const char *a, const char *b) {
+    if (!a || !b) return false;
+    while (*a && *b) {
+        if (*a != *b) return false;
+        a++;
+        b++;
+    }
+    return *a == *b;
+}
+
+static bool starts_with(const char *s, const char *prefix) {
+    if (!s || !prefix) return false;
+    while (*prefix) {
+        if (*s != *prefix) return false;
+        s++;
+        prefix++;
+    }
+    return true;
+}
+
+static bool ends_with(const char *s, const char *suffix) {
+    if (!s || !suffix) return false;
+    int sl = (int)strlen(s);
+    int tl = (int)strlen(suffix);
+    if (tl > sl) return false;
+    return strcmp(s + sl - tl, suffix) == 0;
+}
+
+static void trim(char *s) {
+    if (!s) return;
+    int len = (int)strlen(s);
+    int start = 0;
+    while (s[start] == ' ' || s[start] == '\t') start++;
+    int end = len - 1;
+    while (end >= start && (s[end] == ' ' || s[end] == '\t' || s[end] == '\r' || s[end] == '\n')) end--;
+
+    int out = 0;
+    for (int i = start; i <= end; i++) {
+        s[out++] = s[i];
+    }
+    s[out] = 0;
+}
+
+static void alias_add(const char *name, const char *value) {
+    if (!name || !name[0] || !value) return;
+    for (int i = 0; i < g_alias_count; i++) {
+        if (str_eq(g_aliases[i].name, name)) {
+            str_copy(g_aliases[i].value, value, sizeof(g_aliases[i].value));
+            return;
+        }
+    }
+    if (g_alias_count >= MAX_ALIASES) return;
+    str_copy(g_aliases[g_alias_count].name, name, sizeof(g_aliases[g_alias_count].name));
+    str_copy(g_aliases[g_alias_count].value, value, sizeof(g_aliases[g_alias_count].value));
+    g_alias_count++;
+}
+
+static void alias_remove(const char *name) {
+    if (!name || !name[0]) return;
+    for (int i = 0; i < g_alias_count; i++) {
+        if (str_eq(g_aliases[i].name, name)) {
+            for (int j = i; j < g_alias_count - 1; j++) {
+                g_aliases[j] = g_aliases[j + 1];
+            }
+            g_alias_count--;
+            return;
+        }
+    }
+}
+
+static const char *alias_get(const char *name) {
+    if (!name || !name[0]) return NULL;
+    for (int i = 0; i < g_alias_count; i++) {
+        if (str_eq(g_aliases[i].name, name)) return g_aliases[i].value;
+    }
+    return NULL;
+}
+
+static void config_defaults(void) {
+    str_copy(g_cfg.path, "/bin", sizeof(g_cfg.path));
+    str_copy(g_cfg.startup, "", sizeof(g_cfg.startup));
+    str_copy(g_cfg.boot_script, "", sizeof(g_cfg.boot_script));
+    str_copy(g_cfg.prompt_left, DEFAULT_PROMPT, sizeof(g_cfg.prompt_left));
+    str_copy(g_cfg.prompt_right, "", sizeof(g_cfg.prompt_right));
+    str_copy(g_cfg.history_file, "/Library/bsh/history", sizeof(g_cfg.history_file));
+    g_cfg.history_size = 200;
+    g_cfg.glob_enabled = true;
+    g_cfg.complete_enabled = true;
+    g_cfg.suggest_enabled = true;
+    g_alias_count = 0;
+}
+
+static void parse_bool(const char *val, bool *out) {
+    if (!val || !out) return;
+    if (str_eq(val, "true") || str_eq(val, "1") || str_eq(val, "yes")) *out = true;
+    else *out = false;
+}
+
+static void split_path(const char *path_str) {
+    g_path_count = 0;
+    if (!path_str) return;
+    int i = 0;
+    int start = 0;
+    while (1) {
+        if (path_str[i] == ':' || path_str[i] == 0) {
+            int len = i - start;
+            if (len > 0 && g_path_count < MAX_PATHS) {
+                int copy_len = len < (MAX_PATH_LEN - 1) ? len : (MAX_PATH_LEN - 1);
+                for (int j = 0; j < copy_len; j++) {
+                    g_paths[g_path_count][j] = path_str[start + j];
+                }
+                g_paths[g_path_count][copy_len] = 0;
+                g_path_count++;
+            }
+            start = i + 1;
+        }
+        if (path_str[i] == 0) break;
+        i++;
+    }
+}
+
+static void load_shell_colors(void) {
+    g_color_dir = (uint32_t)sys_get_shell_config("dir_color");
+    g_color_file = (uint32_t)sys_get_shell_config("file_color");
+    g_color_size = (uint32_t)sys_get_shell_config("size_color");
+    g_color_error = (uint32_t)sys_get_shell_config("error_color");
+    g_color_success = (uint32_t)sys_get_shell_config("success_color");
+    g_color_default = (uint32_t)sys_get_shell_config("default_text_color");
+
+    if (g_color_default == 0) g_color_default = 0xFFCCCCCC;
+    if (g_color_error == 0) g_color_error = 0xFFFF4444;
+    if (g_color_success == 0) g_color_success = 0xFF6A9955;
+    if (g_color_dir == 0) g_color_dir = 0xFF569CD6;
+    if (g_color_file == 0) g_color_file = g_color_default;
+    if (g_color_size == 0) g_color_size = 0xFF6A9955;
+}
+
+static void set_color(uint32_t color) {
+    sys_set_text_color(color);
+}
+
+static void reset_color(void) {
+    sys_set_text_color(g_color_default);
+}
+
+static void config_load(void) {
+    config_defaults();
+
+    int fd = sys_open("/Library/bsh/bshrc", "r");
+    if (fd < 0) {
+        split_path(g_cfg.path);
+        return;
+    }
+
+    char buf[4096];
+    int bytes = sys_read(fd, buf, sizeof(buf) - 1);
+    sys_close(fd);
+    if (bytes <= 0) {
+        split_path(g_cfg.path);
+        return;
+    }
+    buf[bytes] = 0;
+
+    char *line = buf;
+    while (*line) {
+        char *end = line;
+        while (*end && *end != '\n' && *end != '\r') end++;
+        char saved = *end;
+        *end = 0;
+
+        trim(line);
+        if (line[0] == '#' || line[0] == 0) {
+            line = end + (saved ? 1 : 0);
+            if (saved == '\r' && *line == '\n') line++;
+            continue;
+        }
+
+        if (starts_with(line, "alias ") || starts_with(line, "alias\t")) {
+            char *def = line + 5;
+            while (*def == ' ' || *def == '\t') def++;
+            char *eq = def;
+            while (*eq && *eq != '=') eq++;
+            if (*eq == '=') {
+                *eq = 0;
+                char *name = def;
+                char *val = eq + 1;
+                trim(name);
+                trim(val);
+                if (name[0]) alias_add(name, val);
+            }
+            line = end + (saved ? 1 : 0);
+            if (saved == '\r' && *line == '\n') line++;
+            continue;
+        }
+
+        char *sep = line;
+        while (*sep && *sep != '=') sep++;
+        if (*sep == '=') {
+            *sep = 0;
+            char *key = line;
+            char *val = sep + 1;
+            trim(key);
+            trim(val);
+
+            if (str_eq(key, "PATH")) str_copy(g_cfg.path, val, sizeof(g_cfg.path));
+            else if (str_eq(key, "STARTUP")) str_copy(g_cfg.startup, val, sizeof(g_cfg.startup));
+            else if (str_eq(key, "BOOT_SCRIPT")) str_copy(g_cfg.boot_script, val, sizeof(g_cfg.boot_script));
+            else if (str_eq(key, "PROMPT_LEFT")) str_copy(g_cfg.prompt_left, val, sizeof(g_cfg.prompt_left));
+            else if (str_eq(key, "PROMPT_RIGHT")) str_copy(g_cfg.prompt_right, val, sizeof(g_cfg.prompt_right));
+            else if (str_eq(key, "HISTORY_FILE")) str_copy(g_cfg.history_file, val, sizeof(g_cfg.history_file));
+            else if (str_eq(key, "HISTORY_SIZE")) g_cfg.history_size = atoi(val);
+            else if (str_eq(key, "GLOB")) parse_bool(val, &g_cfg.glob_enabled);
+            else if (str_eq(key, "COMPLETE")) parse_bool(val, &g_cfg.complete_enabled);
+            else if (str_eq(key, "SUGGEST")) parse_bool(val, &g_cfg.suggest_enabled);
+        }
+
+        line = end + (saved ? 1 : 0);
+        if (saved == '\r' && *line == '\n') line++;
+    }
+
+    split_path(g_cfg.path);
+}
+
+static void history_load(void) {
+    g_history_count = 0;
+    if (!g_cfg.history_file[0]) return;
+
+    int fd = sys_open(g_cfg.history_file, "r");
+    if (fd < 0) return;
+
+    char buf[4096];
+    int bytes = sys_read(fd, buf, sizeof(buf) - 1);
+    sys_close(fd);
+    if (bytes <= 0) return;
+    buf[bytes] = 0;
+
+    char *line = buf;
+    while (*line && g_history_count < MAX_HISTORY) {
+        char *end = line;
+        while (*end && *end != '\n' && *end != '\r') end++;
+        char saved = *end;
+        *end = 0;
+        trim(line);
+        if (line[0]) {
+            str_copy(g_history[g_history_count++], line, MAX_LINE);
+        }
+        line = end + (saved ? 1 : 0);
+        if (saved == '\r' && *line == '\n') line++;
+    }
+}
+
+static void history_save(void) {
+    if (!g_cfg.history_file[0]) return;
+
+    int fd = sys_open(g_cfg.history_file, "w");
+    if (fd < 0) return;
+
+    for (int i = 0; i < g_history_count; i++) {
+        int len = (int)strlen(g_history[i]);
+        if (len > 0) {
+            sys_write_fs(fd, g_history[i], len);
+            sys_write_fs(fd, "\n", 1);
+        }
+    }
+    sys_close(fd);
+}
+
+static void history_add(const char *line) {
+    if (!line || !line[0]) return;
+    if (g_history_count > 0 && str_eq(g_history[g_history_count - 1], line)) return;
+
+    if (g_history_count < MAX_HISTORY) {
+        str_copy(g_history[g_history_count++], line, MAX_LINE);
+    } else {
+        for (int i = 1; i < MAX_HISTORY; i++) {
+            str_copy(g_history[i - 1], g_history[i], MAX_LINE);
+        }
+        str_copy(g_history[MAX_HISTORY - 1], line, MAX_LINE);
+    }
+    if (g_history_count > g_cfg.history_size && g_cfg.history_size > 0) {
+        int excess = g_history_count - g_cfg.history_size;
+        for (int i = excess; i < g_history_count; i++) {
+            str_copy(g_history[i - excess], g_history[i], MAX_LINE);
+        }
+        g_history_count -= excess;
+    }
+    history_save();
+}
+
+static void get_time_string(char *out, int max_len) {
+    int dt[6] = {0};
+    sys_system(11, (uint64_t)dt, 0, 0, 0);
+    char hh[4], mm[4];
+    itoa(dt[3], hh);
+    itoa(dt[4], mm);
+    out[0] = 0;
+    if (dt[3] < 10) str_copy(out, "0", max_len);
+    str_append(out, hh, max_len);
+    str_append(out, ":", max_len);
+    if (dt[4] < 10) str_append(out, "0", max_len);
+    str_append(out, mm, max_len);
+}
+
+static void format_prompt(const char *tmpl, char *out, int max_len) {
+    char cwd[256];
+    if (!getcwd(cwd, sizeof(cwd))) str_copy(cwd, "/", sizeof(cwd));
+
+    int out_idx = 0;
+    for (int i = 0; tmpl[i] && out_idx < max_len - 1; i++) {
+        if (tmpl[i] == '%' && tmpl[i + 1]) {
+            char token = tmpl[i + 1];
+            if (token == '~') {
+                if (starts_with(cwd, "/root") && (cwd[5] == 0 || cwd[5] == '/')) {
+                    out[out_idx++] = '~';
+                    int j = 5;
+                    while (cwd[j] && out_idx < max_len - 1) {
+                        out[out_idx++] = cwd[j++];
+                    }
+                } else {
+                    int j = 0;
+                    while (cwd[j] && out_idx < max_len - 1) {
+                        out[out_idx++] = cwd[j++];
+                    }
+                }
+                i++;
+                continue;
+            }
+            if (token == 'n') {
+                const char *user = "root";
+                int j = 0;
+                while (user[j] && out_idx < max_len - 1) out[out_idx++] = user[j++];
+                i++;
+                continue;
+            }
+            if (token == 'h') {
+                const char *host = "boredos";
+                int j = 0;
+                while (host[j] && out_idx < max_len - 1) out[out_idx++] = host[j++];
+                i++;
+                continue;
+            }
+            if (token == 'T') {
+                char time_buf[16];
+                get_time_string(time_buf, sizeof(time_buf));
+                int j = 0;
+                while (time_buf[j] && out_idx < max_len - 1) out[out_idx++] = time_buf[j++];
+                i++;
+                continue;
+            }
+        }
+        out[out_idx++] = tmpl[i];
+    }
+    out[out_idx] = 0;
+}
+
+static int split_args(char *line, char *argv[], int max_args) {
+    int argc = 0;
+    int i = 0;
+    while (line[i] && argc < max_args) {
+        while (line[i] == ' ' || line[i] == '\t') i++;
+        if (!line[i]) break;
+
+        if (line[i] == '"') {
+            i++;
+            argv[argc++] = &line[i];
+            while (line[i] && line[i] != '"') i++;
+            if (line[i]) {
+                line[i] = 0;
+                i++;
+            }
+        } else {
+            argv[argc++] = &line[i];
+            while (line[i] && line[i] != ' ' && line[i] != '\t') i++;
+            if (line[i]) {
+                line[i] = 0;
+                i++;
+            }
+        }
+    }
+    return argc;
+}
+
+static bool is_file_path(const char *path) {
+    FAT32_FileInfo info;
+    if (sys_get_file_info(path, &info) == 0 && !info.is_directory) return true;
+    return false;
+}
+
+static bool run_script(const char *path);
+
+static void resolve_path(const char *input, char *out, int max_len) {
+    if (!out || max_len <= 0) return;
+    if (!input || !input[0]) {
+        out[0] = 0;
+        return;
+    }
+    if (input[0] == '/') {
+        str_copy(out, input, max_len);
+        return;
+    }
+
+    char cwd[256];
+    if (!getcwd(cwd, sizeof(cwd))) {
+        str_copy(out, input, max_len);
+        return;
+    }
+
+    str_copy(out, cwd, max_len);
+    int len = (int)strlen(out);
+    if (len > 0 && out[len - 1] != '/') str_append(out, "/", max_len);
+    str_append(out, input, max_len);
+}
+
+static bool resolve_script_path(const char *input, char *out, int max_len) {
+    char candidate[256];
+    resolve_path(input, candidate, sizeof(candidate));
+    if (is_file_path(candidate)) {
+        str_copy(out, candidate, max_len);
+        return true;
+    }
+    if (!ends_with(candidate, ".bsh")) {
+        char with_ext[256];
+        str_copy(with_ext, candidate, sizeof(with_ext));
+        str_append(with_ext, ".bsh", sizeof(with_ext));
+        if (is_file_path(with_ext)) {
+            str_copy(out, with_ext, max_len);
+            return true;
+        }
+    }
+    return false;
+}
+
+static bool is_elf_file(const char *path) {
+    unsigned char hdr[4];
+    int fd = sys_open(path, "r");
+    if (fd < 0) return false;
+    int bytes = sys_read(fd, hdr, 4);
+    sys_close(fd);
+    if (bytes < 4) return false;
+    return hdr[0] == 0x7F && hdr[1] == 'E' && hdr[2] == 'L' && hdr[3] == 'F';
+}
+
+static int resolve_command(const char *cmd, char *out, int out_len) {
+    if (!cmd || !cmd[0]) return -1;
+
+    bool has_slash = false;
+    for (int i = 0; cmd[i]; i++) {
+        if (cmd[i] == '/') { has_slash = true; break; }
+    }
+
+    if (has_slash) {
+        if (sys_exists(cmd)) {
+            if (!is_file_path(cmd)) return -2;
+            if (!is_elf_file(cmd)) return -3;
+            str_copy(out, cmd, out_len);
+            return 0;
+        }
+        if (!ends_with(cmd, ".elf")) {
+            char temp[256];
+            str_copy(temp, cmd, sizeof(temp));
+            str_append(temp, ".elf", sizeof(temp));
+            if (sys_exists(temp)) {
+                if (!is_file_path(temp)) return -2;
+                if (!is_elf_file(temp)) return -3;
+                str_copy(out, temp, out_len);
+                return 0;
+            }
+        }
+        return -1;
+    }
+
+    for (int i = 0; i < g_path_count; i++) {
+        char temp[256];
+        temp[0] = 0;
+        str_copy(temp, g_paths[i], sizeof(temp));
+        if (temp[0] && temp[strlen(temp) - 1] != '/') str_append(temp, "/", sizeof(temp));
+        str_append(temp, cmd, sizeof(temp));
+        if (sys_exists(temp) && is_file_path(temp) && is_elf_file(temp)) {
+            str_copy(out, temp, out_len);
+            return 0;
+        }
+        if (!ends_with(cmd, ".elf")) {
+            str_append(temp, ".elf", sizeof(temp));
+            if (sys_exists(temp) && is_file_path(temp) && is_elf_file(temp)) {
+                str_copy(out, temp, out_len);
+                return 0;
+            }
+        }
+    }
+
+    return -1;
+}
+
+static void build_args_string(int argc, char *argv[], int start, char *out, int out_len) {
+    int pos = 0;
+    for (int i = start; i < argc; i++) {
+        if (i > start && pos < out_len - 1) out[pos++] = ' ';
+
+        bool need_quotes = false;
+        for (int j = 0; argv[i][j]; j++) {
+            if (argv[i][j] == ' ') { need_quotes = true; break; }
+        }
+        if (need_quotes && pos < out_len - 1) out[pos++] = '"';
+
+        for (int j = 0; argv[i][j] && pos < out_len - 1; j++) {
+            out[pos++] = argv[i][j];
+        }
+
+        if (need_quotes && pos < out_len - 1) out[pos++] = '"';
+    }
+    out[pos] = 0;
+}
+
+static bool is_space_char(char c) {
+    return c == ' ' || c == '\t';
+}
+
+static int find_token_start(const char *line, int len) {
+    int i = len - 1;
+    while (i >= 0 && !is_space_char(line[i])) i--;
+    return i + 1;
+}
+
+static int common_prefix_len(char matches[][MAX_MATCH_LEN], int count) {
+    if (count <= 0) return 0;
+    int len = (int)strlen(matches[0]);
+    for (int i = 1; i < count; i++) {
+        int j = 0;
+        while (j < len && matches[i][j] && matches[i][j] == matches[0][j]) j++;
+        len = j;
+        if (len == 0) break;
+    }
+    return len;
+}
+
+static int add_match_unique(char matches[][MAX_MATCH_LEN], int count, const char *candidate) {
+    if (!candidate || !candidate[0]) return count;
+    for (int i = 0; i < count; i++) {
+        if (str_eq(matches[i], candidate)) return count;
+    }
+    if (count >= MAX_MATCHES) return count;
+    str_copy(matches[count], candidate, MAX_MATCH_LEN);
+    return count + 1;
+}
+
+static void build_path_match(const char *dir_part, const char *entry, bool is_dir, char *out, int out_len) {
+    out[0] = 0;
+    if (dir_part && dir_part[0] && !(dir_part[0] == '.' && dir_part[1] == 0)) {
+        str_copy(out, dir_part, out_len);
+        int len = (int)strlen(out);
+        if (len > 0 && out[len - 1] != '/') str_append(out, "/", out_len);
+    }
+    str_append(out, entry, out_len);
+    if (is_dir) str_append(out, "/", out_len);
+}
+
+static int collect_command_matches(const char *prefix, char matches[][MAX_MATCH_LEN]) {
+    int count = 0;
+    const char *builtins[] = {
+        "cd", "pwd", "ls", "cat", "echo", "clear", "mkdir", "rm",
+        "touch", "cp", "mv", "man", "alias", "unalias", ".", "exit"
+    };
+    for (int i = 0; i < (int)(sizeof(builtins) / sizeof(builtins[0])); i++) {
+        if (starts_with(builtins[i], prefix)) count = add_match_unique(matches, count, builtins[i]);
+    }
+
+    for (int i = 0; i < g_alias_count; i++) {
+        if (starts_with(g_aliases[i].name, prefix)) {
+            count = add_match_unique(matches, count, g_aliases[i].name);
+        }
+    }
+
+    FAT32_FileInfo entries[128];
+    for (int i = 0; i < g_path_count; i++) {
+        int got = sys_list(g_paths[i], entries, 128);
+        if (got <= 0) continue;
+        for (int j = 0; j < got; j++) {
+            if (entries[j].is_directory) continue;
+            if (starts_with(entries[j].name, prefix)) {
+                count = add_match_unique(matches, count, entries[j].name);
+            }
+        }
+    }
+    return count;
+}
+
+static int collect_path_matches(const char *dir_part, const char *prefix, char matches[][MAX_MATCH_LEN]) {
+    const char *list_dir = (dir_part && dir_part[0]) ? dir_part : ".";
+    FAT32_FileInfo entries[128];
+    int got = sys_list(list_dir, entries, 128);
+    if (got <= 0) return 0;
+
+    int count = 0;
+    for (int i = 0; i < got; i++) {
+        if (!starts_with(entries[i].name, prefix)) continue;
+        char full[MAX_MATCH_LEN];
+        build_path_match(dir_part, entries[i].name, entries[i].is_directory, full, sizeof(full));
+        count = add_match_unique(matches, count, full);
+    }
+    return count;
+}
+
+static void redraw_input(const char *prompt, const char *line, int len) {
+    sys_write(1, "\r", 1);
+    sys_write(1, prompt, (int)strlen(prompt));
+    sys_write(1, line, len);
+    sys_write(1, "\x1b[K", 3);
+}
+
+static void show_matches(const char *prompt, const char *line, int len, char matches[][MAX_MATCH_LEN], int count) {
+    sys_write(1, "\n", 1);
+    for (int i = 0; i < count; i++) {
+        sys_write(1, matches[i], (int)strlen(matches[i]));
+        sys_write(1, "  ", 2);
+    }
+    sys_write(1, "\n", 1);
+    redraw_input(prompt, line, len);
+}
+
+static int pid_exists(int pid) {
+    char path[64];
+    path[0] = 0;
+    strcat(path, "/proc/");
+    char pid_buf[16];
+    itoa(pid, pid_buf);
+    strcat(path, pid_buf);
+    strcat(path, "/status");
+    int fd = sys_open(path, "r");
+    if (fd < 0) return 0;
+    char buf[8];
+    int bytes = sys_read(fd, buf, sizeof(buf));
+    sys_close(fd);
+    return bytes > 0;
+}
+
+static void wait_for_pid(int pid) {
+    while (pid_exists(pid)) {
+        if (g_tty_id >= 0) {
+            int fg = sys_tty_get_fg(g_tty_id);
+            if (fg != pid) break;
+        }
+        sleep(10);
+    }
+}
+
+static void cmd_clear(void) {
+    sys_write(1, "\x1b[2J\x1b[H", 7);
+}
+
+static int builtin_cd(int argc, char *argv[]) {
+    const char *path = (argc > 1) ? argv[1] : "/";
+    if (chdir(path) != 0) {
+        set_color(g_color_error);
+        printf("cd: no such directory: %s\n", path);
+        reset_color();
+        return 1;
+    }
+    return 0;
+}
+
+static int builtin_pwd(void) {
+    char cwd[256];
+    if (getcwd(cwd, sizeof(cwd))) {
+        printf("%s\n", cwd);
+        return 0;
+    }
+    return 1;
+}
+
+static int builtin_echo(int argc, char *argv[]) {
+    for (int i = 1; i < argc; i++) {
+        if (i > 1) sys_write(1, " ", 1);
+        sys_write(1, argv[i], (int)strlen(argv[i]));
+    }
+    sys_write(1, "\n", 1);
+    return 0;
+}
+
+static int builtin_ls(int argc, char *argv[]) {
+    char path[256];
+    if (argc > 1) str_copy(path, argv[1], sizeof(path));
+    else if (!getcwd(path, sizeof(path))) str_copy(path, "/", sizeof(path));
+
+    FAT32_FileInfo info;
+    if (sys_get_file_info(path, &info) < 0) {
+        set_color(g_color_error);
+        printf("ls: cannot access %s\n", path);
+        reset_color();
+        return 1;
+    }
+    if (!info.is_directory) {
+        set_color(g_color_file);
+        printf("%s\n", info.name);
+        reset_color();
+        return 0;
+    }
+
+    FAT32_FileInfo entries[128];
+    int count = sys_list(path, entries, 128);
+    if (count < 0) {
+        set_color(g_color_error);
+        printf("ls: cannot list %s\n", path);
+        reset_color();
+        return 1;
+    }
+
+    for (int i = 0; i < count; i++) {
+        if (entries[i].is_directory) {
+            set_color(g_color_dir);
+            printf("[DIR]  %s\n", entries[i].name);
+        } else {
+            set_color(g_color_file);
+            printf("[FILE] %s", entries[i].name);
+            set_color(g_color_size);
+            printf(" (%d bytes)\n", entries[i].size);
+        }
+    }
+    reset_color();
+    return 0;
+}
+
+static int builtin_cat(int argc, char *argv[]) {
+    if (argc < 2) {
+        set_color(g_color_error);
+        printf("Usage: cat <file>\n");
+        reset_color();
+        return 1;
+    }
+
+    for (int i = 1; i < argc; i++) {
+        int fd = sys_open(argv[i], "r");
+        if (fd < 0) {
+            set_color(g_color_error);
+            printf("cat: cannot open %s\n", argv[i]);
+            reset_color();
+            continue;
+        }
+        char buffer[4096];
+        int bytes;
+        while ((bytes = sys_read(fd, buffer, sizeof(buffer))) > 0) {
+            sys_write(1, buffer, bytes);
+        }
+        sys_close(fd);
+    }
+    reset_color();
+    return 0;
+}
+
+static int builtin_mkdir(int argc, char *argv[]) {
+    if (argc < 2) {
+        set_color(g_color_error);
+        printf("Usage: mkdir <dir>\n");
+        reset_color();
+        return 1;
+    }
+    if (sys_mkdir(argv[1]) == 0) return 0;
+    set_color(g_color_error);
+    printf("mkdir: cannot create %s\n", argv[1]);
+    reset_color();
+    return 1;
+}
+
+static int builtin_rm(int argc, char *argv[]) {
+    if (argc < 2) {
+        set_color(g_color_error);
+        printf("Usage: rm <path>\n");
+        reset_color();
+        return 1;
+    }
+    if (sys_delete(argv[1]) == 0) return 0;
+    set_color(g_color_error);
+    printf("rm: cannot delete %s\n", argv[1]);
+    reset_color();
+    return 1;
+}
+
+static int builtin_touch(int argc, char *argv[]) {
+    if (argc < 2) {
+        set_color(g_color_error);
+        printf("Usage: touch <file>\n");
+        reset_color();
+        return 1;
+    }
+    int fd = sys_open(argv[1], "w");
+    if (fd < 0) {
+        set_color(g_color_error);
+        printf("touch: cannot create %s\n", argv[1]);
+        reset_color();
+        return 1;
+    }
+    sys_close(fd);
+    return 0;
+}
+
+static void combine_path(char *dest, const char *path1, const char *path2) {
+    int i = 0;
+    while (path1[i]) {
+        dest[i] = path1[i];
+        i++;
+    }
+    if (i > 0 && dest[i - 1] != '/') dest[i++] = '/';
+    int j = 0;
+    while (path2[j]) dest[i++] = path2[j++];
+    dest[i] = 0;
+}
+
+static const char* get_basename(const char *path) {
+    const char *last = NULL;
+    int len = 0;
+    while (path[len]) {
+        if (path[len] == '/') last = path + len;
+        len++;
+    }
+    if (!last) return path;
+    if (last[1] == 0) {
+        if (len <= 1) return path;
+        int i = len - 2;
+        while (i >= 0 && path[i] != '/') i--;
+        if (i < 0) return path;
+        return path + i + 1;
+    }
+    return last + 1;
+}
+
+static void copy_recursive(const char *src, const char *dst) {
+    FAT32_FileInfo info;
+    if (sys_get_file_info(src, &info) < 0) return;
+
+    if (info.is_directory) {
+        sys_mkdir(dst);
+        FAT32_FileInfo entries[64];
+        int count = sys_list(src, entries, 64);
+        for (int i = 0; i < count; i++) {
+            if (str_eq(entries[i].name, ".") || str_eq(entries[i].name, "..")) continue;
+            char sub_src[512], sub_dst[512];
+            combine_path(sub_src, src, entries[i].name);
+            combine_path(sub_dst, dst, entries[i].name);
+            copy_recursive(sub_src, sub_dst);
+        }
+    } else {
+        int fd_in = sys_open(src, "r");
+        if (fd_in < 0) return;
+        int fd_out = sys_open(dst, "w");
+        if (fd_out < 0) { sys_close(fd_in); return; }
+        char buffer[4096];
+        int bytes;
+        while ((bytes = sys_read(fd_in, buffer, sizeof(buffer))) > 0) {
+            sys_write_fs(fd_out, buffer, bytes);
+        }
+        sys_close(fd_in);
+        sys_close(fd_out);
+    }
+}
+
+static void delete_recursive(const char *path) {
+    FAT32_FileInfo info;
+    if (sys_get_file_info(path, &info) < 0) return;
+
+    if (info.is_directory) {
+        FAT32_FileInfo entries[64];
+        int count = sys_list(path, entries, 64);
+        for (int i = 0; i < count; i++) {
+            if (str_eq(entries[i].name, ".") || str_eq(entries[i].name, "..")) continue;
+            char sub_path[512];
+            combine_path(sub_path, path, entries[i].name);
+            delete_recursive(sub_path);
+        }
+        sys_delete(path);
+    } else {
+        sys_delete(path);
+    }
+}
+
+static int builtin_cp(int argc, char *argv[]) {
+    bool recursive = false;
+    char *src = NULL;
+    char *dst = NULL;
+    for (int i = 1; i < argc; i++) {
+        if (str_eq(argv[i], "-r")) recursive = true;
+        else if (!src) src = argv[i];
+        else if (!dst) dst = argv[i];
+    }
+    if (!src || !dst) {
+        set_color(g_color_error);
+        printf("Usage: cp [-r] <source> <dest>\n");
+        reset_color();
+        return 1;
+    }
+
+    FAT32_FileInfo info_src;
+    if (sys_get_file_info(src, &info_src) < 0) {
+        set_color(g_color_error);
+        printf("cp: source does not exist\n");
+        reset_color();
+        return 1;
+    }
+    if (info_src.is_directory && !recursive) {
+        set_color(g_color_error);
+        printf("cp: %s is a directory (use -r)\n", src);
+        reset_color();
+        return 1;
+    }
+
+    char actual_dst[512];
+    FAT32_FileInfo info_dst;
+    if (sys_get_file_info(dst, &info_dst) == 0 && info_dst.is_directory) {
+        const char *base = get_basename(src);
+        combine_path(actual_dst, dst, base);
+    } else {
+        str_copy(actual_dst, dst, sizeof(actual_dst));
+    }
+
+    if (recursive) copy_recursive(src, actual_dst);
+    else copy_recursive(src, actual_dst);
+    return 0;
+}
+
+static int builtin_mv(int argc, char *argv[]) {
+    if (argc < 3) {
+        set_color(g_color_error);
+        printf("Usage: mv <source> <dest>\n");
+        reset_color();
+        return 1;
+    }
+
+    char *src = argv[1];
+    char *dst = argv[2];
+
+    char actual_dst[512];
+    FAT32_FileInfo info_dst;
+    if (sys_get_file_info(dst, &info_dst) == 0 && info_dst.is_directory) {
+        const char *base = get_basename(src);
+        combine_path(actual_dst, dst, base);
+    } else {
+        str_copy(actual_dst, dst, sizeof(actual_dst));
+    }
+
+    copy_recursive(src, actual_dst);
+    delete_recursive(src);
+    return 0;
+}
+
+static int builtin_man(int argc, char *argv[]) {
+    if (argc < 2) {
+        set_color(g_color_error);
+        printf("What manual page do you want? Example: man ls\n");
+        reset_color();
+        return 0;
+    }
+
+    char path[128];
+    str_copy(path, "/Library/man/", sizeof(path));
+    str_append(path, argv[1], sizeof(path));
+    str_append(path, ".txt", sizeof(path));
+
+    int fd = sys_open(path, "r");
+    if (fd < 0) {
+        set_color(g_color_error);
+        printf("No manual entry for %s\n", argv[1]);
+        reset_color();
+        return 1;
+    }
+
+    char buffer[4096];
+    int bytes;
+    while ((bytes = sys_read(fd, buffer, sizeof(buffer))) > 0) {
+        sys_write(1, buffer, bytes);
+    }
+    sys_close(fd);
+    printf("\n");
+    return 0;
+}
+
+static int builtin_alias(int argc, char *argv[]) {
+    if (argc == 1) {
+        for (int i = 0; i < g_alias_count; i++) {
+            printf("alias %s=%s\n", g_aliases[i].name, g_aliases[i].value);
+        }
+        return 0;
+    }
+
+    for (int i = 1; i < argc; i++) {
+        char *eq = argv[i];
+        while (*eq && *eq != '=') eq++;
+        if (*eq != '=') {
+            const char *val = alias_get(argv[i]);
+            if (val) {
+                printf("alias %s=%s\n", argv[i], val);
+                continue;
+            }
+            set_color(g_color_error);
+            printf("alias: invalid definition: %s\n", argv[i]);
+            reset_color();
+            return 1;
+        }
+        *eq = 0;
+        alias_add(argv[i], eq + 1);
+    }
+    return 0;
+}
+
+static int builtin_unalias(int argc, char *argv[]) {
+    if (argc < 2) {
+        set_color(g_color_error);
+        printf("Usage: unalias <name>\n");
+        reset_color();
+        return 1;
+    }
+    for (int i = 1; i < argc; i++) alias_remove(argv[i]);
+    return 0;
+}
+
+static int execute_builtin(int argc, char *argv[]) {
+    if (argc == 0) return 0;
+    if (str_eq(argv[0], "cd")) return builtin_cd(argc, argv);
+    if (str_eq(argv[0], "pwd")) return builtin_pwd();
+    if (str_eq(argv[0], "ls")) return builtin_ls(argc, argv);
+    if (str_eq(argv[0], "cat")) return builtin_cat(argc, argv);
+    if (str_eq(argv[0], "echo")) return builtin_echo(argc, argv);
+    if (str_eq(argv[0], "clear")) { cmd_clear(); return 0; }
+    if (str_eq(argv[0], "mkdir")) return builtin_mkdir(argc, argv);
+    if (str_eq(argv[0], "rm")) return builtin_rm(argc, argv);
+    if (str_eq(argv[0], "touch")) return builtin_touch(argc, argv);
+    if (str_eq(argv[0], "cp")) return builtin_cp(argc, argv);
+    if (str_eq(argv[0], "mv")) return builtin_mv(argc, argv);
+    if (str_eq(argv[0], "man")) return builtin_man(argc, argv);
+    if (str_eq(argv[0], "alias")) return builtin_alias(argc, argv);
+    if (str_eq(argv[0], "unalias")) return builtin_unalias(argc, argv);
+    if (str_eq(argv[0], ".")) {
+        if (argc < 2) {
+            set_color(g_color_error);
+            printf("Usage: . <script>\n");
+            reset_color();
+            return 1;
+        }
+        if (!run_script(argv[1])) {
+            set_color(g_color_error);
+            printf("bsh: cannot run script: %s\n", argv[1]);
+            reset_color();
+            return 1;
+        }
+        return 0;
+    }
+    if (str_eq(argv[0], "exit")) return 2;
+    return -1;
+}
+
+static int execute_line_inner(const char *line, int depth) {
+    if (!line || !line[0]) return 0;
+    if (depth > 8) return 1;
+
+    char line_copy[MAX_LINE];
+    str_copy(line_copy, line, sizeof(line_copy));
+    trim(line_copy);
+    if (!line_copy[0]) return 0;
+    if (line_copy[0] == '#') return 0;
+
+    char *argv[MAX_ARGS];
+    int argc = split_args(line_copy, argv, MAX_ARGS);
+    if (argc <= 0) return 0;
+
+    if (!str_eq(argv[0], "alias") && !str_eq(argv[0], "unalias")) {
+        const char *alias_val = alias_get(argv[0]);
+        if (alias_val) {
+            char expanded[MAX_LINE];
+            str_copy(expanded, alias_val, sizeof(expanded));
+
+            char tail[MAX_LINE];
+            build_args_string(argc, argv, 1, tail, sizeof(tail));
+            if (tail[0]) {
+                str_append(expanded, " ", sizeof(expanded));
+                str_append(expanded, tail, sizeof(expanded));
+            }
+            return execute_line_inner(expanded, depth + 1);
+        }
+    }
+
+    int bi = execute_builtin(argc, argv);
+    if (bi == 2) return 2;
+    if (bi >= 0) return 0;
+
+    char full_path[256];
+    int cmd_res = resolve_command(argv[0], full_path, sizeof(full_path));
+    if (cmd_res == -2) {
+        set_color(g_color_error);
+        printf("bsh: is a directory: %s\n", argv[0]);
+        reset_color();
+        return 1;
+    }
+    if (cmd_res == -3) {
+        set_color(g_color_error);
+        printf("bsh: not executable: %s\n", argv[0]);
+        reset_color();
+        return 1;
+    }
+    if (cmd_res != 0) {
+        set_color(g_color_error);
+        printf("bsh: command not found: %s\n", argv[0]);
+        reset_color();
+        return 1;
+    }
+
+    char args_buf[256];
+    build_args_string(argc, argv, 1, args_buf, sizeof(args_buf));
+
+    int pid = sys_spawn(full_path, args_buf[0] ? args_buf : NULL, SPAWN_FLAG_TERMINAL | SPAWN_FLAG_INHERIT_TTY, 0);
+    if (pid < 0) {
+        set_color(g_color_error);
+        printf("bsh: failed to launch: %s\n", full_path);
+        reset_color();
+        return 1;
+    }
+
+    if (g_tty_id >= 0) sys_tty_set_fg(g_tty_id, pid);
+    wait_for_pid(pid);
+    if (g_tty_id >= 0) sys_tty_set_fg(g_tty_id, 0);
+
+    return 0;
+}
+
+static int execute_line(const char *line) {
+    return execute_line_inner(line, 0);
+}
+
+static bool run_script(const char *path) {
+    if (!path || !path[0]) return false;
+    char resolved[256];
+    if (!resolve_script_path(path, resolved, sizeof(resolved))) return false;
+
+    int fd = sys_open(resolved, "r");
+    if (fd < 0) return false;
+
+    char buf[4096];
+    int bytes = sys_read(fd, buf, sizeof(buf) - 1);
+    sys_close(fd);
+    if (bytes <= 0) return true;
+
+    buf[bytes] = 0;
+    char *line = buf;
+    while (*line) {
+        char *end = line;
+        while (*end && *end != '\n' && *end != '\r') end++;
+        char saved = *end;
+        *end = 0;
+
+        trim(line);
+        if (line[0]) execute_line(line);
+
+        line = end + (saved ? 1 : 0);
+        if (saved == '\r' && *line == '\n') line++;
+    }
+    return true;
+}
+
+static int read_line(char *out, int max_len, const char *prompt) {
+    int len = 0;
+    int hist_index = g_history_count;
+    bool search_mode = false;
+    char saved_line[MAX_LINE];
+    saved_line[0] = 0;
+    char search_prefix[MAX_LINE];
+    search_prefix[0] = 0;
+    out[0] = 0;
+
+    while (1) {
+        char ch = 0;
+        int got = sys_tty_read_in(&ch, 1);
+        if (got <= 0) {
+            sys_yield();
+            continue;
+        }
+
+        if (ch == 3) { // Ctrl+C
+            sys_write(1, "^C\n", 3);
+            out[0] = 0;
+            return 0;
+        }
+
+        if (ch == '\r' || ch == '\n') {
+            sys_write(1, "\n", 1);
+            out[len] = 0;
+            return len;
+        }
+
+        if (ch == '\b' || ch == 127) {
+            if (len > 0) {
+                len--;
+                out[len] = 0;
+                sys_write(1, "\b \b", 3);
+            }
+            search_mode = false;
+            hist_index = g_history_count;
+            continue;
+        }
+
+        if (ch == '\t') {
+            if (!g_cfg.complete_enabled) continue;
+            int token_start = find_token_start(out, len);
+            int token_len = len - token_start;
+            if (token_len <= 0) continue;
+
+            char token[MAX_MATCH_LEN];
+            int copy_len = token_len < (int)sizeof(token) - 1 ? token_len : (int)sizeof(token) - 1;
+            for (int i = 0; i < copy_len; i++) token[i] = out[token_start + i];
+            token[copy_len] = 0;
+
+            bool has_slash = false;
+            for (int i = 0; token[i]; i++) {
+                if (token[i] == '/') { has_slash = true; break; }
+            }
+
+            char matches[MAX_MATCHES][MAX_MATCH_LEN];
+            int match_count = 0;
+
+            if (token_start == 0 && !has_slash) {
+                match_count = collect_command_matches(token, matches);
+            } else {
+                char dir_part[MAX_PATH_LEN];
+                char prefix[MAX_PATH_LEN];
+                int last_slash = -1;
+                for (int i = 0; token[i]; i++) if (token[i] == '/') last_slash = i;
+                if (last_slash >= 0) {
+                    int dlen = last_slash + 1;
+                    if (dlen >= (int)sizeof(dir_part)) dlen = (int)sizeof(dir_part) - 1;
+                    for (int i = 0; i < dlen; i++) dir_part[i] = token[i];
+                    dir_part[dlen] = 0;
+                    str_copy(prefix, token + last_slash + 1, sizeof(prefix));
+                } else {
+                    dir_part[0] = 0;
+                    str_copy(prefix, token, sizeof(prefix));
+                }
+
+                match_count = collect_path_matches(dir_part, prefix, matches);
+            }
+
+            if (match_count == 0) continue;
+
+            if (match_count == 1) {
+                out[token_start] = 0;
+                str_append(out, matches[0], max_len);
+                len = (int)strlen(out);
+                redraw_input(prompt, out, len);
+            } else {
+                int common_len = common_prefix_len(matches, match_count);
+                if (common_len > token_len) {
+                    char prefix_buf[MAX_MATCH_LEN];
+                    int p = common_len < (int)sizeof(prefix_buf) - 1 ? common_len : (int)sizeof(prefix_buf) - 1;
+                    for (int i = 0; i < p; i++) prefix_buf[i] = matches[0][i];
+                    prefix_buf[p] = 0;
+                    out[token_start] = 0;
+                    str_append(out, prefix_buf, max_len);
+                    len = (int)strlen(out);
+                    redraw_input(prompt, out, len);
+                } else {
+                    show_matches(prompt, out, len, matches, match_count);
+                }
+            }
+            search_mode = false;
+            hist_index = g_history_count;
+            continue;
+        }
+
+        if (ch == 17) { // Up
+            if (g_history_count == 0) continue;
+            if (!search_mode) {
+                str_copy(saved_line, out, sizeof(saved_line));
+                str_copy(search_prefix, out, sizeof(search_prefix));
+                search_mode = true;
+                hist_index = g_history_count;
+            }
+
+            int found = -1;
+            for (int i = hist_index - 1; i >= 0; i--) {
+                if (starts_with(g_history[i], search_prefix)) {
+                    found = i;
+                    break;
+                }
+            }
+            if (found >= 0) {
+                hist_index = found;
+                str_copy(out, g_history[hist_index], max_len);
+                len = (int)strlen(out);
+                redraw_input(prompt, out, len);
+            }
+            continue;
+        }
+
+        if (ch == 18) { // Down
+            if (g_history_count == 0 || !search_mode) continue;
+            int found = -1;
+            for (int i = hist_index + 1; i < g_history_count; i++) {
+                if (starts_with(g_history[i], search_prefix)) {
+                    found = i;
+                    break;
+                }
+            }
+            if (found >= 0) {
+                hist_index = found;
+                str_copy(out, g_history[hist_index], max_len);
+                len = (int)strlen(out);
+            } else {
+                search_mode = false;
+                hist_index = g_history_count;
+                str_copy(out, saved_line, max_len);
+                len = (int)strlen(out);
+            }
+            redraw_input(prompt, out, len);
+            continue;
+        }
+
+        if (ch >= 32 && len < max_len - 1) {
+            out[len++] = ch;
+            out[len] = 0;
+            sys_write(1, &ch, 1);
+            search_mode = false;
+            hist_index = g_history_count;
+        }
+    }
+}
+
+int main(int argc, char **argv) {
+    char start_dir[256];
+    start_dir[0] = 0;
+    for (int i = 1; i < argc; i++) {
+        if (str_eq(argv[i], "-t") && i + 1 < argc) {
+            g_tty_id = atoi(argv[i + 1]);
+            i++;
+        } else if (str_eq(argv[i], "-d") && i + 1 < argc) {
+            str_copy(start_dir, argv[i + 1], sizeof(start_dir));
+            i++;
+        }
+    }
+
+    config_load();
+    load_shell_colors();
+    if (start_dir[0]) {
+        chdir(start_dir);
+    } else if (sys_exists("/root")) {
+        chdir("/root");
+    }
+    history_load();
+
+    if (g_cfg.boot_script[0]) {
+        if (!sys_exists("/Library/bsh/.boot_ran")) {
+            run_script(g_cfg.boot_script);
+            int fd = sys_open("/Library/bsh/.boot_ran", "w");
+            if (fd >= 0) sys_close(fd);
+        }
+    }
+
+    if (g_cfg.startup[0]) {
+        run_script(g_cfg.startup);
+    }
+
+    while (1) {
+        if (g_tty_id >= 0) sys_tty_set_fg(g_tty_id, 0);
+
+        char prompt[128];
+        format_prompt(g_cfg.prompt_left[0] ? g_cfg.prompt_left : DEFAULT_PROMPT, prompt, sizeof(prompt));
+        sys_write(1, prompt, (int)strlen(prompt));
+
+        char line[MAX_LINE];
+        int len = read_line(line, sizeof(line), prompt);
+        if (len <= 0) continue;
+
+        history_add(line);
+        int res = execute_line(line);
+        if (res == 2) break;
+    }
+
+    return 0;
+}
diff --git a/src/userland/cli/cat.c b/src/userland/cli/cat.c
deleted file mode 100644
index f99098b..0000000
--- a/src/userland/cli/cat.c
+++ /dev/null
@@ -1,32 +0,0 @@
-// Copyright (c) 2023-2026 Chris (boreddevnl)
-// This software is released under the GNU General Public License v3.0. See LICENSE file for details.
-// This header needs to maintain in any file it is present in, as per the GPL license terms.
-#include <stdlib.h>
-#include <syscall.h>
-
-int main(int argc, char **argv) {
-    uint32_t error_color = (uint32_t)sys_get_shell_config("error_color");
-    uint32_t default_color = (uint32_t)sys_get_shell_config("default_text_color");
-
-    if (argc < 2) {
-        printf("Usage: cat <filename>\n");
-        return 1;
-    }
-    
-    int fd = sys_open(argv[1], "r");
-    if (fd < 0) {
-        sys_set_text_color(error_color);
-        printf("Error: Cannot open %s\n", argv[1]);
-        sys_set_text_color(default_color);
-        return 1;
-    }
-    
-    char buffer[4096];
-    int bytes;
-    while ((bytes = sys_read(fd, buffer, sizeof(buffer))) > 0) {
-        sys_write(1, buffer, bytes);
-    }
-    
-    sys_close(fd);
-    return 0;
-}
diff --git a/src/userland/cli/cp.c b/src/userland/cli/cp.c
deleted file mode 100644
index 6007e70..0000000
--- a/src/userland/cli/cp.c
+++ /dev/null
@@ -1,166 +0,0 @@
-// Copyright (c) 2023-2026 Chris (boreddevnl)
-// This software is released under the GNU General Public License v3.0. See LICENSE file for details.
-// This header needs to maintain in any file it is present in, as per the GPL license terms.
-#include <stdlib.h>
-#include <syscall.h>
-
-typedef int bool;
-#define true 1
-#define false 0
-
-void combine_path(char *dest, const char *path1, const char *path2) {
-    int i = 0;
-    while (path1[i]) {
-        dest[i] = path1[i];
-        i++;
-    }
-    if (i > 0 && dest[i-1] != '/') {
-        dest[i++] = '/';
-    }
-    int j = 0;
-    while (path2[j]) {
-        dest[i++] = path2[j++];
-    }
-    dest[i] = 0;
-}
-
-const char* get_basename(const char *path) {
-    const char *last_slash = NULL;
-    int len = 0;
-    while (path[len]) {
-        if (path[len] == '/') last_slash = path + len;
-        len++;
-    }
-    
-    if (!last_slash) return path;
-    
-    // If it ends with a slash, skip it and find the previous one
-    if (last_slash[1] == '\0') {
-        if (len <= 1) return path; // root "/"
-        int i = len - 2;
-        while (i >= 0 && path[i] != '/') i--;
-        if (i < 0) return path; 
-        return path + i + 1;
-    }
-    
-    return last_slash + 1;
-}
-
-void copy_recursive(const char *src, const char *dst) {
-    FAT32_FileInfo info;
-    if (sys_get_file_info(src, &info) < 0) {
-        printf("Error: Cannot get info for %s\n", src);
-        return;
-    }
-
-    if (info.is_directory) {
-        if (sys_mkdir(dst) < 0) {
-            // Might already exist
-        }
-        
-        FAT32_FileInfo entries[64];
-        int count = sys_list(src, entries, 64);
-        for (int i = 0; i < count; i++) {
-            if (strcmp(entries[i].name, ".") == 0 || strcmp(entries[i].name, "..") == 0) continue;
-            
-            char sub_src[512], sub_dst[512];
-            combine_path(sub_src, src, entries[i].name);
-            combine_path(sub_dst, dst, entries[i].name);
-            copy_recursive(sub_src, sub_dst);
-        }
-    } else {
-        int fd_in = sys_open(src, "r");
-        if (fd_in < 0) {
-            printf("Error: Cannot open source %s\n", src);
-            return;
-        }
-        int fd_out = sys_open(dst, "w");
-        if (fd_out < 0) {
-            printf("Error: Cannot create destination %s\n", dst);
-            sys_close(fd_in);
-            return;
-        }
-        char buffer[4096];
-        int bytes;
-        while ((bytes = sys_read(fd_in, buffer, sizeof(buffer))) > 0) {
-            sys_write_fs(fd_out, buffer, bytes);
-        }
-        sys_close(fd_in);
-        sys_close(fd_out);
-    }
-}
-
-int main(int argc, char **argv) {
-    bool recursive = false;
-    char *src_path = NULL;
-    char *dst_path = NULL;
-
-    for (int i = 1; i < argc; i++) {
-        if (strcmp(argv[i], "-r") == 0) {
-            recursive = true;
-        } else if (!src_path) {
-            src_path = argv[i];
-        } else if (!dst_path) {
-            dst_path = argv[i];
-        }
-    }
-
-    if (!src_path || !dst_path) {
-        printf("Usage: cp [-r] <source> <dest>\n");
-        return 1;
-    }
-    
-    FAT32_FileInfo info_src;
-    if (sys_get_file_info(src_path, &info_src) < 0) {
-        printf("Error: Source %s does not exist\n", src_path);
-        return 1;
-    }
-
-    if (info_src.is_directory && !recursive) {
-        printf("Error: %s is a directory (use -r to copy recursively)\n", src_path);
-        return 1;
-    }
-
-    char actual_dst[512];
-    FAT32_FileInfo info_dst;
-    if (sys_get_file_info(dst_path, &info_dst) == 0 && info_dst.is_directory) {
-        // If destination is a directory, copy INTO it
-        const char *base = get_basename(src_path);
-        // Clean up trailing slash from basename if any (get_basename handles it mostly)
-        char clean_base[256];
-        int k = 0;
-        while (base[k] && base[k] != '/') {
-            clean_base[k] = base[k];
-            k++;
-        }
-        clean_base[k] = 0;
-        combine_path(actual_dst, dst_path, clean_base);
-    } else {
-        strcpy(actual_dst, dst_path);
-    }
-
-    if (recursive) {
-        copy_recursive(src_path, actual_dst);
-    } else {
-        int fd_in = sys_open(src_path, "r");
-        if (fd_in < 0) {
-            printf("Error: Cannot open source %s\n", src_path);
-            return 1;
-        }
-        int fd_out = sys_open(actual_dst, "w");
-        if (fd_out < 0) {
-            printf("Error: Cannot create destination %s\n", actual_dst);
-            sys_close(fd_in);
-            return 1;
-        }
-        char buffer[4096];
-        int bytes;
-        while ((bytes = sys_read(fd_in, buffer, sizeof(buffer))) > 0) {
-            sys_write_fs(fd_out, buffer, bytes);
-        }
-        sys_close(fd_in);
-        sys_close(fd_out);
-    }
-    
-    return 0;
-}
diff --git a/src/userland/cli/ls.c b/src/userland/cli/ls.c
deleted file mode 100644
index 56c611d..0000000
--- a/src/userland/cli/ls.c
+++ /dev/null
@@ -1,66 +0,0 @@
-// Copyright (c) 2023-2026 Chris (boreddevnl)
-// This software is released under the GNU General Public License v3.0. See LICENSE file for details.
-// This header needs to maintain in any file it is present in, as per the GPL license terms.
-#include <stdlib.h>
-#include <syscall.h>
-
-int main(int argc, char **argv) {
-    uint64_t dir_color = sys_get_shell_config("dir_color");
-    uint64_t file_color = sys_get_shell_config("file_color");
-    uint64_t size_color = sys_get_shell_config("size_color");
-    uint64_t error_color = sys_get_shell_config("error_color");
-    uint64_t default_color = sys_get_shell_config("default_text_color");
-
-    char path[256];
-    if (argc > 1) {
-        strcpy(path, argv[1]);
-    } else {
-        if (!sys_getcwd(path, sizeof(path))) {
-            strcpy(path, "/");
-        }
-    }
-    
-    FAT32_FileInfo info;
-    if (sys_get_file_info(path, &info) < 0) {
-        sys_set_text_color(error_color);
-        printf("Error: Path '%s' does not exist\n", path);
-        sys_set_text_color(default_color);
-        return 1;
-    }
-
-    if (!info.is_directory) {
-        sys_set_text_color(file_color);
-        printf("[FILE] %s", info.name);
-        sys_set_text_color(size_color);
-        printf(" (%d bytes)\n", info.size);
-        sys_set_text_color(default_color);
-        printf("\nTotal: 1 items\n");
-        return 0;
-    }
-    
-    FAT32_FileInfo entries[128];
-    int count = sys_list(path, entries, 128);
-    
-    if (count < 0) {
-        sys_set_text_color(error_color);
-        printf("Error: Cannot list directory %s\n", path);
-        sys_set_text_color(default_color);
-        return 1;
-    }
-    
-    for (int i = 0; i < count; i++) {
-        if (entries[i].is_directory) {
-            sys_set_text_color(dir_color);
-            printf("[DIR]  %s\n", entries[i].name);
-        } else {
-            sys_set_text_color(file_color);
-            printf("[FILE] %s", entries[i].name);
-            sys_set_text_color(size_color);
-            printf(" (%d bytes)\n", entries[i].size);
-        }
-    }
-    
-    sys_set_text_color(default_color);
-    printf("\nTotal: %d items\n", count);
-    return 0;
-}
diff --git a/src/userland/cli/mkdir.c b/src/userland/cli/mkdir.c
deleted file mode 100644
index 592d7fb..0000000
--- a/src/userland/cli/mkdir.c
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright (c) 2023-2026 Chris (boreddevnl)
-// This software is released under the GNU General Public License v3.0. See LICENSE file for details.
-// This header needs to maintain in any file it is present in, as per the GPL license terms.
-#include <stdlib.h>
-#include <syscall.h>
-
-int main(int argc, char **argv) {
-    uint32_t error_color = (uint32_t)sys_get_shell_config("error_color");
-    uint32_t success_color = (uint32_t)sys_get_shell_config("success_color");
-    uint32_t default_color = (uint32_t)sys_get_shell_config("default_text_color");
-
-    if (argc < 2) {
-        printf("Usage: mkdir <dirname>\n");
-        return 1;
-    }
-    
-    if (sys_mkdir(argv[1]) == 0) {
-        sys_set_text_color(success_color);
-        printf("Created directory: %s\n", argv[1]);
-    } else {
-        sys_set_text_color(error_color);
-        printf("Error: Cannot create directory %s\n", argv[1]);
-        sys_set_text_color(default_color);
-        return 1;
-    }
-    sys_set_text_color(default_color);
-    return 0;
-}
diff --git a/src/userland/cli/mv.c b/src/userland/cli/mv.c
deleted file mode 100644
index a6d3c41..0000000
--- a/src/userland/cli/mv.c
+++ /dev/null
@@ -1,128 +0,0 @@
-// Copyright (c) 2023-2026 Chris (boreddevnl)
-// This software is released under the GNU General Public License v3.0. See LICENSE file for details.
-// This header needs to maintain in any file it is present in, as per the GPL license terms.
-#include <stdlib.h>
-#include <syscall.h>
-
-void combine_path(char *dest, const char *path1, const char *path2) {
-    int i = 0;
-    while (path1[i]) {
-        dest[i] = path1[i];
-        i++;
-    }
-    if (i > 0 && dest[i-1] != '/') {
-        dest[i++] = '/';
-    }
-    int j = 0;
-    while (path2[j]) {
-        dest[i++] = path2[j++];
-    }
-    dest[i] = 0;
-}
-
-const char* get_basename(const char *path) {
-    const char *last_slash = NULL;
-    int len = 0;
-    while (path[len]) {
-        if (path[len] == '/') last_slash = path + len;
-        len++;
-    }
-    
-    if (!last_slash) return path;
-    
-    if (last_slash[1] == '\0') {
-        if (len <= 1) return path;
-        int i = len - 2;
-        while (i >= 0 && path[i] != '/') i--;
-        if (i < 0) return path; 
-        return path + i + 1;
-    }
-    
-    return last_slash + 1;
-}
-
-void copy_recursive(const char *src, const char *dst) {
-    FAT32_FileInfo info;
-    if (sys_get_file_info(src, &info) < 0) return;
-
-    if (info.is_directory) {
-        sys_mkdir(dst);
-        FAT32_FileInfo entries[64];
-        int count = sys_list(src, entries, 64);
-        for (int i = 0; i < count; i++) {
-            if (strcmp(entries[i].name, ".") == 0 || strcmp(entries[i].name, "..") == 0) continue;
-            char sub_src[512], sub_dst[512];
-            combine_path(sub_src, src, entries[i].name);
-            combine_path(sub_dst, dst, entries[i].name);
-            copy_recursive(sub_src, sub_dst);
-        }
-    } else {
-        int fd_in = sys_open(src, "r");
-        if (fd_in < 0) return;
-        int fd_out = sys_open(dst, "w");
-        if (fd_out < 0) { sys_close(fd_in); return; }
-        char buffer[4096];
-        int bytes;
-        while ((bytes = sys_read(fd_in, buffer, sizeof(buffer))) > 0) {
-            sys_write_fs(fd_out, buffer, bytes);
-        }
-        sys_close(fd_in);
-        sys_close(fd_out);
-    }
-}
-
-void delete_recursive(const char *path) {
-    FAT32_FileInfo info;
-    if (sys_get_file_info(path, &info) < 0) return;
-
-    if (info.is_directory) {
-        FAT32_FileInfo entries[64];
-        int count = sys_list(path, entries, 64);
-        for (int i = 0; i < count; i++) {
-            if (strcmp(entries[i].name, ".") == 0 || strcmp(entries[i].name, "..") == 0) continue;
-            char sub_path[512];
-            combine_path(sub_path, path, entries[i].name);
-            delete_recursive(sub_path);
-        }
-        sys_delete(path);
-    } else {
-        sys_delete(path);
-    }
-}
-
-int main(int argc, char **argv) {
-    if (argc < 3) {
-        printf("Usage: mv <source> <dest>\n");
-        return 1;
-    }
-    
-    char *src_path = argv[1];
-    char *dst_path = argv[2];
-
-    FAT32_FileInfo info_src;
-    if (sys_get_file_info(src_path, &info_src) < 0) {
-        printf("Error: Cannot open source %s\n", src_path);
-        return 1;
-    }
-
-    char actual_dst[512];
-    FAT32_FileInfo info_dst;
-    if (sys_get_file_info(dst_path, &info_dst) == 0 && info_dst.is_directory) {
-        const char *base = get_basename(src_path);
-        char clean_base[256];
-        int k = 0;
-        while (base[k] && base[k] != '/') {
-            clean_base[k] = base[k];
-            k++;
-        }
-        clean_base[k] = 0;
-        combine_path(actual_dst, dst_path, clean_base);
-    } else {
-        strcpy(actual_dst, dst_path);
-    }
-
-    copy_recursive(src_path, actual_dst);
-    delete_recursive(src_path);
-    
-    return 0;
-}
diff --git a/src/userland/cli/rm.c b/src/userland/cli/rm.c
deleted file mode 100644
index a8fa250..0000000
--- a/src/userland/cli/rm.c
+++ /dev/null
@@ -1,29 +0,0 @@
-// Copyright (c) 2023-2026 Chris (boreddevnl)
-// This software is released under the GNU General Public License v3.0. See LICENSE file for details.
-// This header needs to maintain in any file it is present in, as per the GPL license terms.
-#include <stdlib.h>
-#include <syscall.h>
-
-int main(int argc, char **argv) {
-    uint32_t error_color = (uint32_t)sys_get_shell_config("error_color");
-    uint32_t success_color = (uint32_t)sys_get_shell_config("success_color");
-    uint32_t default_color = (uint32_t)sys_get_shell_config("default_text_color");
-
-    if (argc < 2) {
-        printf("Usage: rm <path>\n");
-        return 1;
-    }
-    
-    // Simple rm (no recursive support yet for simplicity, but can be added)
-    if (sys_delete(argv[1]) == 0) {
-        sys_set_text_color(success_color);
-        printf("Deleted: %s\n", argv[1]);
-    } else {
-        sys_set_text_color(error_color);
-        printf("Error: Cannot delete %s\n", argv[1]);
-        sys_set_text_color(default_color);
-        return 1;
-    }
-    sys_set_text_color(default_color);
-    return 0;
-}
diff --git a/src/userland/cli/touch.c b/src/userland/cli/touch.c
deleted file mode 100644
index 013092b..0000000
--- a/src/userland/cli/touch.c
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright (c) 2023-2026 Chris (boreddevnl)
-// This software is released under the GNU General Public License v3.0. See LICENSE file for details.
-// This header needs to maintain in any file it is present in, as per the GPL license terms.
-#include <stdlib.h>
-#include <syscall.h>
-
-int main(int argc, char **argv) {
-    if (argc < 2) {
-        printf("Usage: touch <filename>\n");
-        return 1;
-    }
-    
-    // Check if file already exists
-    if (sys_exists(argv[1])) {
-        // Just return success if it exists (simplification)
-        return 0;
-    }
-    
-    int fd = sys_open(argv[1], "w");
-    if (fd < 0) {
-        printf("Error: Cannot create %s\n", argv[1]);
-        return 1;
-    }
-    
-    sys_close(fd);
-    return 0;
-}
diff --git a/src/userland/gui/terminal.c b/src/userland/gui/terminal.c
new file mode 100644
index 0000000..928565c
--- /dev/null
+++ b/src/userland/gui/terminal.c
@@ -0,0 +1,893 @@
+// Copyright (c) 2023-2026 Chris (boreddevnl)
+// This software is released under the GNU General Public License v3.0. See LICENSE file for details.
+// This header needs to maintain in any file it is present in, as per the GPL license terms.
+#include <stdlib.h>
+#include <syscall.h>
+#include "libc/libui.h"
+#include <stdbool.h>
+#include <stdint.h>
+
+#define DEFAULT_COLS 116
+#define DEFAULT_ROWS 41
+#define SCROLLBACK_LINES 800
+#define SCROLLBACK_COLS 256
+#define CHAR_W 8
+#define DEFAULT_LINE_H 10
+#define TAB_BAR_H 20
+#define CONTENT_PAD_BOTTOM 20
+#define TAB_CLOSE_W 12
+#define TAB_CLOSE_PAD 6
+#define MAX_TABS 4
+#define TTY_READ_CHUNK 512
+
+typedef struct {
+    char c;
+    uint32_t color;
+} CharCell;
+
+typedef struct {
+    int tty_id;
+    int bsh_pid;
+    CharCell *cells;
+    CharCell *scrollback;
+    int *scroll_cols;
+    int scroll_head;
+    int scroll_count;
+    int scroll_offset;
+    int cursor_row;
+    int cursor_col;
+    uint32_t fg_color;
+    uint32_t bg_color;
+
+    int ansi_state;
+    int ansi_params[8];
+    int ansi_param_count;
+    int saved_row;
+    int saved_col;
+} TerminalSession;
+
+static ui_window_t g_win;
+static TerminalSession g_tabs[MAX_TABS];
+static int g_tab_count = 0;
+static int g_active_tab = 0;
+static int g_cols = DEFAULT_COLS;
+static int g_rows = DEFAULT_ROWS;
+static int g_line_h = DEFAULT_LINE_H;
+static int g_win_w = DEFAULT_COLS * CHAR_W;
+static int g_win_h = TAB_BAR_H + (DEFAULT_ROWS * DEFAULT_LINE_H);
+
+static void str_copy(char *dst, const char *src, int max_len) {
+    int i = 0;
+    if (max_len <= 0) return;
+    while (i < max_len - 1 && src && src[i]) {
+        dst[i] = src[i];
+        i++;
+    }
+    dst[i] = 0;
+}
+
+static void str_append(char *dst, const char *src, int max_len) {
+    if (!dst || !src || max_len <= 0) return;
+    int dlen = (int)strlen(dst);
+    int i = 0;
+    while (dlen + i < max_len - 1 && src[i]) {
+        dst[dlen + i] = src[i];
+        i++;
+    }
+    dst[dlen + i] = 0;
+}
+
+static void trim_end(char *s) {
+    if (!s) return;
+    int len = (int)strlen(s);
+    while (len > 0 && (s[len - 1] == '\n' || s[len - 1] == '\r' || s[len - 1] == ' ' || s[len - 1] == '\t')) {
+        s[len - 1] = 0;
+        len--;
+    }
+}
+
+static void scrollback_init(TerminalSession *s) {
+    s->scroll_head = 0;
+    s->scroll_count = 0;
+    s->scroll_offset = 0;
+    if (s->scrollback) {
+        for (int i = 0; i < SCROLLBACK_LINES * SCROLLBACK_COLS; i++) {
+            s->scrollback[i].c = ' ';
+            s->scrollback[i].color = s->fg_color;
+        }
+    }
+    if (s->scroll_cols) {
+        for (int i = 0; i < SCROLLBACK_LINES; i++) s->scroll_cols[i] = 0;
+    }
+}
+
+static void scrollback_push_row(TerminalSession *s, const CharCell *row, int cols) {
+    if (!s->scrollback || !s->scroll_cols) return;
+    int idx = s->scroll_head;
+    CharCell *dest = s->scrollback + (idx * SCROLLBACK_COLS);
+    int copy_cols = cols;
+    if (copy_cols > SCROLLBACK_COLS) copy_cols = SCROLLBACK_COLS;
+
+    for (int i = 0; i < SCROLLBACK_COLS; i++) {
+        dest[i].c = ' ';
+        dest[i].color = s->fg_color;
+    }
+    for (int i = 0; i < copy_cols; i++) {
+        dest[i] = row[i];
+    }
+
+    s->scroll_cols[idx] = copy_cols;
+    s->scroll_head = (idx + 1) % SCROLLBACK_LINES;
+    if (s->scroll_count < SCROLLBACK_LINES) {
+        s->scroll_count++;
+    } else if (s->scroll_offset > 0) {
+        s->scroll_offset--;
+    }
+
+    if (s->scroll_offset > 0) {
+        s->scroll_offset++;
+    }
+}
+
+static int scrollback_max_offset(TerminalSession *s) {
+    int total = s->scroll_count + g_rows;
+    if (total <= g_rows) return 0;
+    return total - g_rows;
+}
+
+static void session_adjust_scroll(TerminalSession *s, int delta) {
+    if (!s) return;
+    int max_offset = scrollback_max_offset(s);
+    s->scroll_offset += delta;
+    if (s->scroll_offset < 0) s->scroll_offset = 0;
+    if (s->scroll_offset > max_offset) s->scroll_offset = max_offset;
+}
+
+static CharCell *scrollback_get_line(TerminalSession *s, int line_index, int *out_cols) {
+    if (!s || line_index < 0 || line_index >= s->scroll_count) return NULL;
+    int start = s->scroll_head - s->scroll_count;
+    if (start < 0) start += SCROLLBACK_LINES;
+    int idx = (start + line_index) % SCROLLBACK_LINES;
+    if (out_cols) *out_cols = s->scroll_cols[idx];
+    return s->scrollback + (idx * SCROLLBACK_COLS);
+}
+
+static uint32_t ansi_color_16(int idx) {
+    static uint32_t base[16] = {
+        0xFF000000, 0xFFAA0000, 0xFF00AA00, 0xFFAA5500,
+        0xFF0000AA, 0xFFAA00AA, 0xFF00AAAA, 0xFFAAAAAA,
+        0xFF555555, 0xFFFF5555, 0xFF55FF55, 0xFFFFFF55,
+        0xFF5555FF, 0xFFFF55FF, 0xFF55FFFF, 0xFFFFFFFF
+    };
+    if (idx < 0) idx = 0;
+    if (idx > 15) idx = 15;
+    return base[idx];
+}
+
+static void session_reset_colors(TerminalSession *s) {
+    s->fg_color = 0xFFFFFFFF;
+    s->bg_color = 0xFF1E1E1E;
+}
+
+static void session_clear(TerminalSession *s) {
+    for (int i = 0; i < g_cols * g_rows; i++) {
+        s->cells[i].c = ' ';
+        s->cells[i].color = s->fg_color;
+    }
+    s->cursor_row = 0;
+    s->cursor_col = 0;
+    s->scroll_offset = 0;
+}
+
+static void session_scroll(TerminalSession *s) {
+    int row_bytes = g_cols * (int)sizeof(CharCell);
+    if (g_rows > 0) {
+        scrollback_push_row(s, s->cells, g_cols);
+    }
+    memmove(s->cells, s->cells + g_cols, row_bytes * (g_rows - 1));
+    for (int i = 0; i < g_cols; i++) {
+        int idx = (g_rows - 1) * g_cols + i;
+        s->cells[idx].c = ' ';
+        s->cells[idx].color = s->fg_color;
+    }
+    s->cursor_row = g_rows - 1;
+    s->cursor_col = 0;
+}
+
+static void session_put_char(TerminalSession *s, char c) {
+    if (c == '\n') {
+        s->cursor_row++;
+        s->cursor_col = 0;
+        if (s->cursor_row >= g_rows) session_scroll(s);
+        return;
+    }
+    if (c == '\r') {
+        s->cursor_col = 0;
+        return;
+    }
+    if (c == '\b') {
+        if (s->cursor_col > 0) s->cursor_col--;
+        int idx = s->cursor_row * g_cols + s->cursor_col;
+        if (idx >= 0 && idx < g_cols * g_rows) {
+            s->cells[idx].c = ' ';
+            s->cells[idx].color = s->fg_color;
+        }
+        return;
+    }
+    if (c == '\t') {
+        int next = ((s->cursor_col / 4) + 1) * 4;
+        while (s->cursor_col < next) {
+            session_put_char(s, ' ');
+        }
+        return;
+    }
+
+    if (c < 32) return;
+
+    int idx = s->cursor_row * g_cols + s->cursor_col;
+    if (idx >= 0 && idx < g_cols * g_rows) {
+        s->cells[idx].c = c;
+        s->cells[idx].color = s->fg_color;
+    }
+    s->cursor_col++;
+    if (s->cursor_col >= g_cols) {
+        s->cursor_col = 0;
+        s->cursor_row++;
+        if (s->cursor_row >= g_rows) session_scroll(s);
+    }
+}
+
+static void ansi_handle_sgr(TerminalSession *s) {
+    if (s->ansi_param_count == 0) {
+        session_reset_colors(s);
+        return;
+    }
+    for (int i = 0; i < s->ansi_param_count; i++) {
+        int p = s->ansi_params[i];
+        if (p == 0) session_reset_colors(s);
+        else if (p >= 30 && p <= 37) s->fg_color = ansi_color_16(p - 30);
+        else if (p >= 90 && p <= 97) s->fg_color = ansi_color_16(8 + (p - 90));
+        else if (p >= 40 && p <= 47) s->bg_color = ansi_color_16(p - 40);
+        else if (p >= 100 && p <= 107) s->bg_color = ansi_color_16(8 + (p - 100));
+        else if (p == 38 || p == 48) {
+            if (i + 4 < s->ansi_param_count && s->ansi_params[i + 1] == 2) {
+                int r = s->ansi_params[i + 2] & 0xFF;
+                int g = s->ansi_params[i + 3] & 0xFF;
+                int b = s->ansi_params[i + 4] & 0xFF;
+                uint32_t color = 0xFF000000 | ((uint32_t)r << 16) | ((uint32_t)g << 8) | (uint32_t)b;
+                if (p == 38) s->fg_color = color;
+                else s->bg_color = color;
+                i += 4;
+            }
+        }
+    }
+}
+
+static void ansi_finalize(TerminalSession *s, char cmd) {
+    if (cmd == 'm') {
+        ansi_handle_sgr(s);
+    } else if (cmd == 'J') {
+        int mode = s->ansi_param_count > 0 ? s->ansi_params[0] : 0;
+        if (mode == 2 || mode == 0) session_clear(s);
+    } else if (cmd == 'K') {
+        int row = s->cursor_row;
+        for (int col = s->cursor_col; col < g_cols; col++) {
+            int idx = row * g_cols + col;
+            s->cells[idx].c = ' ';
+            s->cells[idx].color = s->fg_color;
+        }
+    } else if (cmd == 'H' || cmd == 'f') {
+        int row = (s->ansi_param_count > 0) ? s->ansi_params[0] : 1;
+        int col = (s->ansi_param_count > 1) ? s->ansi_params[1] : 1;
+        if (row < 1) row = 1;
+        if (col < 1) col = 1;
+        s->cursor_row = row - 1;
+        s->cursor_col = col - 1;
+    } else if (cmd == 'A') {
+        int n = (s->ansi_param_count > 0) ? s->ansi_params[0] : 1;
+        s->cursor_row -= n;
+        if (s->cursor_row < 0) s->cursor_row = 0;
+    } else if (cmd == 'B') {
+        int n = (s->ansi_param_count > 0) ? s->ansi_params[0] : 1;
+        s->cursor_row += n;
+        if (s->cursor_row >= g_rows) s->cursor_row = g_rows - 1;
+    } else if (cmd == 'C') {
+        int n = (s->ansi_param_count > 0) ? s->ansi_params[0] : 1;
+        s->cursor_col += n;
+        if (s->cursor_col >= g_cols) s->cursor_col = g_cols - 1;
+    } else if (cmd == 'D') {
+        int n = (s->ansi_param_count > 0) ? s->ansi_params[0] : 1;
+        s->cursor_col -= n;
+        if (s->cursor_col < 0) s->cursor_col = 0;
+    } else if (cmd == 's') {
+        s->saved_row = s->cursor_row;
+        s->saved_col = s->cursor_col;
+    } else if (cmd == 'u') {
+        s->cursor_row = s->saved_row;
+        s->cursor_col = s->saved_col;
+    }
+
+    s->ansi_state = 0;
+    s->ansi_param_count = 0;
+}
+
+static void session_process_char(TerminalSession *s, char c) {
+    if (s->ansi_state == 0) {
+        if (c == 27) {
+            s->ansi_state = 1;
+            s->ansi_param_count = 0;
+            s->ansi_params[0] = 0;
+            return;
+        }
+        session_put_char(s, c);
+        return;
+    }
+
+    if (s->ansi_state == 1) {
+        if (c == '[') {
+            s->ansi_state = 2;
+            s->ansi_param_count = 0;
+            s->ansi_params[0] = 0;
+            return;
+        }
+        s->ansi_state = 0;
+        session_put_char(s, c);
+        return;
+    }
+
+    if (s->ansi_state == 2) {
+        if (c >= '0' && c <= '9') {
+            int idx = s->ansi_param_count;
+            s->ansi_params[idx] = s->ansi_params[idx] * 10 + (c - '0');
+            return;
+        }
+        if (c == ';') {
+            if (s->ansi_param_count < 7) {
+                s->ansi_param_count++;
+                s->ansi_params[s->ansi_param_count] = 0;
+            }
+            return;
+        }
+        s->ansi_param_count++;
+        ansi_finalize(s, c);
+        return;
+    }
+}
+
+static void session_process_output(TerminalSession *s, const char *buf, int len) {
+    for (int i = 0; i < len; i++) {
+        session_process_char(s, buf[i]);
+    }
+}
+
+static int get_tab_width(void) {
+    if (g_tab_count <= 0) return g_win_w;
+    int tab_w = g_win_w / g_tab_count;
+    if (tab_w < 60) tab_w = 60;
+    return tab_w;
+}
+
+static int read_proc_field(int pid, const char *field, char *out, int max_len) {
+    if (!out || max_len <= 0) return -1;
+    char path[64];
+    path[0] = 0;
+    str_append(path, "/proc/", sizeof(path));
+    char pid_buf[16];
+    itoa(pid, pid_buf);
+    str_append(path, pid_buf, sizeof(path));
+    str_append(path, "/", sizeof(path));
+    str_append(path, field, sizeof(path));
+
+    int fd = sys_open(path, "r");
+    if (fd < 0) return -1;
+    int bytes = sys_read(fd, out, max_len - 1);
+    sys_close(fd);
+    if (bytes <= 0) return -1;
+    out[bytes] = 0;
+    trim_end(out);
+    return 0;
+}
+
+static void truncate_label(const char *src, char *out, int max_chars) {
+    if (!out || max_chars <= 0) return;
+    int len = (int)strlen(src);
+    if (len <= max_chars) {
+        str_copy(out, src, max_chars + 1);
+        return;
+    }
+    if (max_chars <= 3) {
+        for (int i = 0; i < max_chars; i++) out[i] = src[i];
+        out[max_chars] = 0;
+        return;
+    }
+    for (int i = 0; i < max_chars - 3; i++) out[i] = src[i];
+    out[max_chars - 3] = '.';
+    out[max_chars - 2] = '.';
+    out[max_chars - 1] = '.';
+    out[max_chars] = 0;
+}
+
+static void get_tab_title(TerminalSession *s, char *out, int max_len) {
+    if (!s || !out) return;
+    int fg = sys_tty_get_fg(s->tty_id);
+    if (fg > 0) {
+        if (read_proc_field(fg, "name", out, max_len) == 0) return;
+    }
+    if (s->bsh_pid > 0) {
+        if (read_proc_field(s->bsh_pid, "cwd", out, max_len) == 0) return;
+    }
+    str_copy(out, "Bsh", max_len);
+}
+
+static int read_config_value(const char *key, char *out, int max_len) {
+    if (!key || !out || max_len <= 0) return -1;
+    int fd = sys_open("/Library/bsh/bshrc", "r");
+    if (fd < 0) return -1;
+
+    char buf[4096];
+    int bytes = sys_read(fd, buf, sizeof(buf) - 1);
+    sys_close(fd);
+    if (bytes <= 0) return -1;
+    buf[bytes] = 0;
+
+    char *line = buf;
+    while (*line) {
+        char *end = line;
+        while (*end && *end != '\n' && *end != '\r') end++;
+        char saved = *end;
+        *end = 0;
+
+        trim_end(line);
+        if (line[0] != '#' && line[0] != 0) {
+            char *sep = line;
+            while (*sep && *sep != '=') sep++;
+            if (*sep == '=') {
+                *sep = 0;
+                if (strcmp(line, key) == 0) {
+                    str_copy(out, sep + 1, max_len);
+                    return 0;
+                }
+            }
+        }
+
+        line = end + (saved ? 1 : 0);
+        if (saved == '\r' && *line == '\n') line++;
+    }
+
+    return -1;
+}
+
+static void resolve_bsh_path(char *out, int max_len) {
+    char path_line[256];
+    if (read_config_value("PATH", path_line, sizeof(path_line)) != 0) {
+        str_copy(path_line, "/bin", sizeof(path_line));
+    }
+
+    int i = 0;
+    int start = 0;
+    while (1) {
+        if (path_line[i] == ':' || path_line[i] == 0) {
+            int len = i - start;
+            if (len > 0) {
+                char base[128];
+                if (len >= (int)sizeof(base)) len = (int)sizeof(base) - 1;
+                for (int j = 0; j < len; j++) base[j] = path_line[start + j];
+                base[len] = 0;
+
+                char candidate[160];
+                candidate[0] = 0;
+                str_append(candidate, base, sizeof(candidate));
+                if (candidate[0] && candidate[strlen(candidate) - 1] != '/') str_append(candidate, "/", sizeof(candidate));
+                str_append(candidate, "bsh.elf", sizeof(candidate));
+                if (sys_exists(candidate)) {
+                    str_copy(out, candidate, max_len);
+                    return;
+                }
+
+                candidate[0] = 0;
+                str_append(candidate, base, sizeof(candidate));
+                if (candidate[0] && candidate[strlen(candidate) - 1] != '/') str_append(candidate, "/", sizeof(candidate));
+                str_append(candidate, "bsh", sizeof(candidate));
+                if (sys_exists(candidate)) {
+                    str_copy(out, candidate, max_len);
+                    return;
+                }
+            }
+            start = i + 1;
+        }
+        if (path_line[i] == 0) break;
+        i++;
+    }
+
+    str_copy(out, "/bin/bsh.elf", max_len);
+}
+
+static bool has_space(const char *s) {
+    if (!s) return false;
+    while (*s) {
+        if (*s == ' ') return true;
+        s++;
+    }
+    return false;
+}
+
+static void terminal_resize(int w, int h) {
+    int min_w = CHAR_W * 40;
+    int min_h = TAB_BAR_H + (g_line_h * 10);
+    if (w < min_w) w = min_w;
+    if (h < min_h) h = min_h;
+
+    g_win_w = w;
+    g_win_h = h;
+
+    int new_cols = w / CHAR_W;
+    int content_h = h - TAB_BAR_H - CONTENT_PAD_BOTTOM;
+    if (g_line_h <= 0) g_line_h = DEFAULT_LINE_H;
+    if (content_h < g_line_h) content_h = g_line_h;
+    int new_rows = content_h / g_line_h;
+    if (new_cols < 10) new_cols = 10;
+    if (new_rows < 5) new_rows = 5;
+
+    if (new_cols == g_cols && new_rows == g_rows) return;
+
+    int old_cols = g_cols;
+    int old_rows = g_rows;
+    g_cols = new_cols;
+    g_rows = new_rows;
+
+    for (int i = 0; i < g_tab_count; i++) {
+        TerminalSession *s = &g_tabs[i];
+        int old_scroll_count = s->scroll_count;
+        int old_scroll_offset = s->scroll_offset;
+        int old_total_lines = old_scroll_count + old_rows;
+        int old_bottom_line = old_total_lines - 1 - old_scroll_offset;
+        int old_top_line = old_bottom_line - (old_rows - 1);
+        CharCell *old_cells = s->cells;
+        int old_cursor_row = s->cursor_row;
+        int old_cursor_col = s->cursor_col;
+
+        s->cells = (CharCell *)malloc(sizeof(CharCell) * g_cols * g_rows);
+        for (int j = 0; j < g_cols * g_rows; j++) {
+            s->cells[j].c = ' ';
+            s->cells[j].color = s->fg_color;
+        }
+
+        int row_start = 0;
+        if (old_rows > g_rows) {
+            if (old_cursor_row >= g_rows) {
+                row_start = old_cursor_row - (g_rows - 1);
+            } else {
+                row_start = 0;
+            }
+            int max_start = old_rows - g_rows;
+            if (row_start > max_start) row_start = max_start;
+            if (row_start < 0) row_start = 0;
+        }
+        int dropped = 0;
+        if (row_start > 0) {
+            int projected = old_scroll_count + row_start;
+            if (projected > SCROLLBACK_LINES) dropped = projected - SCROLLBACK_LINES;
+        }
+        int desired_top_line = old_top_line - dropped;
+        if (desired_top_line < 0) desired_top_line = 0;
+        for (int r = 0; r < row_start; r++) {
+            scrollback_push_row(s, old_cells + (r * old_cols), old_cols);
+        }
+
+        int copy_rows = old_rows;
+        if (copy_rows > g_rows) copy_rows = g_rows;
+        int copy_cols = old_cols < g_cols ? old_cols : g_cols;
+        for (int r = 0; r < copy_rows; r++) {
+            CharCell *src = old_cells + ((row_start + r) * old_cols);
+            CharCell *dst = s->cells + (r * g_cols);
+            for (int c = 0; c < copy_cols; c++) {
+                dst[c] = src[c];
+            }
+        }
+
+        s->cursor_row = old_cursor_row - row_start;
+        if (old_rows <= g_rows) s->cursor_row = old_cursor_row;
+        if (s->cursor_row < 0) s->cursor_row = 0;
+        if (s->cursor_row >= g_rows) s->cursor_row = g_rows - 1;
+
+        s->cursor_col = old_cursor_col;
+        if (s->cursor_col < 0) s->cursor_col = 0;
+        if (s->cursor_col >= g_cols) s->cursor_col = g_cols - 1;
+
+        if (old_scroll_offset == 0) {
+            s->scroll_offset = 0;
+        } else {
+            int new_total_lines = s->scroll_count + g_rows;
+            int desired_bottom = desired_top_line + (g_rows - 1);
+            s->scroll_offset = (new_total_lines - 1) - desired_bottom;
+        }
+        session_adjust_scroll(s, 0);
+
+        if (old_cells) free(old_cells);
+    }
+}
+
+static void draw_tabs(void) {
+    if (g_tab_count <= 0) return;
+    ui_draw_rect(g_win, 0, 0, g_win_w, TAB_BAR_H, 0xFF1A1A1A);
+    int tab_w = get_tab_width();
+    for (int i = 0; i < g_tab_count; i++) {
+        int x = i * tab_w;
+        uint32_t bg = (i == g_active_tab) ? 0xFF333333 : 0xFF222222;
+        ui_draw_rect(g_win, x, 0, tab_w - 2, TAB_BAR_H, bg);
+        int close_size = TAB_CLOSE_W;
+        int close_x = x + tab_w - TAB_CLOSE_PAD - close_size;
+        int close_y = (TAB_BAR_H - close_size) / 2;
+        uint32_t close_bg = (i == g_active_tab) ? 0xFF444444 : 0xFF333333;
+        ui_draw_rect(g_win, close_x, close_y, close_size, close_size, close_bg);
+        ui_draw_string(g_win, close_x + 2, close_y + 1, "x", 0xFFFFFFFF);
+        char title[64];
+        char label[64];
+        get_tab_title(&g_tabs[i], title, sizeof(title));
+        int text_w = tab_w - 10 - (TAB_CLOSE_PAD + TAB_CLOSE_W);
+        int max_chars = text_w / CHAR_W;
+        if (max_chars < 4) max_chars = 4;
+        truncate_label(title, label, max_chars);
+        ui_draw_string(g_win, x + 6, 4, label, 0xFFFFFFFF);
+    }
+}
+
+static void draw_session(TerminalSession *s) {
+    int base_y = TAB_BAR_H;
+    ui_draw_rect(g_win, 0, base_y, g_win_w, g_win_h - base_y, s->bg_color);
+
+    int max_offset = scrollback_max_offset(s);
+    if (s->scroll_offset > max_offset) s->scroll_offset = max_offset;
+    int total_lines = s->scroll_count + g_rows;
+    int bottom_line = total_lines - 1 - s->scroll_offset;
+    int top_line = bottom_line - (g_rows - 1);
+
+    for (int row = 0; row < g_rows; row++) {
+        int line_index = top_line + row;
+        CharCell *line = NULL;
+        int line_cols = 0;
+        if (line_index >= 0 && line_index < s->scroll_count) {
+            line = scrollback_get_line(s, line_index, &line_cols);
+        } else if (line_index >= s->scroll_count && line_index < total_lines) {
+            int live_row = line_index - s->scroll_count;
+            if (live_row >= 0 && live_row < g_rows) {
+                line = s->cells + (live_row * g_cols);
+                line_cols = g_cols;
+            }
+        }
+        for (int col = 0; col < g_cols; col++) {
+            char ch = ' ';
+            uint32_t color = s->fg_color;
+            if (line && col < line_cols) {
+                ch = line[col].c;
+                if (ch == 0) ch = ' ';
+                color = line[col].color;
+            }
+            char str[2] = { ch, 0 };
+            int x = col * CHAR_W;
+            int y = base_y + row * g_line_h;
+            ui_draw_string_bitmap(g_win, x, y, str, color);
+        }
+    }
+
+    if (s->scroll_offset == 0) {
+        int cx = s->cursor_col * CHAR_W;
+        int cy = base_y + s->cursor_row * g_line_h;
+        ui_draw_rect(g_win, cx, cy + g_line_h - 2, CHAR_W, 2, 0xFFFFFFFF);
+    }
+
+    ui_mark_dirty(g_win, 0, 0, g_win_w, g_win_h);
+}
+
+static void tab_init(TerminalSession *s, int tty_id, int bsh_pid) {
+    s->tty_id = tty_id;
+    s->bsh_pid = bsh_pid;
+    s->cells = (CharCell *)malloc(sizeof(CharCell) * g_cols * g_rows);
+    s->scrollback = (CharCell *)malloc(sizeof(CharCell) * SCROLLBACK_LINES * SCROLLBACK_COLS);
+    s->scroll_cols = (int *)malloc(sizeof(int) * SCROLLBACK_LINES);
+    s->cursor_row = 0;
+    s->cursor_col = 0;
+    s->ansi_state = 0;
+    s->ansi_param_count = 0;
+    s->saved_row = 0;
+    s->saved_col = 0;
+    session_reset_colors(s);
+    scrollback_init(s);
+    session_clear(s);
+}
+
+static void tab_free(TerminalSession *s) {
+    if (!s) return;
+    if (s->cells) {
+        free(s->cells);
+        s->cells = NULL;
+    }
+    if (s->scrollback) {
+        free(s->scrollback);
+        s->scrollback = NULL;
+    }
+    if (s->scroll_cols) {
+        free(s->scroll_cols);
+        s->scroll_cols = NULL;
+    }
+}
+
+static void close_tab(int idx) {
+    if (idx < 0 || idx >= g_tab_count) return;
+    TerminalSession *s = &g_tabs[idx];
+
+    sys_tty_kill_all(s->tty_id);
+    sys_tty_destroy(s->tty_id);
+
+    tab_free(s);
+
+    for (int i = idx; i < g_tab_count - 1; i++) {
+        g_tabs[i] = g_tabs[i + 1];
+    }
+    g_tab_count--;
+    if (g_tab_count <= 0) {
+        sys_exit(0);
+    }
+    if (g_active_tab > idx) {
+        g_active_tab--;
+    } else if (g_active_tab == idx) {
+        if (g_active_tab >= g_tab_count) g_active_tab = g_tab_count - 1;
+    }
+}
+
+static int create_tab(void) {
+    if (g_tab_count >= MAX_TABS) return -1;
+
+    int tty_id = sys_tty_create();
+    if (tty_id < 0) return -1;
+
+    char start_dir[256];
+    start_dir[0] = 0;
+    if (g_tab_count > 0) {
+        TerminalSession *active = &g_tabs[g_active_tab];
+        if (active->bsh_pid > 0) {
+            read_proc_field(active->bsh_pid, "cwd", start_dir, sizeof(start_dir));
+        }
+    }
+
+    char args[32];
+    args[0] = 0;
+    str_append(args, "-t ", sizeof(args));
+    char id_buf[8];
+    itoa(tty_id, id_buf);
+    str_append(args, id_buf, sizeof(args));
+
+    if (start_dir[0]) {
+        str_append(args, " -d ", sizeof(args));
+        if (has_space(start_dir)) {
+            str_append(args, "\"", sizeof(args));
+            str_append(args, start_dir, sizeof(args));
+            str_append(args, "\"", sizeof(args));
+        } else {
+            str_append(args, start_dir, sizeof(args));
+        }
+    }
+
+    char bsh_path[128];
+    resolve_bsh_path(bsh_path, sizeof(bsh_path));
+    int pid = sys_spawn(bsh_path, args, SPAWN_FLAG_TERMINAL | SPAWN_FLAG_TTY_ID, tty_id);
+    if (pid < 0) return -1;
+
+    tab_init(&g_tabs[g_tab_count], tty_id, pid);
+    g_tab_count++;
+    return g_tab_count - 1;
+}
+
+static void handle_key(gui_event_t *ev) {
+    TerminalSession *s = &g_tabs[g_active_tab];
+    char c = (char)ev->arg1;
+    bool ctrl = ev->arg3 != 0;
+
+    if (ctrl && c == 't') {
+        int idx = create_tab();
+        if (idx >= 0) g_active_tab = idx;
+        return;
+    }
+
+    if (ctrl && c == 20) {
+        if (g_tab_count > 0) g_active_tab = (g_active_tab + 1) % g_tab_count;
+        return;
+    }
+
+    if (ctrl && c == 19) {
+        if (g_tab_count > 0) g_active_tab = (g_active_tab + g_tab_count - 1) % g_tab_count;
+        return;
+    }
+
+    if (ctrl && (c == 'c' || c == 'C')) {
+        int fg = sys_tty_get_fg(s->tty_id);
+        if (fg > 0) {
+            sys_tty_kill_fg(s->tty_id);
+            sys_tty_set_fg(s->tty_id, 0);
+            return;
+        }
+        char ch = 3;
+        sys_tty_write_in(s->tty_id, &ch, 1);
+        return;
+    }
+
+    sys_tty_write_in(s->tty_id, &c, 1);
+}
+
+int main(void) {
+    g_win = ui_window_create("Terminal", 60, 60, g_win_w, g_win_h);
+    ui_window_set_resizable(g_win, true);
+
+    int fh = (int)ui_get_font_height();
+    if (fh > 0) g_line_h = fh;
+    terminal_resize(g_win_w, g_win_h);
+
+    int idx = create_tab();
+    if (idx < 0) return 1;
+    g_active_tab = idx;
+
+    gui_event_t ev;
+    char out_buf[TTY_READ_CHUNK];
+
+    while (1) {
+        bool dirty = false;
+
+        for (int i = 0; i < g_tab_count; i++) {
+            TerminalSession *s = &g_tabs[i];
+            int read = 0;
+            while ((read = sys_tty_read_out(s->tty_id, out_buf, sizeof(out_buf))) > 0) {
+                session_process_output(s, out_buf, read);
+                if (i == g_active_tab) dirty = true;
+            }
+        }
+
+        while (ui_get_event(g_win, &ev)) {
+            if (ev.type == GUI_EVENT_CLOSE) {
+                for (int i = 0; i < g_tab_count; i++) {
+                    if (g_tabs[i].bsh_pid > 0) sys_kill(g_tabs[i].bsh_pid);
+                }
+                sys_exit(0);
+            } else if (ev.type == GUI_EVENT_KEY) {
+                handle_key(&ev);
+                dirty = true;
+            } else if (ev.type == GUI_EVENT_CLICK) {
+                if (ev.arg2 < TAB_BAR_H) {
+                    int tab_w = get_tab_width();
+                    int tab = ev.arg1 / tab_w;
+                    if (tab >= 0 && tab < g_tab_count) {
+                        int close_size = TAB_CLOSE_W;
+                        int close_x = tab * tab_w + tab_w - TAB_CLOSE_PAD - close_size;
+                        int close_y = (TAB_BAR_H - close_size) / 2;
+                        if (ev.arg1 >= close_x && ev.arg1 < close_x + close_size &&
+                            ev.arg2 >= close_y && ev.arg2 < close_y + close_size) {
+                            close_tab(tab);
+                        } else {
+                            g_active_tab = tab;
+                        }
+                        dirty = true;
+                    }
+                }
+            } else if (ev.type == GUI_EVENT_MOUSE_WHEEL) {
+                int lines = ev.arg1 * 3;
+                if (lines != 0) {
+                    session_adjust_scroll(&g_tabs[g_active_tab], lines);
+                    dirty = true;
+                }
+            } else if (ev.type == GUI_EVENT_RESIZE) {
+                terminal_resize(ev.arg1, ev.arg2);
+                dirty = true;
+            } else if (ev.type == GUI_EVENT_PAINT) {
+                dirty = true;
+            }
+        }
+
+        if (dirty) {
+            draw_tabs();
+            draw_session(&g_tabs[g_active_tab]);
+        } else {
+            sys_yield();
+        }
+    }
+
+    return 0;
+}
diff --git a/src/userland/gui/txtedit.c b/src/userland/gui/txtedit.c
index d6e103e..3aae7e0 100644
--- a/src/userland/gui/txtedit.c
+++ b/src/userland/gui/txtedit.c
@@ -40,6 +40,46 @@ static void editor_strcpy(char *dest, const char *src) {
     *dest = 0;
 }
 
+static int editor_strlen(const char *s) {
+    int len = 0;
+    while (s && s[len]) len++;
+    return len;
+}
+
+static void editor_strncat(char *dst, const char *src, int max_len) {
+    if (!dst || !src || max_len <= 0) return;
+    int dlen = editor_strlen(dst);
+    int i = 0;
+    while (dlen + i < max_len - 1 && src[i]) {
+        dst[dlen + i] = src[i];
+        i++;
+    }
+    dst[dlen + i] = 0;
+}
+
+static void editor_resolve_path(const char *input, char *out, int max_len) {
+    if (!out || max_len <= 0) return;
+    if (!input || input[0] == 0) {
+        out[0] = 0;
+        return;
+    }
+    if (input[0] == '/') {
+        editor_strcpy(out, input);
+        return;
+    }
+
+    char cwd[256];
+    if (sys_getcwd(cwd, sizeof(cwd)) < 0) {
+        editor_strcpy(out, input);
+        return;
+    }
+
+    editor_strcpy(out, cwd);
+    int len = editor_strlen(out);
+    if (len > 0 && out[len - 1] != '/') editor_strncat(out, "/", max_len);
+    editor_strncat(out, input, max_len);
+}
+
 static void editor_clear_all(void) {
     for (int i = 0; i < EDITOR_MAX_LINES; i++) {
         for (int j = 0; j < EDITOR_MAX_LINE_LEN; j++) {
@@ -71,9 +111,11 @@ static void editor_ensure_cursor_visible(void) {
 
 void editor_open_file(const char *filename) {
     editor_clear_all();
-    editor_strcpy(open_filename, filename);
+    char resolved[256];
+    editor_resolve_path(filename, resolved, sizeof(resolved));
+    editor_strcpy(open_filename, resolved);
     
-    int fd = sys_open(filename, "r");
+    int fd = sys_open(resolved, "r");
     if (fd < 0) {
         file_modified = 0;
         return;
diff --git a/src/userland/gui/viewer.c b/src/userland/gui/viewer.c
index e533fca..6feee80 100644
--- a/src/userland/gui/viewer.c
+++ b/src/userland/gui/viewer.c
@@ -41,6 +41,40 @@ static int viewer_strlen(const char *s) {
     return len;
 }
 
+static void viewer_strncat(char *dst, const char *src, int max_len) {
+    if (!dst || !src || max_len <= 0) return;
+    int dlen = viewer_strlen(dst);
+    int i = 0;
+    while (dlen + i < max_len - 1 && src[i]) {
+        dst[dlen + i] = src[i];
+        i++;
+    }
+    dst[dlen + i] = 0;
+}
+
+static void viewer_resolve_path(const char *input, char *out, int max_len) {
+    if (!out || max_len <= 0) return;
+    if (!input || input[0] == 0) {
+        out[0] = 0;
+        return;
+    }
+    if (input[0] == '/') {
+        viewer_strcpy(out, input);
+        return;
+    }
+
+    char cwd[256];
+    if (sys_getcwd(cwd, sizeof(cwd)) < 0) {
+        viewer_strcpy(out, input);
+        return;
+    }
+
+    viewer_strcpy(out, cwd);
+    int len = viewer_strlen(out);
+    if (len > 0 && out[len - 1] != '/') viewer_strncat(out, "/", max_len);
+    viewer_strncat(out, input, max_len);
+}
+
 static void viewer_scale_rgba_to_argb(const unsigned char *rgba, int src_w, int src_h,
                                       uint32_t *dst, int dst_w, int dst_h) {
     if (src_w == dst_w && src_h == dst_h) {
@@ -141,7 +175,9 @@ static void viewer_paint(ui_window_t win) {
 }
 
 void viewer_open_file(const char *path) {
-    int fd = sys_open(path, "r");
+    char resolved[256];
+    viewer_resolve_path(path, resolved, sizeof(resolved));
+    int fd = sys_open(resolved, "r");
     if (fd < 0) return;
 
     uint32_t file_size = sys_size(fd);
@@ -250,13 +286,13 @@ void viewer_open_file(const char *path) {
     stbi_image_free(rgba);
     free(buf);
 
-    viewer_strcpy(viewer_file_path, path);
+    viewer_strcpy(viewer_file_path, resolved);
 
-    const char *fname = path;
-    int plen = viewer_strlen(path);
+    const char *fname = resolved;
+    int plen = viewer_strlen(resolved);
     for (int i = plen - 1; i >= 0; i--) {
-        if (path[i] == '/') {
-            fname = &path[i + 1];
+        if (resolved[i] == '/') {
+            fname = &resolved[i + 1];
             break;
         }
     }
diff --git a/src/userland/libc/stdlib.c b/src/userland/libc/stdlib.c
index 1b52de7..2df15fb 100644
--- a/src/userland/libc/stdlib.c
+++ b/src/userland/libc/stdlib.c
@@ -329,7 +329,7 @@ int chdir(const char *path) {
 }
 
 char* getcwd(char *buf, int size) {
-    if (sys_getcwd(buf, size) == 0) return buf;
+    if (sys_getcwd(buf, size) >= 0) return buf;
     return NULL;
 }
 
diff --git a/src/userland/libc/syscall.c b/src/userland/libc/syscall.c
index 219eceb..5e433c3 100644
--- a/src/userland/libc/syscall.c
+++ b/src/userland/libc/syscall.c
@@ -145,6 +145,46 @@ int sys_chdir(const char *path) {
     return (int)syscall2(SYS_FS, FS_CMD_CHDIR, (uint64_t)path);
 }
 
+int sys_tty_create(void) {
+    return (int)syscall2(SYS_SYSTEM, SYSTEM_CMD_TTY_CREATE, 0);
+}
+
+int sys_tty_read_out(int tty_id, char *buf, int len) {
+    return (int)syscall5(SYS_SYSTEM, SYSTEM_CMD_TTY_READ_OUT, (uint64_t)tty_id, (uint64_t)buf, (uint64_t)len, 0);
+}
+
+int sys_tty_write_in(int tty_id, const char *buf, int len) {
+    return (int)syscall5(SYS_SYSTEM, SYSTEM_CMD_TTY_WRITE_IN, (uint64_t)tty_id, (uint64_t)buf, (uint64_t)len, 0);
+}
+
+int sys_tty_read_in(char *buf, int len) {
+    return (int)syscall4(SYS_SYSTEM, SYSTEM_CMD_TTY_READ_IN, (uint64_t)buf, (uint64_t)len, 0);
+}
+
+int sys_spawn(const char *path, const char *args, uint64_t flags, uint64_t tty_id) {
+    return (int)syscall5(SYS_SYSTEM, SYSTEM_CMD_SPAWN, (uint64_t)path, (uint64_t)args, flags, (uint64_t)tty_id);
+}
+
+int sys_tty_set_fg(int tty_id, int pid) {
+    return (int)syscall4(SYS_SYSTEM, SYSTEM_CMD_TTY_SET_FG, (uint64_t)tty_id, (uint64_t)pid, 0);
+}
+
+int sys_tty_get_fg(int tty_id) {
+    return (int)syscall3(SYS_SYSTEM, SYSTEM_CMD_TTY_GET_FG, (uint64_t)tty_id, 0);
+}
+
+int sys_tty_kill_fg(int tty_id) {
+    return (int)syscall3(SYS_SYSTEM, SYSTEM_CMD_TTY_KILL_FG, (uint64_t)tty_id, 0);
+}
+
+int sys_tty_kill_all(int tty_id) {
+    return (int)syscall3(SYS_SYSTEM, SYSTEM_CMD_TTY_KILL_ALL, (uint64_t)tty_id, 0);
+}
+
+int sys_tty_destroy(int tty_id) {
+    return (int)syscall3(SYS_SYSTEM, SYSTEM_CMD_TTY_DESTROY, (uint64_t)tty_id, 0);
+}
+
 void sys_kill(int pid) {
     syscall1(SYS_KILL, (uint64_t)pid);
 }
diff --git a/src/userland/libc/syscall.h b/src/userland/libc/syscall.h
index 8897483..f6f168a 100644
--- a/src/userland/libc/syscall.h
+++ b/src/userland/libc/syscall.h
@@ -72,6 +72,20 @@
 #define SYSTEM_CMD_TCP_RECV_NB 42
 #define SYSTEM_CMD_YIELD 43
 #define SYSTEM_CMD_PARALLEL_RUN 50
+#define SYSTEM_CMD_TTY_CREATE 60
+#define SYSTEM_CMD_TTY_READ_OUT 61
+#define SYSTEM_CMD_TTY_WRITE_IN 62
+#define SYSTEM_CMD_TTY_READ_IN 63
+#define SYSTEM_CMD_SPAWN 64
+#define SYSTEM_CMD_TTY_SET_FG 65
+#define SYSTEM_CMD_TTY_GET_FG 66
+#define SYSTEM_CMD_TTY_KILL_FG 67
+#define SYSTEM_CMD_TTY_KILL_ALL 68
+#define SYSTEM_CMD_TTY_DESTROY 69
+
+#define SPAWN_FLAG_TERMINAL 0x1
+#define SPAWN_FLAG_INHERIT_TTY 0x2
+#define SPAWN_FLAG_TTY_ID 0x4
 
 // Internal assembly entry into Ring 0
 extern uint64_t syscall0(uint64_t sys_num);
@@ -115,6 +129,17 @@ int sys_exists(const char *path);
 int sys_getcwd(char *buf, int size);
 int sys_chdir(const char *path);
 
+int sys_tty_create(void);
+int sys_tty_read_out(int tty_id, char *buf, int len);
+int sys_tty_write_in(int tty_id, const char *buf, int len);
+int sys_tty_read_in(char *buf, int len);
+int sys_spawn(const char *path, const char *args, uint64_t flags, uint64_t tty_id);
+int sys_tty_set_fg(int tty_id, int pid);
+int sys_tty_get_fg(int tty_id);
+int sys_tty_kill_fg(int tty_id);
+int sys_tty_kill_all(int tty_id);
+int sys_tty_destroy(int tty_id);
+
 typedef struct {
     char name[256];
     uint32_t size;
diff --git a/src/userland/net/telnet.c b/src/userland/net/telnet.c
index e355e53..d8440bf 100644
--- a/src/userland/net/telnet.c
+++ b/src/userland/net/telnet.c
@@ -3,8 +3,6 @@
 // This header needs to maintain in any file it is present in, as per the GPL license terms.
 #include <stdlib.h>
 #include <syscall.h>
-#include "libc/libui.h"
-
 
 static int term_cols = 116;
 static int term_rows = 41;
@@ -80,13 +78,10 @@ static void telnet_handle_option(uint8_t cmd, uint8_t opt) {
 
         case WILL:
             if (opt == OPT_SUPPRESS_GA) {
-                // Good — accept suppressed GA (most BBS systems do this)
                 telnet_send_3(IAC, DO, OPT_SUPPRESS_GA);
             } else if (opt == OPT_ECHO) {
-                // Server will echo chars (remote echo) — accept it
                 telnet_send_3(IAC, DO, OPT_ECHO);
             } else {
-                // Refuse other server offers
                 telnet_send_3(IAC, DONT, opt);
             }
             break;
@@ -115,14 +110,13 @@ static void telnet_handle_sb_terminal_type(const uint8_t *sb_data, int sb_len) {
 }
 
 
-
 typedef enum {
     TS_DATA = 0,
     TS_IAC,
-    TS_CMD,         
-    TS_OPT,         
-    TS_SB,         
-    TS_SB_IAC     
+    TS_CMD,
+    TS_OPT,
+    TS_SB,
+    TS_SB_IAC
 } TelnetParseState;
 
 static TelnetParseState ts_state = TS_DATA;
@@ -133,7 +127,7 @@ static int ts_sb_pos = 0;
 
 // Output buffer — accumulate non-IAC bytes to write in bulk
 static char out_buf[4096];
-static int  out_pos = 0;
+static int out_pos = 0;
 
 static void flush_out(void) {
     if (out_pos > 0) {
@@ -159,7 +153,6 @@ static int telnet_process(const uint8_t *data, int len) {
                 if (b == IAC) {
                     ts_state = TS_IAC;
                 } else {
-                    // Pass directly to display
                     out_char((char)b);
                 }
                 break;
@@ -167,7 +160,6 @@ static int telnet_process(const uint8_t *data, int len) {
             case TS_IAC:
                 switch (b) {
                     case IAC:
-                        // Escaped IAC — literal 0xFF
                         out_char((char)0xFF);
                         ts_state = TS_DATA;
                         break;
@@ -233,10 +225,9 @@ static int telnet_process(const uint8_t *data, int len) {
     return 1;
 }
 
-
 static int map_key(char c, uint8_t *key_out) {
     if (c == 29) {
-        // Ctrl+] 
+        // Ctrl+]
         return -1;
     }
     if (c == 17) {
@@ -260,12 +251,12 @@ static int map_key(char c, uint8_t *key_out) {
         return 3;
     }
     if (c == '\n') {
-        // Enter 
+        // Enter
         key_out[0] = '\r'; key_out[1] = '\n';
         return 2;
     }
     if (c == '\b') {
-        // Backspace 
+        // Backspace
         key_out[0] = '\x7f';
         return 1;
     }
@@ -276,7 +267,7 @@ static int map_key(char c, uint8_t *key_out) {
 
 static int my_atoi(const char *s) {
     int v = 0;
-    while (*s >= '0' && *s <= '9') { v = v*10 + (*s - '0'); s++; }
+    while (*s >= '0' && *s <= '9') { v = v * 10 + (*s - '0'); s++; }
     return v;
 }
 
@@ -284,7 +275,7 @@ static int parse_ip(const char *s, net_ipv4_address_t *ip) {
     int part = 0, val = 0;
     while (*s) {
         if (*s >= '0' && *s <= '9') {
-            val = val*10 + (*s - '0');
+            val = val * 10 + (*s - '0');
             if (val > 255) return -1;
         } else if (*s == '.') {
             if (part > 3) return -1;
@@ -340,8 +331,6 @@ int main(int argc, char **argv) {
         return 1;
     }
     printf("Connected. Press Ctrl+] to disconnect.\n\n");
-    
-    sys_system(41, 1, 0, 0, 0); // SYSTEM_CMD_SET_RAW_MODE = 1
 
     uint8_t recv_buf[4096];
     int total = 0;
@@ -349,19 +338,17 @@ int main(int argc, char **argv) {
     int connected = 1;
 
     while (connected) {
-        gui_event_t ev;
-        while (ui_get_event(0, &ev)) { // win=0 for console proc
-            if (ev.type == GUI_EVENT_KEY) {
-                uint8_t key_data[16];
-                int key_len = map_key((char)ev.arg1, key_data);
-                if (key_len < 0) {
-                    connected = 0;
-                    break;
-                }
-                telnet_send(key_data, key_len);
+        char ch = 0;
+        int got = sys_tty_read_in(&ch, 1);
+        if (got > 0) {
+            uint8_t key_data[16];
+            int key_len = map_key(ch, key_data);
+            if (key_len < 0) {
+                connected = 0;
+                break;
             }
+            telnet_send(key_data, key_len);
         }
-        if (!connected) break;
 
         int len = sys_tcp_recv_nb(recv_buf, sizeof(recv_buf) - 1);
         if (len < 0) {
@@ -371,8 +358,7 @@ int main(int argc, char **argv) {
         }
         if (len == 0) {
             idle_count++;
-            // Don't timeout too fast if we are just waiting for user input
-            if (idle_count > 10000000) { 
+            if (idle_count > 10000000) {
                 printf("\r\n[Connection timed out]\r\n");
                 connected = 0;
                 break;
@@ -395,11 +381,7 @@ int main(int argc, char **argv) {
         }
     }
 
-    // Disable raw mode before exiting
-    sys_system(41, 0, 0, 0, 0);
-
     sys_tcp_close();
     printf("\r\n[Telnet session ended]\r\n");
     return 0;
 }
-
diff --git a/src/wm/cmd.c b/src/wm/cmd.c
deleted file mode 100644
index 1e945b8..0000000
--- a/src/wm/cmd.c
+++ /dev/null
@@ -1,2332 +0,0 @@
-// Copyright (c) 2023-2026 Chris (boreddevnl)
-// This software is released under the GNU General Public License v3.0. See LICENSE file for details.
-// This header needs to maintain in any file it is present in, as per the GPL license terms.
-#include "cmd.h"
-#include "graphics.h"
-#include "wm.h"
-#include "io.h"
-#include "rtc.h"
-
-#include "fat32.h"
-#include "vfs.h"
-#include "disk.h"
-#include "kutils.h"
-#include <stddef.h>
-#include "memory_manager.h"
-#include "process.h"
-#include <stdbool.h>
-#include <stdint.h>
-#include <stddef.h>
-#include "network.h"
-#include "vm.h"
-#include "net_defs.h"
-#include "man_entries.h"
-
-#define DEFAULT_CMD_COLS 116
-#define DEFAULT_CMD_ROWS 41
-#define MAX_CMD_COLS 256
-// Terminal cell dimensions — fixed to match the 8x8 bitmap font
-#define LINE_HEIGHT 10
-#define CHAR_WIDTH  8
-
-#define COLOR_RED 0xFFFF0000
-
-#define TXT_BUFFER_SIZE 4096
-
-// --- Structs ---
-typedef struct {
-    char c;
-    uint32_t color;
-    uint8_t attrs; // bit 0: bold, bit 1: reverse, bit 2: blink
-} CharCell;
-
-typedef enum {
-    MODE_SHELL,
-    MODE_PAGER
-} CmdMode;
-
-// Shell Configuration
-typedef struct {
-    uint32_t prompt_drive_color;
-    uint32_t prompt_colon_color;
-    uint32_t prompt_dir_color;
-    uint32_t prompt_op_color;
-    char prompt_op_char;
-    uint32_t default_text_color;
-    uint32_t bg_color;
-    uint32_t cursor_color;
-    bool show_drive;
-    bool show_dir;
-    uint32_t dir_color;
-    uint32_t file_color;
-    uint32_t size_color;
-    uint32_t error_color;
-    uint32_t success_color;
-    uint32_t help_color;
-    uint32_t command_color;
-    char title_text[64];
-    char custom_welcome_message[128];
-    char startup_cmd[128];
-    char prompt_suffix[32];
-    bool welcome_msg;
-    bool history_save_prompt;
-} ShellConfig;
-
-static ShellConfig shell_config;
-
-// CMD Window State (per-window context)
-typedef struct {
-    char current_dir[256];
-} CmdState;
-
-// --- State ---
-Window win_cmd;
-
-// Shell State
-static int terminal_cols = DEFAULT_CMD_COLS;
-static int terminal_rows = DEFAULT_CMD_ROWS;
-static CharCell *screen_buffer = NULL;
-static int cursor_row = 0;
-static int cursor_col = 0;
-static uint32_t current_color = 0xFFFFFFFF; // Default light text
-static uint32_t current_bg_color = 0;        // 0 = translucent/default
-static CmdState *cmd_state = NULL;  // Will be set in cmd_init
-static int current_prompt_len = 0;
-
-static size_t cmd_strlen(const char *s) {
-    size_t len = 0;
-    while (s[len]) len++;
-    return len;
-}
-
-static int cmd_strcmp(const char *s1, const char *s2) {
-    while (*s1 && (*s1 == *s2)) {
-        s1++;
-        s2++;
-    }
-    return *(const unsigned char*)s1 - *(const unsigned char*)s2;
-}
-
-// ANSI State Machine
-static int ansi_state = 0;
-#define ANSI_MAX_PARAMS 8
-static int ansi_params[ANSI_MAX_PARAMS];
-static int ansi_param_count = 0;
-static bool ansi_private_mode = false;
-static int saved_cursor_row = 0;
-static int saved_cursor_col = 0;
-static uint8_t current_attrs = 0;
-static bool cursor_visible = true;
-static bool terminal_raw_mode = false;
-
-// Pager State
-static CmdMode current_mode = MODE_SHELL;
-static char pager_wrapped_lines[2000][MAX_CMD_COLS + 1]; 
-static int pager_total_lines = 0;
-static int pager_top_line = 0;
-
-// Process Execution State
-bool cmd_is_waiting_for_process = false;
-
-// Boot time for uptime
-int boot_time_init = 0;
-
-// Output redirection state
-static FAT32_FileHandle *redirect_file = NULL;
-static char redirect_mode = 0;  // '>' for write, 'a' for append, 0 for normal output
-static char redirect_filename[256];
-static bool pipe_capture_mode = false;
-static char pipe_buffer[8192];
-static int pipe_buffer_pos = 0;
-static bool pipe_waiting_for_first = false;
-static char pipe_next_command[512];
-int boot_year, boot_month, boot_day, boot_hour, boot_min, boot_sec;
-
-// Message notification state
-static int msg_count = 0;
-
-void cmd_increment_msg_count(void) {
-    msg_count++;
-}
-
-void cmd_reset_msg_count(void) {
-    msg_count = 0;
-}
-
-static uint32_t ansi_get_256_color(int n) {
-    if (n < 16) {
-        static uint32_t base[16] = {
-            0xFF000000, 0xFFAA0000, 0xFF00AA00, 0xFFAA5500, 0xFF0000AA, 0xFFAA00AA, 0xFF00AAAA, 0xFFAAAAAA,
-            0xFF555555, 0xFFFF5555, 0xFF55FF55, 0xFFFFFF55, 0xFF5555FF, 0xFFFF55FF, 0xFF55FFFF, 0xFFFFFFFF
-        };
-        return base[n];
-    }
-    if (n >= 232) {
-        uint8_t v = (n - 232) * 10 + 8;
-        return 0xFF000000 | (v << 16) | (v << 8) | v;
-    }
-    n -= 16;
-    static uint8_t levels[] = {0, 95, 135, 175, 215, 255};
-    int r = levels[n / 36];
-    int g = levels[(n / 6) % 6];
-    int b = levels[n % 6];
-    return 0xFF000000 | (r << 16) | (g << 8) | b;
-}
-
-static void ansi_handle_sgr() {
-    if (ansi_param_count == 0) {
-        current_color = 0xFFFFFFFF;
-        current_bg_color = 0;
-        current_attrs = 0;
-        return;
-    }
-    for (int i = 0; i < ansi_param_count; i++) {
-        int p = ansi_params[i];
-        if (p == 0) { 
-            current_color = 0xFFFFFFFF; 
-            current_bg_color = 0; 
-            current_attrs = 0; 
-        }
-        else if (p == 1) current_attrs |= 1; // Bold
-        else if (p == 5) current_attrs |= 4; // Blink
-        else if (p == 7) current_attrs |= 2; // Reverse
-        else if (p == 22) current_attrs &= ~1; // Normal intensity
-        else if (p == 25) current_attrs &= ~4; // Stop blink
-        else if (p == 27) current_attrs &= ~2; // Normal (not reverse)
-        else if (p >= 30 && p <= 37) current_color = ansi_get_256_color(p - 30);
-        else if (p >= 40 && p <= 47) current_bg_color = ansi_get_256_color(p - 40);
-        else if (p >= 90 && p <= 97) current_color = ansi_get_256_color(p - 90 + 8);
-        else if (p >= 100 && p <= 107) current_bg_color = ansi_get_256_color(p - 100 + 8);
-        else if (p == 38 || p == 48) {
-            bool is_fg = (p == 38);
-            if (i + 2 < ansi_param_count && ansi_params[i+1] == 5) {
-                uint32_t c = ansi_get_256_color(ansi_params[i+2]);
-                if (is_fg) current_color = c; else current_bg_color = c;
-                i += 2;
-            } else if (i + 4 < ansi_param_count && ansi_params[i+1] == 2) {
-                uint32_t c = 0xFF000000 | ((ansi_params[i+2] & 0xFF) << 16) | ((ansi_params[i+3] & 0xFF) << 8) | (ansi_params[i+4] & 0xFF);
-                if (is_fg) current_color = c; else current_bg_color = c;
-                i += 4;
-            }
-        }
-    }
-}
-
-static void cmd_strcpy(char *dest, const char *src) {
-    while (*src) *dest++ = *src++;
-    *dest = 0;
-}
-
-static void itoa(int n, char *buf);
-static void handle_pipe_chain(const char* right_cmd, bool print_prompt);
-
-static void itoa(int n, char *buf) {
-    if (n == 0) {
-        buf[0] = '0'; buf[1] = 0; return;
-    }
-    int i = 0;
-    int sign = n < 0;
-    if (sign) n = -n;
-    while (n > 0) {
-        buf[i++] = (n % 10) + '0';
-        n /= 10;
-    }
-    if (sign) buf[i++] = '-';
-    buf[i] = 0;
-    // Reverse
-    for (int j = 0; j < i / 2; j++) {
-        char t = buf[j];
-        buf[j] = buf[i - 1 - j];
-        buf[i - 1 - j] = t;
-    }
-    buf[i] = 0;
-}
-
-// --- Configuration Parsing ---
-
-static bool parse_bool(const char *s) {
-    if (!s) return false;
-    while (*s == ' ' || *s == '\t') s++;
-    if (cmd_strcmp(s, "true") == 0 || cmd_strcmp(s, "1") == 0 || cmd_strcmp(s, "yes") == 0) return true;
-    return false;
-}
-
-static int parse_int(const char *s) {
-    if (!s) return 0;
-    while (*s == ' ' || *s == '\t') s++;
-    int res = 0;
-    int sign = 1;
-    if (*s == '-') { sign = -1; s++; }
-    while (*s >= '0' && *s <= '9') {
-        res = res * 10 + (*s - '0');
-        s++;
-    }
-    return res * sign;
-}
-
-static uint32_t parse_color(const char *s) {
-    if (!s) return 0;
-    while (*s == ' ' || *s == '\t') s++;
-    if (!*s) return 0;
-
-    // 1. HEX Format: #RRGGBB or 0xRRGGBB
-    if (s[0] == '#' || (s[0] == '0' && (s[1] == 'x' || s[1] == 'X'))) {
-        const char *hex = (s[0] == '#') ? s + 1 : s + 2;
-        uint32_t res = 0;
-        int count = 0;
-        while (*hex && count < 8) {
-            char c = *hex++;
-            if (c >= '0' && c <= '9') res = (res << 4) | (c - '0');
-            else if (c >= 'a' && c <= 'f') res = (res << 4) | (c - 'a' + 10);
-            else if (c >= 'A' && c <= 'F') res = (res << 4) | (c - 'A' + 10);
-            else break;
-            count++;
-        }
-        if (count == 6) res |= 0xFF000000;
-        return res;
-    }
-
-    // 2. RGB Format: rgb(r, g, b)
-    if (s[0] == 'r' && s[1] == 'g' && s[2] == 'b') {
-        const char *p = s + 3;
-        while (*p && *p != '(') p++;
-        if (*p == '(') {
-            p++;
-            while (*p == ' ' || *p == '\t') p++;
-            int r = parse_int(p);
-            while (*p && *p != ',' && *p != ')') p++;
-            if (*p == ',') {
-                p++;
-                while (*p == ' ' || *p == '\t') p++;
-                int g = parse_int(p);
-                while (*p && *p != ',' && *p != ')') p++;
-                if (*p == ',') {
-                    p++;
-                    while (*p == ' ' || *p == '\t') p++;
-                    int b = parse_int(p);
-                    return 0xFF000000 | ((uint32_t)(r & 0xFF) << 16) | ((uint32_t)(g & 0xFF) << 8) | (uint32_t)(b & 0xFF);
-                }
-            }
-        }
-    }
-
-    // 3. Named Colors (assuming s is trimmed and lowercased)
-    if (cmd_strcmp(s, "black") == 0) return 0xFF000000;
-    if (cmd_strcmp(s, "white") == 0) return 0xFFFFFFFF;
-    if (cmd_strcmp(s, "gray") == 0 || cmd_strcmp(s, "grey") == 0) return 0xFF808080;
-    if (cmd_strcmp(s, "lightgray") == 0 || cmd_strcmp(s, "light gray") == 0 || cmd_strcmp(s, "lightgrey") == 0 || cmd_strcmp(s, "light grey") == 0) return 0xFFD3D3D3;
-    if (cmd_strcmp(s, "darkgray") == 0 || cmd_strcmp(s, "dark gray") == 0 || cmd_strcmp(s, "darkgrey") == 0 || cmd_strcmp(s, "dark grey") == 0) return 0xFFA9A9A9;
-    
-    if (cmd_strcmp(s, "red") == 0) return 0xFFFF0000;
-    if (cmd_strcmp(s, "lightred") == 0 || cmd_strcmp(s, "light red") == 0) return 0xFFFF7F7F;
-    if (cmd_strcmp(s, "darkred") == 0 || cmd_strcmp(s, "dark red") == 0) return 0xFF8B0000;
-    
-    if (cmd_strcmp(s, "green") == 0) return 0xFF00FF00;
-    if (cmd_strcmp(s, "lightgreen") == 0 || cmd_strcmp(s, "light green") == 0) return 0xFF90EE90;
-    if (cmd_strcmp(s, "darkgreen") == 0 || cmd_strcmp(s, "dark green") == 0) return 0xFF006400;
-    
-    if (cmd_strcmp(s, "yellow") == 0) return 0xFFFFFF00;
-    if (cmd_strcmp(s, "lightyellow") == 0 || cmd_strcmp(s, "light yellow") == 0) return 0xFFFFFFE0;
-    
-    if (cmd_strcmp(s, "blue") == 0) return 0xFF0000FF;
-    if (cmd_strcmp(s, "lightblue") == 0 || cmd_strcmp(s, "light blue") == 0) return 0xFFADD8E6;
-    if (cmd_strcmp(s, "darkblue") == 0 || cmd_strcmp(s, "dark blue") == 0) return 0xFF00008B;
-    
-    if (cmd_strcmp(s, "magenta") == 0) return 0xFFFF00FF;
-    if (cmd_strcmp(s, "lightmagenta") == 0 || cmd_strcmp(s, "light magenta") == 0) return 0xFFFF77FF;
-    
-    if (cmd_strcmp(s, "cyan") == 0 || cmd_strcmp(s, "aqua") == 0) return 0xFF00FFFF;
-    if (cmd_strcmp(s, "lightcyan") == 0 || cmd_strcmp(s, "light cyan") == 0) return 0xFFE0FFFF;
-    
-    if (cmd_strcmp(s, "orange") == 0) return 0xFFFFA500;
-    if (cmd_strcmp(s, "brown") == 0) return 0xFFA52A2A;
-    if (cmd_strcmp(s, "pink") == 0) return 0xFFFFC0CB;
-    if (cmd_strcmp(s, "purple") == 0) return 0xFF800080;
-    if (cmd_strcmp(s, "teal") == 0) return 0xFF008080;
-    if (cmd_strcmp(s, "lime") == 0) return 0xFF00FF00;
-    if (cmd_strcmp(s, "maroon") == 0) return 0xFF800000;
-    if (cmd_strcmp(s, "navy") == 0) return 0xFF000080;
-    if (cmd_strcmp(s, "indigo") == 0) return 0xFF4B0082;
-    if (cmd_strcmp(s, "violet") == 0) return 0xFFEE82EE;
-
-    // 4. Fallback: Loose Hex (e.g. "FF00FF")
-    const char *hex = s;
-    uint32_t res = 0;
-    int count = 0;
-    while (*hex && count < 8) {
-        char c = *hex++;
-        if (c >= '0' && c <= '9') res = (res << 4) | (c - '0');
-        else if (c >= 'a' && c <= 'f') res = (res << 4) | (c - 'a' + 10);
-        else if (c >= 'A' && c <= 'F') res = (res << 4) | (c - 'A' + 10);
-        else break;
-        count++;
-    }
-    if (count == 6) res |= 0xFF000000;
-    return res;
-}
-
-static void cmd_init_config_defaults(void) {
-    shell_config.prompt_drive_color = 0xFFFFFFFF; // Default light gray
-    shell_config.prompt_colon_color = 0xFFCCCCCC;
-    shell_config.prompt_dir_color = 0xFF569CD6;   // Blue
-    shell_config.prompt_op_color = 0xFFCCCCCC;
-    shell_config.prompt_op_char = '>';
-    shell_config.default_text_color = 0xFFFFFFFF; // White
-    shell_config.bg_color = 0xFF1E1E1E;          // Dark background
-    shell_config.cursor_color = 0xFFFFFFFF;
-    shell_config.show_drive = false;
-    shell_config.show_dir = true;
-    shell_config.dir_color = 0xFF569CD6;
-    shell_config.file_color = 0xFFFFFFFF;
-    shell_config.size_color = 0xFF6A9955;         // Green
-    shell_config.error_color = 0xFFFF4444;        // Red
-    shell_config.success_color = 0xFF6A9955;
-    shell_config.help_color = 0xFFCCCCCC;
-    shell_config.command_color = 0xFFFFFFFF;     // White typed text
-    cmd_strcpy(shell_config.title_text, "Command Prompt");
-    cmd_strcpy(shell_config.custom_welcome_message, "");
-    cmd_strcpy(shell_config.startup_cmd, "");
-    cmd_strcpy(shell_config.prompt_suffix, " ");
-    shell_config.welcome_msg = true;
-    shell_config.history_save_prompt = true;
-}
-
-void cmd_load_config(void) {
-    cmd_init_config_defaults();
-    
-    FAT32_FileHandle *fh = fat32_open("Library/conf/shell.cfg", "r");
-    if (!fh) return;
-    
-    char buffer[4096];
-    int bytes = fat32_read(fh, buffer, sizeof(buffer) - 1);
-    fat32_close(fh);
-    
-    if (bytes <= 0) return;
-    buffer[bytes] = 0;
-    
-    char *line = buffer;
-    while (*line) {
-        char *end = line;
-        while (*end && *end != '\n' && *end != '\r') end++;
-        
-        char saved = *end;
-        *end = 0;
-        
-        // Skip comments and empty lines
-        if (line[0] == '/' && line[1] == '/') {
-            line = end + (saved ? 1 : 0);
-            if (saved == '\r' && *line == '\n') line++;
-            continue;
-        }
-        
-        char *sep = line;
-        while (*sep && *sep != '=') sep++;
-        
-        if (*sep == '=') {
-            *sep = 0;
-            char *key = line;
-            char *val = sep + 1;
-            
-            // Trim whitespace from key
-            char *k_end = sep - 1;
-            while (k_end > key && (*k_end == ' ' || *k_end == '\t')) {
-                *k_end-- = 0;
-            }
-            
-            // Trim whitespace from value
-            while (*val == ' ' || *val == '\t') val++;
-            char *v_end = val;
-            while (*v_end) v_end++;
-            if (v_end > val) {
-                v_end--;
-                while (v_end > val && (*v_end == ' ' || *v_end == '\t' || *v_end == '\n' || *v_end == '\r')) {
-                    *v_end-- = 0;
-                }
-            }
-
-            // Lowercase value for easier parsing of named colors, EXCEPT for string fields
-            if (cmd_strcmp(key, "title_text") != 0 && 
-                cmd_strcmp(key, "custom_welcome_message") != 0 &&
-                cmd_strcmp(key, "startup_cmd") != 0 &&
-                cmd_strcmp(key, "prompt_suffix") != 0) {
-                char *p_low = val;
-                while (*p_low) {
-                    if (*p_low >= 'A' && *p_low <= 'Z') *p_low += 32;
-                    p_low++;
-                }
-            }
-            
-            if (cmd_strcmp(key, "prompt_drive_color") == 0) shell_config.prompt_drive_color = parse_color(val);
-            else if (cmd_strcmp(key, "prompt_colon_color") == 0) shell_config.prompt_colon_color = parse_color(val);
-            else if (cmd_strcmp(key, "prompt_dir_color") == 0) shell_config.prompt_dir_color = parse_color(val);
-            else if (cmd_strcmp(key, "prompt_op_color") == 0) shell_config.prompt_op_color = parse_color(val);
-            else if (cmd_strcmp(key, "prompt_op_char") == 0) {
-                if (*val) shell_config.prompt_op_char = *val;
-            }
-            else if (cmd_strcmp(key, "default_text_color") == 0) shell_config.default_text_color = parse_color(val);
-            else if (cmd_strcmp(key, "bg_color") == 0) shell_config.bg_color = parse_color(val);
-            else if (cmd_strcmp(key, "cursor_color") == 0) shell_config.cursor_color = parse_color(val);
-            else if (cmd_strcmp(key, "show_drive") == 0) shell_config.show_drive = parse_bool(val);
-            else if (cmd_strcmp(key, "show_dir") == 0) shell_config.show_dir = parse_bool(val);
-            else if (cmd_strcmp(key, "dir_color") == 0) shell_config.dir_color = parse_color(val);
-            else if (cmd_strcmp(key, "file_color") == 0) shell_config.file_color = parse_color(val);
-            else if (cmd_strcmp(key, "size_color") == 0) shell_config.size_color = parse_color(val);
-            else if (cmd_strcmp(key, "error_color") == 0) shell_config.error_color = parse_color(val);
-            else if (cmd_strcmp(key, "success_color") == 0) shell_config.success_color = parse_color(val);
-            else if (cmd_strcmp(key, "help_color") == 0) shell_config.help_color = parse_color(val);
-            else if (cmd_strcmp(key, "command_color") == 0) shell_config.command_color = parse_color(val);
-            else if (cmd_strcmp(key, "title_text") == 0) {
-                cmd_strcpy(shell_config.title_text, val);
-            }
-            else if (cmd_strcmp(key, "custom_welcome_message") == 0) {
-                cmd_strcpy(shell_config.custom_welcome_message, val);
-            }
-            else if (cmd_strcmp(key, "startup_cmd") == 0) {
-                cmd_strcpy(shell_config.startup_cmd, val);
-            }
-            else if (cmd_strcmp(key, "prompt_suffix") == 0) {
-                cmd_strcpy(shell_config.prompt_suffix, val);
-            }
-            else if (cmd_strcmp(key, "welcome_msg") == 0) shell_config.welcome_msg = parse_bool(val);
-            else if (cmd_strcmp(key, "history_save_prompt") == 0) shell_config.history_save_prompt = parse_bool(val);
-        }
-        
-        line = end + (saved ? 1 : 0);
-        if (saved == '\r' && *line == '\n') line++;
-    }
-}
-
-// System Call Helper
-uint32_t cmd_get_config_value(const char *key) {
-    if (cmd_strcmp(key, "prompt_drive_color") == 0) return shell_config.prompt_drive_color;
-    if (cmd_strcmp(key, "prompt_colon_color") == 0) return shell_config.prompt_colon_color;
-    if (cmd_strcmp(key, "prompt_dir_color") == 0) return shell_config.prompt_dir_color;
-    if (cmd_strcmp(key, "prompt_op_color") == 0) return shell_config.prompt_op_color;
-    if (cmd_strcmp(key, "default_text_color") == 0) return shell_config.default_text_color;
-    if (cmd_strcmp(key, "bg_color") == 0) return shell_config.bg_color;
-    if (cmd_strcmp(key, "cursor_color") == 0) return shell_config.cursor_color;
-    if (cmd_strcmp(key, "dir_color") == 0) return shell_config.dir_color;
-    if (cmd_strcmp(key, "file_color") == 0) return shell_config.file_color;
-    if (cmd_strcmp(key, "size_color") == 0) return shell_config.size_color;
-    if (cmd_strcmp(key, "error_color") == 0) return shell_config.error_color;
-    if (cmd_strcmp(key, "success_color") == 0) return shell_config.success_color;
-    if (cmd_strcmp(key, "help_color") == 0) return shell_config.help_color;
-    if (cmd_strcmp(key, "command_color") == 0) return shell_config.command_color;
-
-    // Return 1 for boolean true values
-    if (cmd_strcmp(key, "show_drive") == 0) return shell_config.show_drive;
-    if (cmd_strcmp(key, "show_dir") == 0) return shell_config.show_dir;
-    if (cmd_strcmp(key, "welcome_msg") == 0) return shell_config.welcome_msg;
-    if (cmd_strcmp(key, "history_save_prompt") == 0) return shell_config.history_save_prompt;
-    
-    return 0;
-}
-
-void cmd_set_current_color(uint32_t color) {
-    current_color = color;
-}
-
-// --- History ---
-#define HISTORY_MAX 64
-static char cmd_history[HISTORY_MAX][MAX_CMD_COLS + 1];
-static int history_head = 0;
-static int history_len = 0;
-static int history_pos = -1;
-static char history_save_buf[MAX_CMD_COLS + 1];
-
-static void cmd_history_add(const char *cmd) {
-    if (!cmd || !*cmd) return;
-    
-    // Don't add if same as last command
-    int last_idx = (history_head - 1 + HISTORY_MAX) % HISTORY_MAX;
-    if (history_len > 0 && cmd_strcmp(cmd, cmd_history[last_idx]) == 0) {
-        return;
-    }
-
-    cmd_strcpy(cmd_history[history_head], cmd);
-    history_head = (history_head + 1) % HISTORY_MAX;
-    if (history_len < HISTORY_MAX) history_len++;
-}
-
-void cmd_print_prompt(void) {
-    if (cmd_state) {
-        current_prompt_len = 0;
-        cursor_col = 0;
-        
-        if (shell_config.show_drive) {
-            // No more drive letter in VFS
-        }
-        
-        if (shell_config.show_dir) {
-            current_color = shell_config.prompt_dir_color;
-            cmd_write(cmd_state->current_dir);
-        }
-        
-        current_color = shell_config.prompt_op_color;
-        cmd_putchar(shell_config.prompt_op_char);
-        
-        if (shell_config.prompt_suffix[0]) {
-            cmd_write(shell_config.prompt_suffix);
-        }
-        
-        current_prompt_len = cursor_col;
-        current_color = shell_config.command_color;
-    }
-}
-
-void cmd_clear_line_content(void) {
-    int prompt_len = current_prompt_len;
-    for (int i = prompt_len; i < terminal_cols; i++) {
-        screen_buffer[cursor_row * terminal_cols + i].c = ' ';
-        screen_buffer[cursor_row * terminal_cols + i].color = current_color;
-    }
-    cursor_col = prompt_len;
-}
-
-static void cmd_set_line_content(const char *str) {
-    cmd_clear_line_content();
-    while (*str && cursor_col < terminal_cols) {
-        screen_buffer[cursor_row * terminal_cols + cursor_col].c = *str;
-        screen_buffer[cursor_row * terminal_cols + cursor_col].color = current_color;
-        cursor_col++;
-        str++;
-    }
-}
-
-
-static void cmd_scroll_up() {
-    for (int r = 1; r < terminal_rows; r++) {
-        for (int c = 0; c < terminal_cols; c++) {
-            screen_buffer[(r - 1) * terminal_cols + c] = screen_buffer[r * terminal_cols + c];
-        }
-    }
-    // Clear bottom row
-    for (int c = 0; c < terminal_cols; c++) {
-        screen_buffer[(terminal_rows - 1) * terminal_cols + c].c = ' ';
-        screen_buffer[(terminal_rows - 1) * terminal_cols + c].color = shell_config.default_text_color;
-    }
-}
-
-
-// Public for CLI apps to use
-void cmd_putchar(char c) {
-    // If pipe capture mode is enabled, write to pipe buffer
-    if (pipe_capture_mode) {
-        if (pipe_buffer_pos < (int)sizeof(pipe_buffer) - 1) {
-            pipe_buffer[pipe_buffer_pos++] = c;
-        }
-        return;
-    }
-    
-    // If output is being redirected to a file, write there instead
-    if (redirect_file && redirect_mode) {
-        fat32_write(redirect_file, &c, 1);
-        return;
-    }
-
-    if (ansi_state == 0) {
-        if (c == '\x1b') {
-            ansi_state = 1;
-            return;
-        } else if (c == '\x07') {
-            // BEL - Beep
-            k_beep(750, 100);
-            return;
-        }
-    } else if (ansi_state == 1) {
-        if (c == '[') {
-            ansi_state = 2;
-            ansi_param_count = 0;
-            for(int i=0; i<ANSI_MAX_PARAMS; i++) ansi_params[i] = 0;
-            ansi_private_mode = false;
-            return;
-        } else if (c == 'O') {
-            ansi_state = 3; // SS3
-            return;
-        } else if (c == 'M') {
-            // Reverse Index - scroll up if at top
-            if (cursor_row > 0) {
-                cursor_row--;
-            } else {
-                // Scroll screen down
-                for (int r = terminal_rows - 1; r > 0; r--) {
-                    for (int col = 0; col < terminal_cols; col++) {
-                        screen_buffer[r * terminal_cols + col] = screen_buffer[(r - 1) * terminal_cols + col];
-                    }
-                }
-                for (int col = 0; col < terminal_cols; col++) {
-                    screen_buffer[0 * terminal_cols + col].c = ' ';
-                    screen_buffer[0 * terminal_cols + col].color = shell_config.default_text_color;
-                    screen_buffer[0 * terminal_cols + col].attrs = 0;
-                }
-            }
-            ansi_state = 0;
-            return;
-        } else if (c == '=' || c == '>') {
-            // ALT/NORM Keypad mode - absorb
-            ansi_state = 0;
-            return;
-        } else {
-            ansi_state = 0; // Unsupported ESC sequence
-        }
-    } else if (ansi_state == 2) {
-        if (c == '?') {
-            ansi_private_mode = true;
-            return;
-        } else if (c >= '0' && c <= '9') {
-            if (ansi_param_count < ANSI_MAX_PARAMS) {
-                ansi_params[ansi_param_count] = ansi_params[ansi_param_count] * 10 + (c - '0');
-            }
-            return;
-        } else if (c == ';') {
-            ansi_param_count++;
-            return;
-        } else {
-            // End of sequence
-            if (ansi_param_count < ANSI_MAX_PARAMS) ansi_param_count++;
-            
-                        if (c == 'm') {
-                ansi_handle_sgr();
-            } else if (c == 'H' || c == 'f') {
-                int r = ansi_params[0] > 0 ? ansi_params[0] - 1 : 0;
-                int col = ansi_params[1] > 0 ? ansi_params[1] - 1 : 0;
-                if (r >= terminal_rows) r = terminal_rows - 1;
-                if (col >= terminal_cols) col = terminal_cols - 1;
-                cursor_row = r;
-                cursor_col = col;
-            } else if (c == 'A') {
-                int n = ansi_params[0] > 0 ? ansi_params[0] : 1;
-                cursor_row -= n; if (cursor_row < 0) cursor_row = 0;
-            } else if (c == 'B') {
-                int n = ansi_params[0] > 0 ? ansi_params[0] : 1;
-                cursor_row += n; if (cursor_row >= terminal_rows) cursor_row = terminal_rows - 1;
-            } else if (c == 'C') {
-                int n = ansi_params[0] > 0 ? ansi_params[0] : 1;
-                cursor_col += n; if (cursor_col >= terminal_cols) cursor_col = terminal_cols - 1;
-            } else if (c == 'D') {
-                int n = ansi_params[0] > 0 ? ansi_params[0] : 1;
-                cursor_col -= n; if (cursor_col < 0) cursor_col = 0;
-            } else if (c == 's') {
-                saved_cursor_row = cursor_row;
-                saved_cursor_col = cursor_col;
-            } else if (c == 'u') {
-                cursor_row = saved_cursor_row;
-                cursor_col = saved_cursor_col;
-            } else if (c == 'J') {
-                if (ansi_params[0] == 2) {
-                    cmd_screen_clear();
-                } else if (ansi_params[0] == 0) {
-                    // Erase from cursor to end of screen
-                    for (int i = cursor_row * terminal_cols + cursor_col; i < terminal_rows * terminal_cols; i++) {
-                        screen_buffer[i].c = ' ';
-                        screen_buffer[i].color = current_color;
-                        screen_buffer[i].attrs = 0;
-                    }
-                } else if (ansi_params[0] == 1) {
-                    // Erase from beginning of screen to cursor
-                    for (int i = 0; i <= cursor_row * terminal_cols + cursor_col; i++) {
-                        screen_buffer[i].c = ' ';
-                        screen_buffer[i].color = current_color;
-                        screen_buffer[i].attrs = 0;
-                    }
-                }
-            } else if (c == 'K') {
-                if (ansi_params[0] == 0) {
-                    for (int i = cursor_col; i < terminal_cols; i++) {
-                        screen_buffer[cursor_row * terminal_cols + i].c = ' ';
-                        screen_buffer[cursor_row * terminal_cols + i].color = current_color;
-                        screen_buffer[cursor_row * terminal_cols + i].attrs = current_attrs;
-                    }
-                } else if (ansi_params[0] == 1) {
-                    for (int i = 0; i <= cursor_col; i++) {
-                        screen_buffer[cursor_row * terminal_cols + i].c = ' ';
-                        screen_buffer[cursor_row * terminal_cols + i].color = current_color;
-                        screen_buffer[cursor_row * terminal_cols + i].attrs = current_attrs;
-                    }
-                } else if (ansi_params[0] == 2) {
-                    for (int i = 0; i < terminal_cols; i++) {
-                        screen_buffer[cursor_row * terminal_cols + i].c = ' ';
-                        screen_buffer[cursor_row * terminal_cols + i].color = current_color;
-                        screen_buffer[cursor_row * terminal_cols + i].attrs = current_attrs;
-                    }
-                }
-            } else if (c == 'h' && ansi_private_mode) {
-                if (ansi_params[0] == 25) cursor_visible = true;
-            } else if (c == 'l' && ansi_private_mode) {
-                if (ansi_params[0] == 25) cursor_visible = false;
-            }
-            
-            ansi_state = 0;
-            return;
-        }
-    } else if (ansi_state == 3) {
-        // SS3 sequences: ESC O <char>
-        if (c == 'A') { cursor_row--; if (cursor_row < 0) cursor_row = 0; }
-        else if (c == 'B') { cursor_row++; if (cursor_row >= terminal_rows) cursor_row = terminal_rows - 1; }
-        else if (c == 'C') { cursor_col++; if (cursor_col >= terminal_cols) cursor_col = terminal_cols - 1; }
-        else if (c == 'D') { cursor_col--; if (cursor_col < 0) cursor_col = 0; }
-        ansi_state = 0;
-        return;
-    }
-    
-    if (c == '\n') {
-        cursor_col = 0;
-        cursor_row++;
-    } else if (c == '\r') {
-        cursor_col = 0;
-    } else if (c == '\t') {
-        int spaces = 4 - (cursor_col % 4);
-        for (int i = 0; i < spaces; i++) cmd_putchar(' ');
-        return;
-    } else if (c == '\b') {
-        if (cursor_col > 0) {
-            cursor_col--;
-            screen_buffer[cursor_row * terminal_cols + cursor_col].c = ' ';
-            screen_buffer[cursor_row * terminal_cols + cursor_col].color = shell_config.default_text_color;
-        }
-    } else {
-        if (cursor_col >= terminal_cols) {
-            cursor_col = 0;
-            cursor_row++;
-        }
-        
-        if (cursor_row >= terminal_rows) {
-            cmd_scroll_up();
-            cursor_row = terminal_rows - 1;
-        }
-
-        screen_buffer[cursor_row * terminal_cols + cursor_col].c = c;
-        screen_buffer[cursor_row * terminal_cols + cursor_col].color = current_color;
-        screen_buffer[cursor_row * terminal_cols + cursor_col].attrs = current_attrs;
-        cursor_col++;
-    }
-
-    if (cursor_row >= terminal_rows) {
-        cmd_scroll_up();
-        cursor_row = terminal_rows - 1;
-    }
-    
-    // Trigger repaint so output from syscalls is immediately visible
-    wm_mark_dirty(win_cmd.x, win_cmd.y, win_cmd.w, win_cmd.h);
-}
-
-void cmd_write_len(const char *str, size_t len);
-
-// Public for CLI apps to use
-void cmd_write(const char *str) {
-    if (!str) return;
-    cmd_write_len(str, cmd_strlen(str));
-}
-
-void cmd_write_len(const char *str, size_t len) {
-    if (pipe_capture_mode) {
-        for (size_t i = 0; i < len && pipe_buffer_pos < (int)sizeof(pipe_buffer) - 1; i++) {
-            pipe_buffer[pipe_buffer_pos++] = str[i];
-        }
-        return;
-    }
-    
-    if (redirect_file && redirect_mode) {
-        fat32_write(redirect_file, (void *)str, len);
-    } else {
-        for (size_t i = 0; i < len; i++) {
-            cmd_putchar(str[i]);
-        }
-    }
-}
-
-// Public for CLI apps to use
-void cmd_write_int(int n) {
-    char buf[32];
-    itoa(n, buf);
-    cmd_write(buf);
-}
-
-void cmd_write_hex(uint64_t n) {
-    const char* digits = "0123456789ABCDEF";
-    char buf[19];
-    buf[0] = '0';
-    buf[1] = 'x';
-    buf[18] = '\0';
-    for (int i = 17; i >= 2; i--) {
-        buf[i] = digits[n & 0xF];
-        n >>= 4;
-    }
-    cmd_write(buf);
-}
-
-int cmd_get_cursor_col(void) {
-    return cursor_col;
-}
-
-// --- Pager Logic ---
-
-// Public for CLI apps to use - clear the terminal screen
-void cmd_screen_clear() {
-    for(int r=0; r<terminal_rows; r++) {
-        for(int c=0; c<terminal_cols; c++) {
-            screen_buffer[r * terminal_cols + c].c = ' ';
-            screen_buffer[r * terminal_cols + c].color = COLOR_DARK_TEXT;
-            screen_buffer[r * terminal_cols + c].attrs = 0;
-        }
-    }
-    cursor_row = 0;
-    cursor_col = 0;
-    wm_mark_dirty(win_cmd.x, win_cmd.y, win_cmd.w, win_cmd.h);
-}
-
-// Public for CLI apps to use - exit/close the terminal window
-void cmd_window_exit() {
-    win_cmd.visible = false;
-}
-
-// Public for CLI apps to use
-void pager_wrap_content(const char **lines, int count) {
-    pager_total_lines = 0;
-    pager_top_line = 0;
-    
-    for (int i = 0; i < count; i++) {
-        const char *line = lines[i];
-        int len = cmd_strlen(line);
-        
-        if (len == 0) {
-            pager_wrapped_lines[pager_total_lines][0] = 0;
-            pager_total_lines++;
-            continue;
-        }
-        
-        // Intelligent Word Wrap
-        int processed = 0;
-        while (processed < len) {
-            if (pager_total_lines >= 2000) break;
-
-            int remaining = len - processed;
-            int chunk_len = remaining;
-            if (chunk_len > terminal_cols) chunk_len = terminal_cols;
-
-            // If cutting a word, backtrack to last space
-            if (chunk_len < remaining) { // Only check if actually wrapping
-                int split_point = chunk_len;
-                while (split_point > 0 && line[processed + split_point] != ' ') {
-                    split_point--;
-                }
-                
-                if (split_point > 0) {
-                    chunk_len = split_point; // Cut at space
-                }
-                // If split_point == 0, the word is longer than the line, so forced split is okay.
-            }
-
-            // Copy chunk
-            for (int k = 0; k < chunk_len; k++) {
-                pager_wrapped_lines[pager_total_lines][k] = line[processed + k];
-            }
-            pager_wrapped_lines[pager_total_lines][chunk_len] = 0;
-            
-            pager_total_lines++;
-            processed += chunk_len;
-            
-            if (processed < len && line[processed] == ' ') {
-                processed++;
-            }
-        }
-    }
-}
-
-// Public for CLI apps to use
-void pager_set_mode(void) {
-    current_mode = MODE_PAGER;
-}
-
-// Internal LS command to avoid stack overflow in external module
-static void cmd_update_dir(const char *path);  // Forward declaration
-
-
-
-static void internal_cmd_cd(char *args) {
-    // Handle cd with proper cmd_state context
-    if (!args || !args[0]) {
-        // No argument - show current directory
-        if (cmd_state) {
-            
-            cmd_write(cmd_state->current_dir);
-            cmd_write("\n");
-        } else {
-            char cwd[256];
-            fat32_get_current_dir(cwd, sizeof(cwd));
-            cmd_write("Current directory: ");
-            cmd_write(cwd);
-            cmd_write("\n");
-        }
-        return;
-    }
-    
-    // Parse argument (remove trailing spaces/tabs)
-    char path[256];
-    int i = 0;
-    while (args[i] && args[i] != ' ' && args[i] != '\t') {
-        path[i] = args[i];
-        i++;
-    }
-    path[i] = 0;
-    
-    if (cmd_state) {
-        // Build full path for validation
-        char full_path[512] = {0};
-        if (path[1] == ':') {
-            // Has drive letter
-            cmd_strcpy(full_path, path);
-        } else if (path[0] == '/') {
-            // Absolute path
-            int j = 0;
-            int k = 0;
-            while (path[k] && j < 509) {
-                full_path[j++] = path[k++];
-            }
-            full_path[j] = 0;
-        } else {
-            // Relative path - resolve from current directory
-            int j = 0;
-            
-            // Copy current directory
-            const char *dir = cmd_state->current_dir;
-            while (*dir && j < 509) {
-                full_path[j++] = *dir++;
-            }
-            
-            // Add separator if needed
-            if (j > 2 && full_path[j-1] != '/') {
-                full_path[j++] = '/';
-            }
-            
-            // Add path argument
-            int k = 0;
-            while (path[k] && j < 509) {
-                full_path[j++] = path[k++];
-            }
-            full_path[j] = 0;
-        }
-        
-        // Validate directory exists
-        if (vfs_is_directory(full_path)) {
-            // Normalize the path to resolve .. and .
-            char normalized_path[512];
-            vfs_normalize_path(cmd_state->current_dir, full_path, normalized_path);
-            
-            cmd_update_dir(normalized_path);
-            cmd_write("Changed to: ");
-            
-            cmd_write(cmd_state->current_dir);
-            cmd_write("\n");
-        } else {
-            cmd_write("Error: Cannot change to directory: ");
-            cmd_write(path);
-            cmd_write("\n");
-        }
-    } else {
-        // Fallback to global state if no cmd_state
-        if (fat32_chdir(path)) {
-            char cwd[256];
-            fat32_get_current_dir(cwd, sizeof(cwd));
-            cmd_write("Changed to: ");
-            cmd_write(cwd);
-            cmd_write("\n");
-        } else {
-            cmd_write("Error: Cannot change to directory: ");
-            cmd_write(path);
-            cmd_write("\n");
-        }
-    }
-}
-
-static void internal_cmd_txtedit(char *args) {
-    // Parse the file path argument
-    char filepath[256];
-    int i = 0;
-    
-    // Skip leading whitespace
-    while (args && args[i] && (args[i] == ' ' || args[i] == '\t')) {
-        i++;
-    }
-    
-    // Extract filepath
-    int j = 0;
-    while (args && args[i] && args[i] != ' ' && args[i] != '\t' && j < 255) {
-        filepath[j++] = args[i++];
-    }
-    filepath[j] = 0;
-    
-    // If no filepath provided, show usage
-    if (j == 0) {
-        cmd_write("Usage: txtedit <filename>\n");
-        return;
-    }
-
-    // Normalize the path
-    char normalized_path[256];
-    fat32_normalize_path(filepath, normalized_path);
-    
-    cmd_write("Opening: ");
-    cmd_write(normalized_path);
-    cmd_write("\n");
-
-    cmd_is_waiting_for_process = true;
-    process_t *proc = process_create_elf("/bin/txtedit.elf", normalized_path);
-    if (proc) {
-        proc->is_terminal_proc = true;
-        proc->ui_window = &win_cmd;
-    }
-}
-
-
-
-
-void cmd_exec_elf(char *args) {
-    if (!args || args[0] == '\0') {
-        cmd_write("Usage: exec <filename>\n");
-        return;
-    }
-
-    char full_exec_path[512] = {0};
-    int i = 0;
-    
-    if (args[0] && args[0] != '/') {
-        if (cmd_state) {
-            const char *dir = cmd_state->current_dir;
-            while (*dir && i < 509) {
-                full_exec_path[i++] = *dir++;
-            }
-            if (i > 0 && full_exec_path[i-1] != '/') {
-                full_exec_path[i++] = '/';
-            }
-        }
-        const char *p = args;
-        while (*p && i < 509) {
-            full_exec_path[i++] = *p++;
-        }
-        full_exec_path[i] = 0;
-    } else {
-        // Just copy what they provided
-        const char *p = args;
-        while (*p && i < 511) {
-            full_exec_path[i++] = *p++;
-        }
-        full_exec_path[i] = 0;
-    }
-    
-    cmd_is_waiting_for_process = true;
-    process_t *proc = process_create_elf(full_exec_path, args);
-    if (proc) {
-        proc->is_terminal_proc = true;
-        proc->ui_window = &win_cmd;
-    }
-}
-
-// Public API for syscall exit 
-void cmd_process_finished(void) {
-    if (cmd_is_waiting_for_process) {
-        cmd_is_waiting_for_process = false;
-
-        if (redirect_file) {
-            fat32_close(redirect_file);
-            redirect_file = NULL;
-            redirect_mode = 0;
-            cmd_write("Output redirected to: ");
-            cmd_write(redirect_filename);
-            cmd_write("\n");
-        }
-
-        if (pipe_waiting_for_first) {
-            pipe_waiting_for_first = false;
-            pipe_capture_mode = false;
-            handle_pipe_chain(pipe_next_command, true);
-            return;
-        }
-
-        if (cursor_col > 0) {
-            cmd_putchar('\n');
-        }
-        cmd_print_prompt();
-    }
-}
-
-static void internal_cmd_exit(char *args) {
-    (void)args;
-    cmd_window_exit();
-}
-
-static void internal_cmd_reload(char *args) {
-    (void)args;
-    cmd_load_config();
-    win_cmd.title = shell_config.title_text;
-    cmd_write("Configuration reloaded.\n");
-    cmd_print_prompt();
-}
-
-static void internal_cmd_cls(char *args) {
-    (void)args;
-    cmd_screen_clear();
-    cursor_row = 0;
-    cursor_col = 0;
-    cmd_print_prompt();
-}
-
-// Command dispatch table
-typedef struct {
-    const char *name;
-    void (*func)(char *args);
-} CommandEntry;
-
-static const CommandEntry commands[] = {
-    {"EXEC", cmd_exec_elf},
-    {"exec", cmd_exec_elf},
-    {"TXTEDIT", internal_cmd_txtedit},
-    {"txtedit", internal_cmd_txtedit},
-    {"EXIT", internal_cmd_exit},
-    {"exit", internal_cmd_exit},
-    {"CD", internal_cmd_cd},
-    {"cd", internal_cmd_cd},
-    {"RELOAD", internal_cmd_reload},
-    {"reload", internal_cmd_reload},
-    {"CLS", internal_cmd_cls},
-    {"cls", internal_cmd_cls},
-    {"CLEAR", internal_cmd_cls},
-    {"clear", internal_cmd_cls},
-    {NULL, NULL}
-};
-
-
-
-
-static void cmd_update_dir(const char *path) {
-    if (!cmd_state || !path) return;
-    
-    const char *p = path;
-    if (*p) {
-        // Remove trailing slashes and copy
-        int len = 0;
-        while (p[len]) len++;
-        while (len > 0 && p[len-1] == '/') len--;
-        
-        if (len == 0) {
-            cmd_state->current_dir[0] = '/';
-            cmd_state->current_dir[1] = 0;
-        } else {
-            for (int i = 0; i < len && i < 255; i++) {
-                cmd_state->current_dir[i] = p[i];
-            }
-            cmd_state->current_dir[len] = 0;
-        }
-    } else {
-        cmd_state->current_dir[0] = '/';
-        cmd_state->current_dir[1] = 0;
-    }
-}
-
-static const char* find_pipe(const char* cmd) {
-    while (*cmd) {
-        if (*cmd == '|' && *(cmd + 1) == '|') {
-            return cmd;
-        }
-        cmd++;
-    }
-    return NULL;
-}
-
-static void cmd_exec_single(char *cmd) {
-    while (*cmd == ' ') cmd++;
-    if (!*cmd) return;
-
-    // Check for drive switch (e.g. "A:", "B:")
-    if (cmd[0] && cmd[1] == ':' && cmd[2] == 0) {
-        cmd_write("Drive letters are no longer supported. Use VFS paths (e.g. /dev/sda1)\n");
-        return;
-    }
-
-    char *args_ptr = cmd;
-    while (*args_ptr && *args_ptr != ' ') {
-        args_ptr++;
-    }
-    char old_char = *args_ptr;
-    *args_ptr = '\0'; // Temporarily terminate to get just the command
-
-    bool is_path = false;
-    char *p = cmd;
-    while(*p) {
-        if (*p == '/' || *p == ':') {
-            is_path = true;
-            break;
-        }
-        p++;
-    }
-
-    if (is_path) {
-        FAT32_FileHandle *fh = fat32_open(cmd, "r");
-        if (fh) {
-            fat32_close(fh);
-            *args_ptr = old_char; // Restore command string
-
-            // Now properly split command and args
-            char *args = cmd;
-            while (*args && *args != ' ') args++;
-            if (*args) {
-                *args = 0; // Null terminate cmd
-                args++; // Point to start of args
-            }
-
-            cmd_is_waiting_for_process = true;
-            process_t *proc = process_create_elf(cmd, args);
-            if (proc) {
-                proc->is_terminal_proc = true;
-                proc->ui_window = &win_cmd;
-            }
-            return;
-        }
-    }
-    
-    *args_ptr = old_char; // Restore command string if not found or not a path
-
-    if (cmd[0] == '.' && cmd[1] == '/') {
-        char *filename = cmd + 2;
-        
-        // Build full path with drive context and current directory
-        char full_exec_path[512];
-        int i = 0;
-        
-        // Add current directory
-        if (cmd_state) {
-            const char *dir = cmd_state->current_dir;
-            while (*dir && i < 509) {
-                full_exec_path[i++] = *dir++;
-            }
-            
-            // Add separator if current dir doesn't end with /
-            if (i > 0 && full_exec_path[i-1] != '/') {
-                full_exec_path[i++] = '/';
-            }
-        }
-        
-        // Add the relative path argument
-        const char *p = filename;
-        while (*p && i < 509) {
-            full_exec_path[i++] = *p++;
-        }
-        full_exec_path[i] = 0;
-        filename = full_exec_path;
-        
-        FAT32_FileHandle *fh = fat32_open(filename, "r");
-        if (fh) {
-
-            uint8_t *buffer = (uint8_t*)kmalloc(VM_MEMORY_SIZE);
-            if (!buffer) {
-                cmd_write("Error: Out of memory.\n");
-                fat32_close(fh);
-                return;
-            }
-
-            int size = fat32_read(fh, buffer, VM_MEMORY_SIZE);
-            fat32_close(fh);
-            
-            if (size > 0) {
-                int res = vm_exec(buffer, size);
-                if (res != 0) {
-                     cmd_write("Execution failed.\n");
-                }
-            } else {
-                cmd_write("Error: Empty file.\n");
-            }
-            kfree(buffer);
-        } else {
-            cmd_write("Error: Command not found or file does not exist.\n");
-        }
-        return;
-    }
-
-    // Split cmd and args
-    char *args = cmd;
-    while (*args && *args != ' ') args++;
-    if (*args) {
-        *args = 0; // Null terminate cmd
-        args++; // Point to start of args
-    }
-
-    // For file system commands, prepend drive context to path args if on different drive
-    // Build full path with drive letter for commands that take paths
-    char full_path_arg[512] = {0};
-    bool is_cd_command = (cmd_strcmp(cmd, "cd") == 0 || cmd_strcmp(cmd, "CD") == 0);
-    bool is_ls_command = (cmd_strcmp(cmd, "ls") == 0 || cmd_strcmp(cmd, "LS") == 0);
-    bool is_echo_command = (cmd_strcmp(cmd, "echo") == 0 || cmd_strcmp(cmd, "ECHO") == 0);
-    
-    if (cmd_state) {
-        // Check if this is a command that takes a path argument
-        bool needs_path = (is_ls_command ||
-                          is_cd_command ||
-                          cmd_strcmp(cmd, "mkdir") == 0 || cmd_strcmp(cmd, "MKDIR") == 0 ||
-                          cmd_strcmp(cmd, "rm") == 0 || cmd_strcmp(cmd, "RM") == 0 ||
-                          cmd_strcmp(cmd, "cat") == 0 || cmd_strcmp(cmd, "CAT") == 0 ||
-                          is_echo_command ||
-                          cmd_strcmp(cmd, "cc") == 0 || cmd_strcmp(cmd, "CC") == 0 ||
-                          cmd_strcmp(cmd, "compc") == 0 || cmd_strcmp(cmd, "COMPC") == 0 ||
-                          cmd_strcmp(cmd, "touch") == 0 || cmd_strcmp(cmd, "TOUCH") == 0 ||
-                          cmd_strcmp(cmd, "cp") == 0 || cmd_strcmp(cmd, "CP") == 0 ||
-                          cmd_strcmp(cmd, "mv") == 0 || cmd_strcmp(cmd, "MV") == 0 ||
-                          cmd_strcmp(cmd, "txtedit") == 0 || cmd_strcmp(cmd, "TXTEDIT") == 0 ||
-                          cmd_strcmp(cmd, "tx") == 0 || cmd_strcmp(cmd, "TX") == 0);
-        
-        if (needs_path) {
-            if (args && args[0]) {
-                if (is_echo_command) {
-                    char temp_args[512] = {0};
-                    int i = 0;
-                    int j = 0;
-                    bool in_redirect = false;
-                    
-                    while (args[i] && j < 509) {
-                        if (args[i] == '>' && args[i+1] == '>') {
-                            // >> redirection
-                            temp_args[j++] = '>';
-                            temp_args[j++] = '>';
-                            i += 2;
-                            while (args[i] == ' ') { temp_args[j++] = ' '; i++; }
-                            
-                            // Prepend directory to filename if relative
-                            if (args[i] && args[i] != '/') {
-                                const char *d = cmd_state->current_dir;
-                                while (*d && j < 509) temp_args[j++] = *d++;
-                                if (j > 0 && temp_args[j-1] != '/') temp_args[j++] = '/';
-                            }
-                            in_redirect = true;
-                        } else if (args[i] == '>' && args[i+1] != '>') {
-                            // > redirection
-                            temp_args[j++] = '>';
-                            i++;
-                            while (args[i] == ' ') { temp_args[j++] = ' '; i++; }
-                            
-                            // Prepend directory to filename if relative
-                            if (args[i] && args[i] != '/') {
-                                const char *d = cmd_state->current_dir;
-                                while (*d && j < 509) temp_args[j++] = *d++;
-                                if (j > 0 && temp_args[j-1] != '/') temp_args[j++] = '/';
-                            }
-                            in_redirect = true;
-                        } else {
-                            temp_args[j++] = args[i++];
-                        }
-                    }
-                    (void)in_redirect;
-                    temp_args[j] = 0;
-                    cmd_strcpy(full_path_arg, temp_args);
-                    args = full_path_arg;
-                } else if (cmd_strcmp(cmd, "cat") == 0 || cmd_strcmp(cmd, "CAT") == 0 ||
-                           cmd_strcmp(cmd, "cc") == 0 || cmd_strcmp(cmd, "CC") == 0 ||
-                           cmd_strcmp(cmd, "compc") == 0 || cmd_strcmp(cmd, "COMPC") == 0 ||
-                           cmd_strcmp(cmd, "touch") == 0 || cmd_strcmp(cmd, "TOUCH") == 0 ||
-                           cmd_strcmp(cmd, "mkdir") == 0 || cmd_strcmp(cmd, "MKDIR") == 0 ||
-                           cmd_strcmp(cmd, "rm") == 0 || cmd_strcmp(cmd, "RM") == 0 ||
-                           cmd_strcmp(cmd, "ls") == 0 || cmd_strcmp(cmd, "LS") == 0 ||
-                           cmd_strcmp(cmd, "cp") == 0 || cmd_strcmp(cmd, "CP") == 0 ||
-                           cmd_strcmp(cmd, "mv") == 0 || cmd_strcmp(cmd, "MV") == 0 ||
-                           cmd_strcmp(cmd, "txtedit") == 0 || cmd_strcmp(cmd, "TXTEDIT") == 0 ||
-                           cmd_strcmp(cmd, "tx") == 0 || cmd_strcmp(cmd, "TX") == 0) {
-                    // For filesystem commands: prepend drive and current directory if relative
-                    if (args[1] == ':') {
-                        // Already has drive letter
-                        cmd_strcpy(full_path_arg, args);
-                    } else if (args[0] == '/') {
-                        // Absolute path
-                        int i = 0;
-                        int j = 0;
-                        while (args[j] && i < 509) {
-                            full_path_arg[i++] = args[j++];
-                        }
-                        full_path_arg[i] = 0;
-                    } else {
-                        // Relative path - need to build from current directory
-                        int i = 0;
-                        
-                        // Add current directory
-                        const char *dir = cmd_state->current_dir;
-                        while (*dir && i < 509) {
-                            full_path_arg[i++] = *dir++;
-                        }
-                        
-                        // Add separator if current dir doesn't end with /
-                        if (i > 0 && full_path_arg[i-1] != '/') {
-                            full_path_arg[i++] = '/';
-                        }
-                        
-                        // Add the relative path argument
-                        int j = 0;
-                        while (args[j] && i < 509) {
-                            full_path_arg[i++] = args[j++];
-                        }
-                        full_path_arg[i] = 0;
-                    }
-                    args = full_path_arg;
-                } else if (is_cd_command) {
-                    // For cd: build full path with drive + current directory + relative path
-                    // Check if args starts with drive letter (e.g., "B:" or "A:")
-                    if (args[1] == ':') {
-                        // Has drive letter, use as-is
-                        cmd_strcpy(full_path_arg, args);
-                    } else if (args[0] == '/') {
-                        // Absolute path
-                        int i = 0;
-                        int j = 0;
-                        while (args[j] && i < 509) {
-                            full_path_arg[i++] = args[j++];
-                        }
-                        full_path_arg[i] = 0;
-                    } else {
-                        // Relative path - need to build from current directory
-                        int i = 0;
-                        
-                        // Add current directory
-                        const char *dir = cmd_state->current_dir;
-                        while (*dir && i < 509) {
-                            full_path_arg[i++] = *dir++;
-                        }
-                        
-                        // Add separator if current dir doesn't end with /
-                        if (i > 0 && full_path_arg[i-1] != '/') {
-                            full_path_arg[i++] = '/';
-                        }
-                        
-                        // Add the relative path argument
-                        int j = 0;
-                        while (args[j] && i < 509) {
-                            full_path_arg[i++] = args[j++];
-                        }
-                        full_path_arg[i] = 0;
-                    }
-                    args = full_path_arg;
-                } else if (args[1] == ':') {
-                    // Already has drive letter
-                    cmd_strcpy(full_path_arg, args);
-                    args = full_path_arg;
-                } else {
-                    // Try to use arg as is (it's either absolute or relative)
-                    // If it's relative, we should actually build it...
-                    // Let's just use it as is for now since later path resolving will catch it
-                    int i = 0;
-                    int j = 0;
-                    while (args[j] && i < 509) {
-                        full_path_arg[i++] = args[j++];
-                    }
-                    full_path_arg[i] = 0;
-                    args = full_path_arg;
-                }
-            } else if (is_ls_command || is_cd_command) {
-                // For ls and cd with no args, pass current directory
-                int i = 0;
-                const char *dir = cmd_state->current_dir;
-                while (*dir && i < 509) {
-                    full_path_arg[i++] = *dir++;
-                }
-                full_path_arg[i] = 0;
-                args = full_path_arg;
-            }
-        }
-    }
-
-    // Use command dispatch table
-    for (int i = 0; commands[i].name != NULL; i++) {
-        if (cmd_strcmp(cmd, commands[i].name) == 0) {
-            commands[i].func(args);
-            return;
-        }
-    }
-
-    // Check for executable in Current Directory or /bin/
-    char search_path[512];
-    
-    // Check if the command already ends in .elf (case insensitive)
-    bool has_elf_ext = false;
-    int cmd_len = cmd_strlen(cmd);
-    if (cmd_len > 4) {
-        const char *ext = cmd + cmd_len - 4;
-        if ((ext[0] == '.' && (ext[1] == 'e' || ext[1] == 'E') && 
-            (ext[2] == 'l' || ext[2] == 'L') && (ext[3] == 'f' || ext[3] == 'F'))) {
-            has_elf_ext = true;
-        }
-    }
-    
-    // 1. Try Current Directory + .elf
-    if (cmd_state) {
-        int idx = 0;
-        const char *dir = cmd_state->current_dir;
-        while (*dir && idx < 500) search_path[idx++] = *dir++;
-        if (idx > 0 && search_path[idx-1] != '/') search_path[idx++] = '/';
-        const char *c = cmd;
-        while (*c && idx < 500) search_path[idx++] = *c++;
-        if (!has_elf_ext) {
-            search_path[idx++] = '.'; search_path[idx++] = 'e'; search_path[idx++] = 'l'; search_path[idx++] = 'f';
-        }
-        search_path[idx] = 0;
-        
-        FAT32_FileHandle *fh = fat32_open(search_path, "r");
-        if (fh) {
-            fat32_close(fh);
-            cmd_is_waiting_for_process = true;
-            process_t *proc = process_create_elf(search_path, args);
-            if (proc) {
-                proc->is_terminal_proc = true;
-                proc->ui_window = &win_cmd;
-            }
-            return;
-        }
-    }
-    
-    // 2. Try /bin/ + .elf
-    {
-        int idx = 0;
-        const char *bin_prefix = "/bin/";
-        while (*bin_prefix) search_path[idx++] = *bin_prefix++;
-        const char *c = cmd;
-        while (*c && idx < 500) search_path[idx++] = *c++;
-        if (!has_elf_ext) {
-            search_path[idx++] = '.'; search_path[idx++] = 'e'; search_path[idx++] = 'l'; search_path[idx++] = 'f';
-        }
-        search_path[idx] = 0;
-        
-        FAT32_FileHandle *fh = fat32_open(search_path, "r");
-        if (fh) {
-            fat32_close(fh);
-            cmd_is_waiting_for_process = true;
-            process_t *proc = process_create_elf(search_path, args);
-            if (proc) {
-                proc->is_terminal_proc = true;
-                proc->ui_window = &win_cmd;
-            }
-            return;
-        }
-    }
-
-
-
-    cmd_write("Unknown command: ");
-    cmd_write(cmd);
-    cmd_write("\n");
-}
-static void cmd_exec(char *cmd, bool print_prompt);
-
-static void handle_pipe_chain(const char* right_cmd, bool print_prompt) {
-    // 1. Trim trailing whitespace from pipe_buffer
-    while (pipe_buffer_pos > 0 && 
-           (pipe_buffer[pipe_buffer_pos-1] == ' ' || 
-            pipe_buffer[pipe_buffer_pos-1] == '\r' || 
-            pipe_buffer[pipe_buffer_pos-1] == '\n')) {
-        pipe_buffer[--pipe_buffer_pos] = '\0';
-    }
-    pipe_buffer[pipe_buffer_pos] = '\0';
-
-    if (pipe_buffer_pos == 0) {
-        cmd_write("Error: Command produced no output to pipe.\n");
-        return;
-    }
-
-    // 2. Wrap in quotes if needed
-    bool needs_quotes = false;
-    if (pipe_buffer[0] != '"' || pipe_buffer[pipe_buffer_pos-1] != '"') {
-        needs_quotes = true;
-    }
-    
-    // 3. Construct the new command
-    char* full_cmd = (char*)kmalloc(9000); 
-    if (!full_cmd) {
-        cmd_write("Error: Out of memory for pipe operation.\n");
-        return;
-    }
-    
-    cmd_strcpy(full_cmd, right_cmd);
-    int len = cmd_strlen(full_cmd);
-    full_cmd[len++] = ' ';
-    if (needs_quotes) full_cmd[len++] = '"';
-    
-    for (int i = 0; i < pipe_buffer_pos && len < 8990; i++) {
-        full_cmd[len++] = pipe_buffer[i];
-    }
-    
-    if (needs_quotes) full_cmd[len++] = '"';
-    full_cmd[len] = '\0';
-    
-    // 4. Recursive execution
-    cmd_exec(full_cmd, print_prompt);
-    
-    kfree(full_cmd);
-}
-
-// Execute command with redirection and pipe support
-static void cmd_exec(char *cmd, bool print_prompt) {
-    // Check for pipe operator first
-    const char* pipe_pos = find_pipe(cmd);
-    if (pipe_pos) {
-        // Handle piped commands
-        char left_cmd[256] = {0};
-        char right_cmd[256] = {0};
-        
-        // Extract left command (before pipe)
-        size_t left_len = pipe_pos - cmd;
-        if (left_len >= sizeof(left_cmd)) left_len = sizeof(left_cmd) - 1;
-        for (size_t j = 0; j < left_len; j++) {
-            left_cmd[j] = cmd[j];
-        }
-        left_cmd[left_len] = '\0';
-        
-        // Trim trailing spaces from left command
-        while (left_len > 0 && left_cmd[left_len - 1] == ' ') {
-            left_cmd[--left_len] = '\0';
-        }
-        
-        // Extract right command (after pipe ||)
-        const char* right_start = pipe_pos + 2;  // Skip both '|' characters
-        while (*right_start == ' ') right_start++;
-        
-        size_t right_len = 0;
-        while (right_start[right_len] && right_len < sizeof(right_cmd) - 1) {
-            right_cmd[right_len] = right_start[right_len];
-            right_len++;
-        }
-        right_cmd[right_len] = '\0';
-        
-        // Trim trailing spaces from right command
-        while (right_len > 0 && right_cmd[right_len - 1] == ' ') {
-            right_cmd[--right_len] = '\0';
-        }
-        
-        // Generalized pipe implementation
-        pipe_buffer_pos = 0;
-        pipe_capture_mode = true;
-        
-        // Execute the left command and capture its output
-        cmd_exec_single(left_cmd);
-        
-        if (cmd_is_waiting_for_process) {
-            // Asynchronous: wait for completion in cmd_process_finished
-            pipe_waiting_for_first = true;
-            cmd_strcpy(pipe_next_command, right_cmd);
-            return;
-        } else {
-            // Synchronous: process immediately
-            pipe_capture_mode = false;
-            handle_pipe_chain(right_cmd, print_prompt);
-            return;
-        }
-    }
-    
-    // Check for redirection operators (> or >>)
-    char *redirect_ptr = NULL;
-    char redirect_op = 0;  // '>' or 'a' for append
-    char output_file[256] = {0};
-    int cmd_len = 0;
-    
-    for (int i = 0; cmd[i]; i++) {
-        if (cmd[i] == '>' && cmd[i+1] == '>') {
-            redirect_ptr = cmd + i + 2;
-            redirect_op = 'a';  // append
-            cmd_len = i;
-            break;
-        } else if (cmd[i] == '>') {
-            redirect_ptr = cmd + i + 1;
-            redirect_op = '>';  // write
-            cmd_len = i;
-            break;
-        }
-    }
-    
-    // If redirection found, set it up
-    if (redirect_ptr) {
-        // Null terminate command
-        cmd[cmd_len] = 0;
-        
-        // Parse output filename
-        int i = 0;
-        while (redirect_ptr[i] && (redirect_ptr[i] == ' ' || redirect_ptr[i] == '\t')) {
-            i++;
-        }
-        
-        int j = 0;
-        while (redirect_ptr[i] && redirect_ptr[i] != ' ' && redirect_ptr[i] != '\t') {
-            output_file[j++] = redirect_ptr[i++];
-        }
-        output_file[j] = 0;
-        
-        if (!output_file[0]) {
-            cmd_write("Error: No output file specified\n");
-            return;
-        }
-        
-        cmd_strcpy(redirect_filename, output_file);
-
-        // Open file for redirection
-        const char *mode = (redirect_op == 'a') ? "a" : "w";
-        redirect_file = fat32_open(output_file, mode);
-        if (!redirect_file) {
-            cmd_write("Error: Cannot open file for redirection\n");
-            return;
-        }
-        
-        redirect_mode = redirect_op;
-    }
-    
-    // Execute the command
-    cmd_exec_single(cmd);
-    
-    // Close redirected file if it was opened
-    // If we started a process, we must NOT close the file yet.
-    // The file will be closed in cmd_process_finished().
-    if (redirect_file && !cmd_is_waiting_for_process) {
-        fat32_close(redirect_file);
-        redirect_file = NULL;
-        redirect_mode = 0;
-        cmd_write("Output redirected to: ");
-        cmd_write(output_file);
-        cmd_write("\n");
-    }
-
-
-    if (print_prompt && !cmd_is_waiting_for_process) {
-        cmd_print_prompt();
-    }
-}
-
-
-// --- Window Functions ---
-
-static void cmd_paint(Window *win) {
-    // Fill background
-    draw_rect(win->x + 4, win->y + 30, win->w - 8, win->h - 34, shell_config.bg_color);
-    
-    int offset_x = win->x + 4;
-    int offset_y = win->y + 24;
-    int start_y = offset_y + 4;
-    int start_x = offset_x + 4;
-
-    if (current_mode == MODE_PAGER) {
-        // Draw Pager Content (Wrapped)
-        for (int i = 0; i < terminal_rows && (pager_top_line + i) < pager_total_lines; i++) {
-            draw_string(start_x, start_y + (i * LINE_HEIGHT), pager_wrapped_lines[pager_top_line + i], shell_config.default_text_color);
-        }
-        
-        // Status Bar
-        // Status Bar
-        draw_string(start_x, start_y + (terminal_rows * LINE_HEIGHT), "-- Press Q to quit --", shell_config.default_text_color);
-    } else {
-        // Draw Cursor
-        if (win->focused && cursor_visible) {
-            draw_rect(start_x + (cursor_col * CHAR_WIDTH), start_y + (cursor_row * LINE_HEIGHT), 
-                      CHAR_WIDTH, LINE_HEIGHT, shell_config.cursor_color);
-        }
-
-        // Draw Shell Buffer
-        for (int r = 0; r < terminal_rows; r++) {
-            for (int c = 0; c < terminal_cols; c++) {
-                CharCell cell = screen_buffer[r * terminal_cols + c];
-                char ch = cell.c;
-                if (ch != 0 && ch != ' ') {
-                    uint32_t fg = cell.color;
-                    uint32_t bg = shell_config.bg_color;
-
-                    if (cell.attrs & 2) { // Reverse
-                        uint32_t tmp = fg;
-                        fg = bg;
-                        bg = tmp;
-                        // Draw background for reversed text
-                        draw_rect(start_x + (c * CHAR_WIDTH), start_y + (r * LINE_HEIGHT), 
-                                  CHAR_WIDTH, LINE_HEIGHT, bg);
-                    }
-
-                    // If cursor is on this character, and cursor color is bright, use background color for char
-                    if (r == cursor_row && c == cursor_col && win->focused && cursor_visible) {
-                        fg = bg; // Character takes background color when cursor is over it
-                    }
-                    
-                    draw_char_bitmap(start_x + (c * CHAR_WIDTH), start_y + (r * LINE_HEIGHT), ch, fg);
-                }
-            }
-        }
-    }
-
-    // Column/Row Indicator in top-right
-    char size_buf[32];
-    itoa(terminal_cols, size_buf);
-    int p = 0; while(size_buf[p]) p++; size_buf[p++] = 'x'; itoa(terminal_rows, size_buf + p);
-    draw_string(win->x + win->w - 80, win->y + 5, size_buf, 0xFFAAAAAA);
-}
-
-void cmd_handle_resize(Window *win, int w, int h) {
-    (void)win;
-    int new_cols = (w - 20) / CHAR_WIDTH;
-    int new_rows = (h - 50) / LINE_HEIGHT;
-    if (new_cols < 20) new_cols = 20;
-    if (new_rows < 5) new_rows = 5;
-
-    if (new_cols == terminal_cols && new_rows == terminal_rows) return;
-
-    CharCell *new_buffer = (CharCell*)kmalloc(new_rows * new_cols * sizeof(CharCell));
-    for (int i = 0; i < new_rows * new_cols; i++) {
-        new_buffer[i].c = ' ';
-        new_buffer[i].color = shell_config.default_text_color;
-    }
-
-    // Reflow Logic: Copy characters and track cursor
-    int new_r = 0;
-    int new_c = 0;
-    int target_cursor_r = 0;
-    int target_cursor_c = 0;
-
-    for (int r = 0; r < terminal_rows; r++) {
-        // Find logical end of this line for copying
-        int last_c = terminal_cols - 1;
-        while (last_c >= 0 && screen_buffer[r * terminal_cols + last_c].c == ' ') last_c--;
-        
-        // If this is the cursor row, we MUST copy up to the cursor col at least
-        if (r == cursor_row) {
-            if (last_c < cursor_col) last_c = cursor_col;
-        }
-
-        for (int c = 0; c <= last_c; c++) {
-            if (r == cursor_row && c == cursor_col) {
-                target_cursor_r = new_r;
-                target_cursor_c = new_c;
-            }
-
-            if (new_c >= new_cols) {
-                new_c = 0;
-                new_r++;
-            }
-            if (new_r < new_rows) {
-                new_buffer[new_r * new_cols + new_c] = screen_buffer[r * terminal_cols + c];
-                new_c++;
-            }
-        }
-
-        // If it was the cursor row, we've found our target position
-        if (r == cursor_row) break;
-
-        // Force newline after each source line if it wasn't a wrap
-        if (last_c < terminal_cols - 1) {
-            new_c = 0;
-            new_r++;
-        }
-    }
-
-    kfree(screen_buffer);
-    screen_buffer = new_buffer;
-    terminal_rows = new_rows;
-    terminal_cols = new_cols;
-    
-    cursor_row = target_cursor_r;
-    cursor_col = target_cursor_c;
-    if (cursor_row >= terminal_rows) cursor_row = terminal_rows - 1;
-    if (cursor_col >= terminal_cols) cursor_col = terminal_cols - 1;
-}
-
-void cmd_handle_click(Window *win, int x, int y) {
-    (void)win;
-    // Basic mouse support: convert pixel to char coords
-    int c = (x - 10) / CHAR_WIDTH;
-    int r = (y - 25) / LINE_HEIGHT;
-    if (r >= 0 && r < terminal_rows && c >= 0 && c < terminal_cols) {
-        // If telnet or other app wants mouse reporting, we'd handle it here
-    }
-}
-
-static void cmd_handle_close(Window *win) {
-    if (!win) return;
-    
-    extern process_t* process_get_by_ui_window(void *win);
-    extern void process_terminate(process_t *proc);
-    
-    // Find any process associated with this terminal window and terminate it
-    process_t *proc = process_get_by_ui_window(win);
-    if (proc) {
-        process_terminate(proc);
-    }
-    
-    win->visible = false;
-}
-
-void cmd_set_raw_mode(bool enabled) {
-    terminal_raw_mode = enabled;
-}
-
-static void cmd_key(Window *target, char c, bool pressed) {
-    if (!pressed) return;
-    (void)target;
-    
-    if (terminal_raw_mode) {
-        // Find the process associated with this terminal and push a key event
-        extern process_t* process_get_by_ui_window(void* win);
-        extern void process_push_gui_event(process_t *proc, gui_event_t *ev);
-        process_t *proc = process_get_by_ui_window(&win_cmd);
-        if (proc && proc->is_terminal_proc) {
-            gui_event_t ev;
-            ev.type = GUI_EVENT_KEY;
-            ev.arg1 = c;
-            process_push_gui_event(proc, &ev);
-            return;
-        }
-    }
-
-    if (current_mode == MODE_PAGER) {
-        if (c == 'q' || c == 'Q') {
-            current_mode = MODE_SHELL;
-        } else if (c == 17) { // UP
-            if (pager_top_line > 0) pager_top_line--;
-        } else if (c == 18) { // DOWN
-            if (pager_top_line < pager_total_lines - terminal_rows) pager_top_line++;
-        }
-        return;
-    }
-
-    // Shell Mode
-     if (c == '\n') { // Enter
-          char cmd_buf[512]; // Use a fixed large enough buffer or dynamic
-          int len = 0;
-          int prompt_len = current_prompt_len;
-          
-          for (int i = prompt_len; i < terminal_cols; i++) {
-              char ch = screen_buffer[cursor_row * terminal_cols + i].c;
-              if (ch == 0 || (ch == ' ' && i > prompt_len && (i + 1 < terminal_cols) && screen_buffer[cursor_row * terminal_cols + i + 1].c == 0)) break;
-              if (len < 511) cmd_buf[len++] = ch;
-          }
-          while (len > 0 && cmd_buf[len-1] == ' ') len--;
-          cmd_buf[len] = 0;
-
-         cmd_putchar('\n');
-         current_color = shell_config.default_text_color;
-         
-         if (len > 0) cmd_history_add(cmd_buf);
-         history_pos = -1;
-         
-         cmd_exec(cmd_buf, true);
-         
-         if (!cmd_is_waiting_for_process) {
-             // cmd_print_prompt(); // This is now handled by cmd_exec
-         }
-    } else if (c == 17) { // UP
-        if (history_len > 0) {
-            if (history_pos == -1) {
-                // Save current line
-                int len = 0;
-                int prompt_len = current_prompt_len;
-                for (int i = prompt_len; i < terminal_cols; i++) {
-                    char ch = screen_buffer[cursor_row * terminal_cols + i].c;
-                    if (ch == 0 || (ch == ' ' && i > prompt_len && (i + 1 < terminal_cols) && screen_buffer[cursor_row * terminal_cols + i + 1].c == 0)) break;
-                    history_save_buf[len++] = ch;
-                }
-                while (len > 0 && history_save_buf[len-1] == ' ') len--;
-                history_save_buf[len] = 0;
-                
-                history_pos = (history_head - 1 + HISTORY_MAX) % HISTORY_MAX;
-            } else {
-                int oldest = (history_head - history_len + HISTORY_MAX) % HISTORY_MAX;
-                if (history_pos != oldest) {
-                    history_pos = (history_pos - 1 + HISTORY_MAX) % HISTORY_MAX;
-                }
-            }
-            cmd_set_line_content(cmd_history[history_pos]);
-        }
-    } else if (c == 18) { // DOWN
-        if (history_pos != -1) {
-            int newest = (history_head - 1 + HISTORY_MAX) % HISTORY_MAX;
-            if (history_pos == newest) {
-                history_pos = -1;
-                cmd_set_line_content(history_save_buf);
-            } else {
-                history_pos = (history_pos + 1) % HISTORY_MAX;
-                cmd_set_line_content(cmd_history[history_pos]);
-            }
-        }
-    } else if (c == 19) { // LEFT
-        if (cursor_col > current_prompt_len) {
-            cursor_col--;
-        }
-    } else if (c == 20) { // RIGHT
-        if (cursor_col < terminal_cols - 1) {
-            cursor_col++;
-        }
-    } else if (c == '\b') { // Backspace
-         if (cursor_col > current_prompt_len) {
-             // Shift characters to the left
-             for (int i = cursor_col; i < terminal_cols; i++) {
-                 screen_buffer[cursor_row * terminal_cols + i - 1] = screen_buffer[cursor_row * terminal_cols + i];
-             }
-             screen_buffer[cursor_row * terminal_cols + terminal_cols - 1].c = ' ';
-             cursor_col--;
-             wm_mark_dirty(win_cmd.x, win_cmd.y, win_cmd.w, win_cmd.h);
-         }
-    } else {
-        if (c >= 32 && c <= 126) {
-            // Shift characters to the right
-            for (int i = terminal_cols - 1; i > cursor_col; i--) {
-                screen_buffer[cursor_row * terminal_cols + i] = screen_buffer[cursor_row * terminal_cols + i - 1];
-            }
-            screen_buffer[cursor_row * terminal_cols + cursor_col].c = c;
-            screen_buffer[cursor_row * terminal_cols + cursor_col].color = current_color;
-            cursor_col++;
-            wm_mark_dirty(win_cmd.x, win_cmd.y, win_cmd.w, win_cmd.h);
-        }
-    }
-}
-
-static void cmd_exec(char *cmd, bool print_prompt);
-
-void cmd_reset(void) {
-    // Reset terminal to fresh state
-    cmd_screen_clear();
-    cmd_load_config();
-    
-    cursor_row = 0;
-    cursor_col = 0;
-    current_color = shell_config.default_text_color;
-    win_cmd.title = shell_config.title_text;
-    
-    if (shell_config.welcome_msg) {
-        if (shell_config.custom_welcome_message[0]) {
-            cmd_write(shell_config.custom_welcome_message);
-            cmd_putchar('\n');
-        } else {
-            cmd_write("BoredOS Command Prompt\n");
-        }
-    }
-    
-    if (shell_config.startup_cmd[0]) {
-        cmd_exec(shell_config.startup_cmd, false);
-    }
-
-    // If a startup command is running, it will print the prompt when it's done.
-    // Otherwise, we print it now.
-    if (!cmd_is_waiting_for_process) {
-        cmd_print_prompt();
-    }
-}
-
-static void create_ramfs_files(void) {
-    if (!fat32_exists("root")) fat32_mkdir("root");
-    if (!fat32_exists("root/Documents")) fat32_mkdir("root/Documents");
-    if (!fat32_exists("root/Documents/Important")) fat32_mkdir("root/Documents/Important");
-    if (!fat32_exists("root/Apps")) fat32_mkdir("root/Apps");
-    if (!fat32_exists("root/Desktop")) fat32_mkdir("root/Desktop");
-    if (!fat32_exists("root/projects")) fat32_mkdir("root/projects");
-    if (!fat32_exists("RecycleBin")) fat32_mkdir("RecycleBin");
-    if (!fat32_exists("Library/conf")) fat32_mkdir("Library/conf");
-
-    // Create default shell configuration file (commented out)
-    if (!fat32_exists("Library/conf/shell.cfg")) {
-        FAT32_FileHandle *cfg = fat32_open("Library/conf/shell.cfg", "w");
-        if (cfg) {
-            const char *config_content = 
-                "// BoredOS Shell Configuration\n"
-                "// Colors: HEX (#RRGGBB), RGB (rgb(r,g,b)), or Names (red, blue, light blue, etc.)\n"
-                "// ---------------------------------------------------------------------------\n"
-                "// prompt_drive_color=white\n"
-                "// prompt_colon_color=gray\n"
-                "// prompt_dir_color=light blue\n"
-                "// prompt_op_color=white\n"
-                "// prompt_op_char=>\n"
-                "// prompt_suffix= \n"
-                "// default_text_color=light gray\n"
-                "// command_color=white\n"
-                "// bg_color=#1E1E1E\n"
-                "// cursor_color=white\n"
-                "// title_text=Command Prompt\n"
-                "// custom_welcome_message=\n"
-                "// startup_cmd=\n"
-                "// welcome_msg=true\n"
-                "// show_drive=true\n"
-                "// show_dir=true\n"
-                "// dir_color=light blue\n"
-                "// file_color=white\n"
-                "// size_color=light green\n"
-                "// error_color=light red\n"
-                "// success_color=light green\n"
-                "// help_color=light gray\n"
-                "// history_save_prompt=true\n";
-            fat32_write(cfg, (void *)config_content, cmd_strlen(config_content)); 
-            fat32_close(cfg);
-        }
-    }
-
-    // Create default sysfetch configuration file
-    if (!fat32_exists("Library/conf/sysfetch.cfg")) {
-        FAT32_FileHandle *cfg = fat32_open("Library/conf/sysfetch.cfg", "w");
-        if (cfg) {
-            const char *config_content =
-                "// BoredOS System Fetch Configuration\n"
-                "// ----------------------------------\n"
-                "// To use custom ascii art, uncomment the line below and point it to your file.\n"
-                "ascii_art_file=/Library/art/boredos.txt\n"
-                "user_host_string=root@boredos\n"
-                "separator=------------\n"
-                "\n"
-                "// Labels (leave empty to hide a line)\n"
-                "os_label=OS\n"
-                "kernel_label=Kernel\n"
-                "uptime_label=Uptime\n"
-                "shell_label=Shell\n"
-                "memory_label=Memory\n";
-            fat32_write(cfg, (void *)config_content, cmd_strlen(config_content));
-            fat32_close(cfg);
-        }
-    }
-
-    // Create default art directory and file
-    if (!fat32_exists("Library/art")) {
-        fat32_mkdir("Library/art");
-    }
-    if (!fat32_exists("Library/art/boredos.txt")) {
-        FAT32_FileHandle *art = fat32_open("Library/art/boredos.txt", "w");
-        if (art) {
-            const char *art_content =
-                "\033[35m==================== \033[97m__    ____  ____ \033[0m\n"
-                "\033[35m=================== \033[97m/ /_  / __ \\/ ___\\\033[0m\n"
-                "\033[34m================== \033[97m/ __ \\/ / / /\\___ \\\033[0m\n"
-                "\033[34m================= \033[97m/ /_/ / /_/ /____/ /\033[0m\n"
-                "\033[36m================ \033[97m/_.___/\\____//_____/ \033[0m\n"
-                "\033[36m===============                       \033[0m\n";
-            fat32_write(art, (void *)art_content, cmd_strlen(art_content));
-            fat32_close(art);
-        }
-    }
-
-    
-  
-    FAT32_FileHandle *fh = fat32_open("root/Apps/README.md", "w");
-    if (fh) {
-        const char *content = 
-            "# All compiled C files in this directory are openable from any other directory by typing in the name of the compiled file by typing in the name of the compiled file.\n\n"            
-            "The c file 'wordofgod.c' contains a C program similar to one in TempleOS, which Terry A. Davis (RIP) saw as 'words from god' telling him what to do with his kernel.\n"
-            "I made this file as a tribute to him, as he also inspired me to create this project in '24. If you want to run it you simply do cc (or compc) wordofgod.c and then run ./wordofgod \n";
-        fat32_write(fh, (void *)content, cmd_strlen(content));
-        fat32_close(fh);
-    }    
-    
-    fh = fat32_open("root/Documents/notes.txt", "w");
-    if (fh) {
-        const char *content = "My Notes\n\n- First note\n- Second note\n";
-        fat32_write(fh, (void *)content, 39);
-        fat32_close(fh);
-    }
-    
-    fh = fat32_open("root/projects/project1.txt", "w");
-    if (fh) {
-        const char *content = "Project 1\n\nStatus: In Progress\n";
-        fat32_write(fh, (void *)content, 32);
-        fat32_close(fh);
-    }
-
-    fat32_open("root/Desktop/Recycle Bin.shortcut", "w");
-
-    
-    fh = fat32_open("root/Apps/wordofgod.c", "w");
-    if (fh) {
-        // Buffer the entire file content to write in one go
-        // This prevents issues with multiple small writes causing truncation
-        char *buf = (char*)kmalloc(8192);
-        if (buf) {
-            int p = 0;
-            const char *strs[] = {
-                "int main(){int l;l=malloc(1200);",
-                "poke(l+0,\"In \");poke(l+4,\"the \");poke(l+8,\"beginning \");poke(l+12,\"God \");poke(l+16,\"created \");poke(l+20,\"heaven \");poke(l+24,\"and \");poke(l+28,\"earth \");poke(l+32,\"light \");poke(l+36,\"darkness \");",
-                "poke(l+40,\"day \");poke(l+44,\"night \");poke(l+48,\"waters \");poke(l+52,\"firmament \");poke(l+56,\"evening \");poke(l+60,\"morning \");poke(l+64,\"land \");poke(l+68,\"seas \");poke(l+72,\"grass \");poke(l+76,\"herb \");",
-                "poke(l+80,\"seed \");poke(l+84,\"fruit \");poke(l+88,\"tree \");poke(l+92,\"sun \");poke(l+96,\"moon \");poke(l+100,\"stars \");poke(l+104,\"signs \");poke(l+108,\"seasons \");poke(l+112,\"days \");poke(l+116,\"years \");",
-                "poke(l+120,\"creature \");poke(l+124,\"life \");poke(l+128,\"fowl \");poke(l+132,\"whales \");poke(l+136,\"cattle \");poke(l+140,\"creeping \");poke(l+144,\"beast \");poke(l+148,\"man \");poke(l+152,\"image \");poke(l+156,\"likeness \");",
-                "poke(l+160,\"dominion \");poke(l+164,\"fish \");poke(l+168,\"air \");poke(l+172,\"every \");poke(l+176,\"CIA \");poke(l+180,\"Epstein Files \");poke(l+184,\"holy \");poke(l+188,\"rest \");poke(l+192,\"dust \");poke(l+196,\"breath \");",
-                "poke(l+200,\"soul \");poke(l+204,\"garden \");poke(l+208,\"east \");poke(l+212,\"Eden \");poke(l+216,\"ground \");poke(l+220,\"sight \");poke(l+224,\"good \");poke(l+228,\"evil \");poke(l+232,\"river \");poke(l+236,\"gold \");",
-                "poke(l+240,\"stone \");poke(l+244,\"woman \");poke(l+248,\"wife \");poke(l+252,\"flesh \");poke(l+256,\"bone \");poke(l+260,\"naked \");poke(l+264,\"serpent \");poke(l+268,\"subtle \");poke(l+272,\"eat \");poke(l+276,\"eyes \");",
-                "poke(l+280,\"wise \");poke(l+284,\"cool \");poke(l+288,\"voice \");poke(l+292,\"fear \");poke(l+296,\"hid \");poke(l+300,\"cursed \");poke(l+304,\"belly \");poke(l+308,\"enmity \");poke(l+312,\"sorrow \");poke(l+316,\"conception \");",
-                "poke(l+320,\"children \");poke(l+324,\"desire \");poke(l+328,\"husband \");poke(l+332,\"lava \");poke(l+336,\"thistles \");poke(l+340,\"sweat \");poke(l+344,\"bread \");poke(l+348,\"mother \");poke(l+352,\"skin \");poke(l+356,\"coats \");",
-                "poke(l+360,\"cherubims \");poke(l+364,\"sword \");poke(l+368,\"gate \");poke(l+372,\"offering \");poke(l+376,\"obsidian \");poke(l+380,\"sin \");poke(l+384,\"door \");poke(l+388,\"blood \");poke(l+392,\"brother \");poke(l+396,\"keeper \");",
-                "poke(l+400,\"voice \");poke(l+404,\"heard \");poke(l+408,\"walking \");poke(l+412,\"cool \");poke(l+416,\"day \");poke(l+420,\"where \");poke(l+424,\"art \");poke(l+428,\"thou \");poke(l+432,\"told \");poke(l+436,\"thee \");",
-                "poke(l+440,\"hast \");poke(l+444,\"eaten \");poke(l+448,\"tree \");poke(l+452,\"minecraft \");poke(l+456,\"commanded \");poke(l+460,\"shouldest \");poke(l+464,\"not \");poke(l+468,\"eat \");poke(l+472,\"gave \");poke(l+476,\"me \");",
-                "poke(l+480,\"beguiled \");poke(l+484,\"belly \");poke(l+488,\"go \");poke(l+492,\"dust \");poke(l+496,\"shalt \");poke(l+500,\"eat \");poke(l+504,\"days \");poke(l+508,\"life \");poke(l+512,\"put \");poke(l+516,\"enmity \");",
-                "poke(l+520,\"between \");poke(l+524,\"seed \");poke(l+528,\"ICE \");poke(l+532,\"Detainment Facility \");poke(l+536,\"heel \");poke(l+540,\"multiply \");poke(l+544,\"sorrow \");poke(l+548,\"conception \");poke(l+552,\"forth \");poke(l+556,\"children \");",
-                "poke(l+560,\"desire \");poke(l+564,\"rule \");poke(l+568,\"over \");poke(l+572,\"sake \");poke(l+576,\"sweat \");poke(l+580,\"face \");poke(l+584,\"till \");poke(l+588,\"return \");poke(l+592,\"ground \");poke(l+596,\"taken \");",
-                "poke(l+600,\"mother \");poke(l+604,\"living \");poke(l+608,\"coats \");poke(l+612,\"skins \");poke(l+616,\"clothed \");poke(l+620,\"become \");poke(l+624,\"one \");poke(l+628,\"us \");poke(l+632,\"know \");poke(l+636,\"good \");",
-                "poke(l+640,\"evil \");poke(l+644,\"lest \");poke(l+648,\"put \");poke(l+652,\"hand \");poke(l+656,\"take \");poke(l+660,\"live \");poke(l+664,\"ever \");poke(l+668,\"sent \");poke(l+672,\"garden \");poke(l+676,\"eden \");",
-                "poke(l+680,\"flaming \");poke(l+684,\"sword \");poke(l+688,\"turned \");poke(l+692,\"way \");poke(l+696,\"knew \");poke(l+700,\"conceived \");poke(l+704,\"bare \");poke(l+708,\"cain \");poke(l+712,\"said \");poke(l+716,\"gotten \");",
-                "poke(l+720,\"lord \");poke(l+724,\"again \");poke(l+728,\"abel \");poke(l+732,\"sheep \");poke(l+736,\"tiller \");poke(l+740,\"process \");poke(l+744,\"time \");poke(l+748,\"pass \");poke(l+752,\"brought \");poke(l+756,\"fruit \");",
-                "poke(l+760,\"offering \");poke(l+764,\"firstlings \");poke(l+768,\"flock \");poke(l+772,\"fat \");poke(l+776,\"thereof \");poke(l+780,\"respect \");poke(l+784,\"wroth \");poke(l+788,\"countenance \");poke(l+792,\"fallen \");poke(l+796,\"well \");",
-                "poke(l+800,\"accepted \");poke(l+804,\"not \");poke(l+808,\"sin \");poke(l+812,\"lieth \");poke(l+816,\"door \");poke(l+820,\"unto \");poke(l+824,\"rule \");poke(l+828,\"talked \");poke(l+832,\"field \");poke(l+836,\"rose \");",
-                "poke(l+840,\"slew \");poke(l+844,\"done \");poke(l+848,\"crieth \");poke(l+852,\"mouth \");poke(l+856,\"receive \");poke(l+860,\"strength \");poke(l+864,\"fugitive \");poke(l+868,\"vagabond \");poke(l+872,\"punishment \");poke(l+876,\"greater \");",
-                "poke(l+880,\"bear \");poke(l+884,\"driven \");poke(l+888,\"hid \");poke(l+892,\"findeth \");poke(l+896,\"slay \");poke(l+900,\"vengeance \");poke(l+904,\"sevenfold \");poke(l+908,\"mark \");poke(l+912,\"finding \");poke(l+916,\"kill \");",
-                "poke(l+920,\"presence \");poke(l+924,\"dwelt \");poke(l+928,\"nod \");poke(l+932,\"enoch \");poke(l+936,\"city \");poke(l+940,\"irad \");poke(l+944,\"mehujael \");poke(l+948,\"methusael \");poke(l+952,\"lamech \");poke(l+956,\"adah \");",
-                "poke(l+960,\"zillah \");poke(l+964,\"jabal \");poke(l+968,\"tent \");poke(l+972,\"cattle \");poke(l+976,\"jubal \");poke(l+980,\"harp \");poke(l+984,\"organ \");poke(l+988,\"tubalcain \");poke(l+992,\"brass \");poke(l+996,\"iron \");",
-                "poke(l+1000,\"naamah \");poke(l+1004,\"wives \");poke(l+1008,\"hear \");poke(l+1012,\"speech \");poke(l+1016,\"hearken \");poke(l+1020,\"young \");poke(l+1024,\"hurt \");poke(l+1028,\"wounding \");poke(l+1032,\"avenged \");poke(l+1036,\"seventy \");",
-                "poke(l+1040,\"seth \");poke(l+1044,\"appointed \");poke(l+1048,\"enos \");poke(l+1052,\"began \");poke(l+1056,\"call \");poke(l+1060,\"name \");poke(l+1064,\"generations \");poke(l+1068,\"adam \");poke(l+1072,\"likeness \");poke(l+1076,\"blessed \");",
-                "poke(l+1080,\"begat \");poke(l+1084,\"sons \");poke(l+1088,\"daughters \");poke(l+1092,\"lived \");poke(l+1096,\"died \");poke(l+1100,\"cainan \");poke(l+1104,\"mahalaleel \");poke(l+1108,\"jared \");poke(l+1112,\"walked \");poke(l+1116,\"three \");",
-                "poke(l+1120,\"hundred \");poke(l+1124,\"sixty \");poke(l+1128,\"five \");poke(l+1132,\"methuselah \");poke(l+1136,\"lamech \");poke(l+1140,\"noah \");poke(l+1144,\"comfort \");poke(l+1148,\"work \");poke(l+1152,\"toil \");poke(l+1156,\"hands \");",
-                "poke(l+1160,\"shem \");poke(l+1164,\"ham \");poke(l+1168,\"japheth \");poke(l+1172,\"men \");poke(l+1176,\"daughters \");poke(l+1180,\"born \");poke(l+1184,\"fair \");poke(l+1188,\"chose \");poke(l+1192,\"spirit \");poke(l+1196,\"strive \");",
-                "int c;int r;r=abs(rand());r=r-(r/5)*5;c=14+r;int i;i=0;while(i<c){int x;x=abs(rand());x=x-(x/300)*300;int w;w=peek(l+x*4);print_str(w);i=i+1;}nl();}",
-                NULL
-            };
-            
-            for (int i = 0; strs[i]; i++) {
-                const char *s = strs[i];
-                while (*s && p < 8191) buf[p++] = *s++;
-            }
-            
-            fat32_write(fh, buf, p);
-            kfree(buf);
-        }
-        fat32_close(fh);
-    }
-}
-
-
-
-void cmd_init(void) {
-    cmd_init_config_defaults();
-    create_ramfs_files();
-    create_man_entries();
-    
-    // Load config after files are created
-    cmd_load_config();
-
-    // Default sizes
-    terminal_cols = DEFAULT_CMD_COLS;
-    terminal_rows = DEFAULT_CMD_ROWS;
-    
-    // Allocate screen buffer
-    screen_buffer = (CharCell*)kmalloc(terminal_cols * terminal_rows * sizeof(CharCell));
-
-    win_cmd.title = shell_config.title_text;
-    win_cmd.x = 50;
-    win_cmd.y = 50;
-    win_cmd.w = (terminal_cols * CHAR_WIDTH) + 20; 
-    win_cmd.h = (terminal_rows * LINE_HEIGHT) + 50;
-    
-    win_cmd.visible = false;
-    win_cmd.focused = false;
-    win_cmd.z_index = 0;
-    win_cmd.paint = cmd_paint;
-    win_cmd.handle_key = cmd_key;
-    win_cmd.handle_click = cmd_handle_click;
-    win_cmd.handle_right_click = NULL;
-    win_cmd.handle_close = cmd_handle_close;
-    win_cmd.handle_resize = cmd_handle_resize;
-    win_cmd.resizable = true;
-    
-    // Initialize cmd state (per-window context)
-    CmdState *state = (CmdState*)kmalloc(sizeof(CmdState));
-    if (state) {
-        
-        state->current_dir[0] = '/';
-        state->current_dir[1] = 'r';
-        state->current_dir[2] = 'o';
-        state->current_dir[3] = 'o';
-        state->current_dir[4] = 't';
-        state->current_dir[5] = 0;
-        win_cmd.data = state;
-        cmd_state = state;  // Set static pointer
-    }
-    
-    cmd_reset();
-    
-    if (!boot_time_init) {
-        rtc_get_datetime(&boot_year, &boot_month, &boot_day, &boot_hour, &boot_min, &boot_sec);
-        boot_time_init = 1;
-    }
-}
diff --git a/src/wm/explorer.c b/src/wm/explorer.c
index 6ba831a..6bb829b 100644
--- a/src/wm/explorer.c
+++ b/src/wm/explorer.c
@@ -9,7 +9,6 @@
 #include "disk.h"
 #include "wm.h"
 #include "memory_manager.h"
-#include "cmd.h"
 #include "process.h"
 #define EXPLORER_ITEM_HEIGHT 80
 #define EXPLORER_ITEM_WIDTH 120
@@ -848,7 +847,7 @@ static void explorer_open_item(Window *win, int index) {
         } else if (explorer_strcmp(state->items[index].name, "Calculator.shortcut") == 0) {
             process_create_elf("/bin/calculator.elf", NULL); return;
         } else if (explorer_strcmp(state->items[index].name, "Terminal.shortcut") == 0) {
-            target = &win_cmd; cmd_reset();
+            process_create_elf("/bin/terminal.elf", NULL); return;
         } else if (explorer_strcmp(state->items[index].name, "Minesweeper.shortcut") == 0) {
             process_create_elf("/bin/minesweeper.elf", NULL); return;
         } else if (explorer_strcmp(state->items[index].name, "Control Panel.shortcut") == 0 || explorer_strcmp(state->items[index].name, "Settings.shortcut") == 0) {
diff --git a/src/wm/explorer.h b/src/wm/explorer.h
index e6a1997..c161c29 100644
--- a/src/wm/explorer.h
+++ b/src/wm/explorer.h
@@ -12,7 +12,6 @@
 // External windows references (for opening other apps)
 extern Window win_explorer;
 extern Window win_editor;
-extern Window win_cmd;
 extern Window win_notepad;
 extern Window win_markdown;
 
diff --git a/src/wm/wm.c b/src/wm/wm.c
index 0a21455..825e4b4 100644
--- a/src/wm/wm.c
+++ b/src/wm/wm.c
@@ -4,7 +4,6 @@
 #include "wm.h"
 #include "graphics.h"
 #include "io.h"
-#include "cmd.h"
 #include "process.h"
 #include "syscall.h"
 #include "kutils.h"
@@ -2485,7 +2484,7 @@ static void wm_handle_mouse_internal(int dx, int dy, uint8_t buttons, int dz) {
                 if (existing) wm_bring_to_front_locked(existing);
                 else process_create_elf("/bin/boredword.elf", NULL);
             } else if (str_starts_with(start_menu_pending_app, "Terminal")) {
-                cmd_reset(); wm_bring_to_front_locked(&win_cmd);
+                process_create_elf("/bin/terminal.elf", NULL);
             } else if (str_starts_with(start_menu_pending_app, "Grapher")) {
                 Window *existing = wm_find_window_by_title_locked("Grapher");
                 if (existing) wm_bring_to_front_locked(existing);
@@ -2550,7 +2549,7 @@ static void wm_handle_mouse_internal(int dx, int dy, uint8_t buttons, int dz) {
                     } else if (str_ends_with(icon->name, "Settings.shortcut")) {
                         process_create_elf("/bin/settings.elf", NULL); handled = true;
                     } else if (str_ends_with(icon->name, "Terminal.shortcut")) {
-                        wm_bring_to_front_locked(&win_cmd); handled = true;
+                        process_create_elf("/bin/terminal.elf", NULL); handled = true;
                     } else if (str_ends_with(icon->name, "About.shortcut")) {
                         process_create_elf("/bin/about.elf", NULL); handled = true;
                     } else if (str_ends_with(icon->name, "Files.shortcut")) {
@@ -3104,9 +3103,6 @@ void wm_init(void) {
     disk_manager_scan();
     log_ok("Disk scanning complete");
 
-    cmd_init();
-    log_ok("Command CLI ready");
-    
     explorer_init();
     log_ok("Explorer ready");
     
@@ -3128,19 +3124,15 @@ void wm_init(void) {
     log_ok("Desktop icons refreshed");
     
     // Initialize z-indices
-    win_cmd.z_index = 0;
     win_explorer.z_index = 1;
-    
-    all_windows[0] = &win_cmd;
-    all_windows[1] = &win_explorer;
-    window_count = 2;
+
+    all_windows[0] = &win_explorer;
+    window_count = 1;
     
     win_explorer.visible = false;
     win_explorer.focused = false;
     win_explorer.z_index = 10;
     
-    win_cmd.visible = false;
-    
     force_redraw = true;
 
     serial_write("[WM] Initialization complete, transitioning to GUI\n");