mos-tui 1.0.2 → 1.0.3

package/core/mos_tui.py

@@ -1,91 +1,116 @@
 #!/usr/bin/env python3
 """
 MOS Terminal UI — Multiprogramming OS Simulator
-Run: python3 mos_tui.py
-Compiles OS_CP.c and provides a full curses TUI.
+Run: python3 mos_tui.py  (from the folder containing OS_CP.c)
 """
 
 import curses
-import curses.textpad
 import subprocess
 import tempfile
 import os
-import sys
 import time
-import textwrap
 import threading
-
-# ── COLORS (pair indices) ─────────────────────────────────────────────────────
-C_NORMAL   = 1   # white on black
-C_BORDER   = 2   # cyan on black
-C_TITLE    = 3   # cyan bold
-C_GREEN    = 4   # green on black
-C_YELLOW   = 5   # yellow on black
-C_RED      = 6   # red on black
-C_DIM      = 7   # dim white
-C_HEADER   = 8   # black on cyan
-C_INPUT    = 9   # green on black (input text)
-C_ORANGE   = 10  # yellow bright (used for EXEC tags)
-C_STAT_VAL = 11  # cyan bold for stat values
-
-# Locate OS_CP.c by searching:
-#   1. Directory explicitly set via MOS_SOURCE env var
-#   2. Current working directory
-#   3. Walk UP from cwd (handles npm package subdirectory installs)
-#   4. Walk UP from script location
+import shutil
+
+# ── COLORS ────────────────────────────────────────────────────────────────────
+C_NORMAL   = 1
+C_BORDER   = 2
+C_TITLE    = 3
+C_GREEN    = 4
+C_YELLOW   = 5
+C_RED      = 6
+C_DIM      = 7
+C_HEADER   = 8
+C_INPUT    = 9
+C_ORANGE   = 10
+C_MAGENTA  = 11
+C_BLUE     = 12
+
+C_MEM_EMPTY = C_DIM
+C_MEM_INSTR = C_BORDER
+C_MEM_DATA  = C_GREEN
+C_MEM_IC    = C_YELLOW
+
+# ── SOURCE LOCATION ───────────────────────────────────────────────────────────
 def _find_source():
-    # Env override — highest priority
     env_src = os.environ.get("MOS_SOURCE")
     if env_src and os.path.exists(env_src):
         return os.path.abspath(env_src)
-
-    # Search upward from cwd
-    search = os.getcwd()
-    for _ in range(6):
-        candidate = os.path.join(search, "OS_CP.c")
-        if os.path.exists(candidate):
-            return candidate
-        parent = os.path.dirname(search)
-        if parent == search:
-            break
-        search = parent
-
-    # Search upward from script location
-    search = os.path.dirname(os.path.abspath(__file__))
-    for _ in range(6):
-        candidate = os.path.join(search, "OS_CP.c")
-        if os.path.exists(candidate):
-            return candidate
-        parent = os.path.dirname(search)
-        if parent == search:
-            break
-        search = parent
-
-    # Fallback — cwd (will show a clear error)
+    for base in [os.getcwd(), os.path.dirname(os.path.abspath(__file__))]:
+        search = base
+        for _ in range(6):
+            c = os.path.join(search, "OS_CP.c")
+            if os.path.exists(c):
+                return c
+            parent = os.path.dirname(search)
+            if parent == search:
+                break
+            search = parent
     return os.path.join(os.getcwd(), "OS_CP.c")
 
 SOURCE = _find_source()
-_CWD   = os.path.dirname(SOURCE)   # always the folder that contains OS_CP.c
+_CWD   = os.path.dirname(SOURCE)
 BINARY = os.path.join(_CWD, "mos_bin")
 
+# ── MEMORY SNAPSHOT ───────────────────────────────────────────────────────────
+class MemSnapshot:
+    def __init__(self):
+        self.cells  = [('    ', 'E')] * 100
+        self.ic     = 0
+        self.c_reg  = 0
+        self.si     = 0
+        self.ir     = '    '
+        self.r_reg  = '    '
+        self.loaded = False
+
+    def parse(self, dump_text):
+        self.cells  = [('    ', 'E')] * 100
+        self.loaded = False
+        for line in dump_text.splitlines():
+            line = line.strip()
+            if not line:
+                continue
+            parts = line.split('|')
+            if parts[0] == 'REG':
+                for kv in parts[1:]:
+                    if '=' in kv:
+                        k, v = kv.split('=', 1)
+                        if   k == 'IC': self.ic    = int(v)
+                        elif k == 'C':  self.c_reg = int(v)
+                        elif k == 'SI': self.si    = int(v)
+                        elif k == 'IR': self.ir    = v.strip()
+                        elif k == 'R':  self.r_reg = v.strip()
+            elif len(parts) == 3:
+                try:
+                    addr = int(parts[0])
+                    content = parts[1]
+                    typ  = parts[2]
+                    if 0 <= addr < 100:
+                        self.cells[addr] = (content, typ)
+                except ValueError:
+                    pass
+        self.loaded = True
+
 # ── STATE ─────────────────────────────────────────────────────────────────────
 class State:
     def __init__(self):
-        self.input_lines   = []          # lines in input editor
-        self.input_cursor  = [0, 0]      # [row, col]
-        self.debug_lines   = []          # (tag, msg) tuples
-        self.output_lines  = []          # strings
-        self.run_history   = []          # (label, ms) for chart
+        self.input_lines   = []
+        self.input_cursor  = [0, 0]
+        self.debug_lines   = []
+        self.output_lines  = []
+        self.run_history   = []
         self.run_count     = 0
         self.status        = "READY"
         self.compiled      = False
-        self.compile_error = ""
         self.exec_time_ms  = None
-        self.focus         = 0           # 0=input, 1=debug, 2=output, 3=chart
+        self.focus         = 0
         self.input_scroll  = 0
         self.debug_scroll  = 0
         self.output_scroll = 0
+        self.mem_scroll    = 0
+        self.mem_view      = 'grid'
         self.lock          = threading.Lock()
+        self.memory        = MemSnapshot()
 
     def add_debug(self, tag, msg):
         ts = time.strftime("%H:%M:%S")
@@ -101,144 +126,193 @@ state = State()
 # ── COMPILE ───────────────────────────────────────────────────────────────────
 def compile_source():
     if not os.path.exists(SOURCE):
-        state.add_debug("ERR", f"OS_CP.c not found at: {SOURCE}")
-        state.add_debug("WARN", f"Run this tool from the folder containing OS_CP.c")
-        state.add_debug("WARN", f"Current dir: {_CWD}")
+        state.add_debug("ERR",  f"OS_CP.c not found at: {SOURCE}")
+        state.add_debug("WARN", f"Base dir searched: {_CWD}")
         return False
-    state.add_debug("INFO", f"Compiling {SOURCE}...")
+    state.add_debug("INFO", f"Compiling {os.path.basename(SOURCE)} ...")
     result = subprocess.run(
         ["gcc", "-o", BINARY, SOURCE, "-lm"],
-        cwd=_CWD,
-        capture_output=True, text=True
+        cwd=_CWD, capture_output=True, text=True
     )
     if result.returncode != 0:
-        state.compile_error = result.stderr.strip()
         state.add_debug("ERR", "Compilation failed")
-        for line in result.stderr.strip().splitlines()[:6]:
-            state.add_debug("ERR", line)
+        for ln in result.stderr.strip().splitlines()[:8]:
+            state.add_debug("ERR", ln)
         return False
     state.compiled = True
-    state.add_debug("OK", f"Compiled → {BINARY}")
+    state.add_debug("OK", f"Compiled → {os.path.basename(BINARY)}")
     return True
 
+# ── MEMORY RECONSTRUCTION (fallback when C has no dump_memory) ──────────────
+def _reconstruct_memory_from_input(input_text):
+    """Simulate LOAD phase to show memory even without dump_memory() in C."""
+    snap = state.memory
+    snap.cells  = [('    ', 'E')] * 100
+    snap.ic = snap.c_reg = snap.si = 0
+    snap.ir = snap.r_reg = '    '
+    snap.loaded = False
+
+    lines     = input_text.splitlines()
+    m         = 0
+    in_prog   = False
+    data_lines = []
+
+    for line in lines:
+        ls = line.rstrip()
+        if   ls.startswith('$AMJ'):
+            snap.cells = [('    ', 'E')] * 100
+            m = 0; in_prog = True; data_lines = []
+        elif ls.startswith('$DTA'):
+            in_prog = False
+        elif ls.startswith('$END'):
+            break
+        elif in_prog:
+            k = 0
+            while k < len(ls):
+                if m >= 100: break
+                cell = (ls[k:k+4] + '    ')[:4]
+                snap.cells[m] = (cell, 'I')
+                m += 1; k += 4
+        else:
+            data_lines.append(ls)
+
+    # Place data by simulating GD instructions
+    data_idx = 0
+    for addr in range(100):
+        content, typ = snap.cells[addr]
+        if content[:2] == 'GD':
+            try:
+                d_addr = int(content[2]) * 10 + int(content[3])
+                if data_idx < len(data_lines):
+                    dline = data_lines[data_idx]; data_idx += 1
+                    for i in range(d_addr, min(d_addr + 10, 100)):
+                        k = (i - d_addr) * 4
+                        snap.cells[i] = ((dline[k:k+4] + '    ')[:4], 'D')
+            except (ValueError, IndexError):
+                pass
+
+    snap.loaded = True
+    used  = sum(1 for _, t in snap.cells if t != 'E')
+    instr = sum(1 for _, t in snap.cells if t == 'I')
+    data  = sum(1 for _, t in snap.cells if t == 'D')
+    state.add_debug("OK",   f"Memory reconstructed: {used}/100 ({instr} instr, {data} data)")
+    state.add_debug("INFO", "For post-execution state, use the updated OS_CP.c")
+
+
 # ── RUN ───────────────────────────────────────────────────────────────────────
 def run_program(input_text, callback):
     state.status = "RUNNING"
     state.add_debug("INFO", f"─── Run #{state.run_count} started ───")
 
-    # Use a dedicated temp directory so input.txt and output.txt are isolated
-    run_dir = tempfile.mkdtemp(prefix='mos_run_')
+    run_dir   = tempfile.mkdtemp(prefix='mos_run_')
     fin_path  = os.path.join(run_dir, "input.txt")
     fout_path = os.path.join(run_dir, "output.txt")
+    dump_path = os.path.join(run_dir, "memory_dump.txt")
 
     with open(fin_path, 'w') as f:
         f.write(input_text)
 
-    state.add_debug("INFO", f"Input written → {fin_path}")
-
     t0 = time.perf_counter()
     try:
         result = subprocess.run(
             [BINARY],
-            capture_output=True,
-            text=True,
-            timeout=10,
-            cwd=run_dir,                          # binary runs inside temp dir
+            capture_output=True, text=True, timeout=10,
+            cwd=run_dir,
             env={**os.environ,
-                 'MOS_INPUT':  fin_path,           # env var override (your updated C uses this)
-                 'MOS_OUTPUT': fout_path}
+                 'MOS_INPUT':   fin_path,
+                 'MOS_OUTPUT':  fout_path,
+                 'MOS_MEMDUMP': dump_path}
         )
         elapsed_ms = (time.perf_counter() - t0) * 1000
-
         state.add_debug("INFO", f"Process exited (code={result.returncode})")
 
-        # Parse stdout debug lines from the C program
         for line in result.stdout.strip().splitlines():
             line = line.strip()
-            if not line:
-                continue
-            if "Compilation" in line or "compile" in line.lower():
-                state.add_debug("ERR", line)
-            elif line.startswith("AMJ") or "initializ" in line.lower():
-                state.add_debug("OK", line)
-            elif line.startswith("DTA") or "execut" in line.lower():
+            if not line: continue
+            if   "initializ" in line.lower() or line.startswith("AMJ"):
+                state.add_debug("OK",   line)
+            elif "execut" in line.lower() or line.startswith("DTA"):
                 state.add_debug("EXEC", line)
-            elif line.startswith("END") or "complet" in line.lower():
-                state.add_debug("OK", line)
-            elif "error" in line.lower() or "invalid" in line.lower() or "overflow" in line.lower():
-                state.add_debug("ERR", line)
+            elif "complet" in line.lower() or line.startswith("END"):
+                state.add_debug("OK",   line)
+            elif any(w in line.lower() for w in ("error","invalid","overflow","not found")):
+                state.add_debug("ERR",  line)
             elif "infinite" in line.lower() or "loop" in line.lower():
                 state.add_debug("WARN", line)
-            elif "time" in line.lower():
-                state.add_debug("INFO", line)
             else:
                 state.add_debug("INFO", line)
 
         if result.stderr.strip():
-            for line in result.stderr.strip().splitlines():
-                state.add_debug("ERR", line)
+            for ln in result.stderr.strip().splitlines():
+                state.add_debug("ERR", ln)
 
-        # Read output.txt from the run directory (guaranteed location)
         output_content = []
         if os.path.exists(fout_path):
             with open(fout_path) as f:
                 output_content = f.read().splitlines()
-            state.add_debug("OK", f"Output read from {fout_path} ({len(output_content)} lines)")
-        else:
-            state.add_debug("WARN", f"output.txt not created at {fout_path}")
+            state.add_debug("OK", f"Output: {len(output_content)} lines")
 
-        # Debug: show raw repr of each line so we can see spaces vs real content
         for idx, line in enumerate(output_content):
             stripped = line.rstrip()
             if stripped:
                 state.add_output(stripped)
             else:
-                # Don't add pure-blank lines from TERMINATE()'s \n\n — skip them
-                # but log them so user can see in debug
-                state.add_debug("INFO", f"output line {idx+1}: (blank/whitespace only)")
+                state.add_debug("INFO", f"output line {idx+1}: (blank)")
 
         if result.returncode == 0:
             if not output_content:
-                state.add_output("[output.txt was empty — check your PD instruction address]")
+                state.add_output("[output.txt empty — check PD address]")
             elif not any(l.strip() for l in output_content):
-                state.add_output("[output.txt had only blank lines — PD address may point to empty memory]")
-                state.add_debug("WARN", "All output lines were blank — GD and PD addresses must match")
-                state.add_debug("WARN", "e.g. GD10 reads into addr 10-19, so use PD10 to print it")
+                state.add_output("[All output lines blank — GD/PD address mismatch?]")
+                state.add_debug("WARN", "GD10 reads into addr 10-19 → use PD10 to print")
+
+        state.add_debug("INFO", f"Checking dump at: {dump_path}")
+        if os.path.exists(dump_path):
+            with open(dump_path) as f:
+                dump_text = f.read()
+            state.add_debug("INFO", f"Dump size: {len(dump_text)} bytes, {len(dump_text.splitlines())} lines")
+            state.memory.parse(dump_text)
+            state.add_debug("INFO", f"Parse done, loaded={state.memory.loaded}")
+            used  = sum(1 for _, t in state.memory.cells if t != 'E')
+            instr = sum(1 for _, t in state.memory.cells if t == 'I')
+            data  = sum(1 for _, t in state.memory.cells if t == 'D')
+            state.add_debug("OK", f"Memory: {used}/100 cells used ({instr} instr, {data} data)")
+        else:
+            state.add_debug("ERR", f"No dump file at: {dump_path}")
+            state.add_debug("WARN", "Using OS_CP.c without dump_memory() — reconstructing from input")
+            # ── FALLBACK: reconstruct memory by simulating the LOAD phase ──
+            _reconstruct_memory_from_input(input_text)
 
         state.exec_time_ms = elapsed_ms
         state.run_history.append((f"Run #{state.run_count}", elapsed_ms))
-        state.add_debug("OK", f"Done in {elapsed_ms:.3f}ms | exit={result.returncode}")
+        state.add_debug("OK", f"Done in {elapsed_ms:.3f}ms")
         state.status = "HALTED" if result.returncode == 0 else "ERROR"
 
     except subprocess.TimeoutExpired:
-        state.add_debug("ERR", "Execution timed out (10s limit)")
+        state.add_debug("ERR", "Timed out (10s)")
         state.status = "TIMEOUT"
     except Exception as e:
         state.add_debug("ERR", f"Runner error: {e}")
         state.status = "ERROR"
     finally:
-        import shutil
         try: shutil.rmtree(run_dir, ignore_errors=True)
         except: pass
 
     callback()
 
-# ── DRAWING HELPERS ───────────────────────────────────────────────────────────
+# ── DRAW HELPERS ──────────────────────────────────────────────────────────────
 def safe_addstr(win, y, x, s, attr=0):
     h, w = win.getmaxyx()
     if y < 0 or y >= h or x < 0 or x >= w:
         return
-    max_len = w - x - 1
-    if max_len <= 0:
-        return
+    s = s[:max(0, w - x - 1)]
+    if not s: return
     try:
-        win.addstr(y, x, s[:max_len], attr)
+        win.addstr(y, x, s, attr)
     except curses.error:
         pass
 
 def draw_box(win, title="", active=False):
-    h, w = win.getmaxyx()
-    col = curses.color_pair(C_BORDER) | (curses.A_BOLD if active else 0)
     try:
         win.border(
             curses.ACS_VLINE, curses.ACS_VLINE,
@@ -249,16 +323,13 @@ def draw_box(win, title="", active=False):
     except curses.error:
         pass
     if title:
-        label = f" {title} "
-        attr = curses.color_pair(C_TITLE) | curses.A_BOLD if active else curses.color_pair(C_DIM)
-        safe_addstr(win, 0, 2, label, attr)
+        attr = (curses.color_pair(C_TITLE) | curses.A_BOLD) if active else curses.color_pair(C_DIM)
+        safe_addstr(win, 0, 2, f" {title} ", attr)
 
-def fill_line(win, y, attr=0):
+def fill_line(win, y):
     h, w = win.getmaxyx()
-    try:
-        win.addstr(y, 1, " " * (w - 2), attr)
-    except curses.error:
-        pass
+    try: win.addstr(y, 1, " " * (w - 2))
+    except curses.error: pass
 
 # ── PANEL: INPUT ──────────────────────────────────────────────────────────────
 def draw_input_panel(win, active):
@@ -266,373 +337,659 @@ def draw_input_panel(win, active):
     h, w = win.getmaxyx()
     inner_h = h - 3
     inner_w = w - 2
-    lines = state.input_lines
-
-    # hint bar
-    hint = " ↑↓ scroll  F5 run  F2 sample  F3 clear "
-    safe_addstr(win, 1, 1, hint[:inner_w], curses.color_pair(C_DIM))
-
+    safe_addstr(win, 1, 1,
+        " arrows:move  S:sample  C:clear  R:run  F6:compile "[:inner_w],
+        curses.color_pair(C_DIM))
     for row in range(inner_h):
         li = row + state.input_scroll
-        y = row + 2
+        y  = row + 2
         fill_line(win, y)
-        if li < len(lines):
-            line = lines[li]
-            col = curses.color_pair(C_INPUT)
-            # color directives
+        if li < len(state.input_lines):
+            line = state.input_lines[li]
+            col  = curses.color_pair(C_INPUT)
             if line.startswith('$'):
                 col = curses.color_pair(C_YELLOW) | curses.A_BOLD
+            elif line[:2] in ('LR','SR','CR','BT','GD','PD') or line.rstrip() == 'H':
+                col = curses.color_pair(C_BORDER)
             safe_addstr(win, y, 1, line[:inner_w], col)
-        # draw cursor
         cr, cc = state.input_cursor
         if li == cr and active:
             cx = min(cc, inner_w - 1)
+            ch = (state.input_lines[cr][cc]
+                  if cr < len(state.input_lines) and cc < len(state.input_lines[cr])
+                  else ' ')
             try:
-                ch = lines[cr][cc] if cr < len(lines) and cc < len(lines[cr]) else ' '
                 win.addch(y, 1 + cx, ch, curses.color_pair(C_HEADER) | curses.A_BOLD)
             except curses.error:
                 pass
 
 # ── PANEL: DEBUG ──────────────────────────────────────────────────────────────
-TAG_COLORS = {
-    "INFO": C_BORDER,
-    "OK":   C_GREEN,
-    "WARN": C_YELLOW,
-    "ERR":  C_RED,
-    "EXEC": C_ORANGE,
-}
+TAG_ATTR = {"INFO": C_BORDER, "OK": C_GREEN, "WARN": C_YELLOW, "ERR": C_RED, "EXEC": C_ORANGE}
 
 def draw_debug_panel(win, active):
-    draw_box(win, "DEBUG LOG  [F2 nav]", active)
-    h, w = win.getmaxyx()
+    draw_box(win, "DEBUG LOG  [F2]", active)
+    h, w    = win.getmaxyx()
     inner_h = h - 2
     inner_w = w - 2
-
-    lines = state.debug_lines
-    # auto-scroll to bottom unless user scrolled
-    max_scroll = max(0, len(lines) - inner_h)
-    if state.debug_scroll > max_scroll:
-        state.debug_scroll = max_scroll
-
+    lines   = state.debug_lines
+    max_s   = max(0, len(lines) - inner_h)
+    if state.debug_scroll > max_s:
+        state.debug_scroll = max_s
     for row in range(inner_h):
         li = row + state.debug_scroll
-        y = row + 1
+        y  = row + 1
         fill_line(win, y)
-        if li >= len(lines):
-            continue
+        if li >= len(lines): continue
         ts, tag, msg = lines[li]
-
         x = 1
-        # timestamp
         safe_addstr(win, y, x, ts, curses.color_pair(C_DIM))
         x += len(ts) + 1
-
-        # tag badge
-        tag_col = curses.color_pair(TAG_COLORS.get(tag, C_DIM)) | curses.A_BOLD
         badge = f"[{tag:<4}]"
-        safe_addstr(win, y, x, badge, tag_col)
+        safe_addstr(win, y, x, badge, curses.color_pair(TAG_ATTR.get(tag, C_DIM)) | curses.A_BOLD)
         x += len(badge) + 1
-
-        # message
-        remaining = inner_w - x
-        safe_addstr(win, y, x, msg[:remaining], curses.color_pair(C_NORMAL))
+        safe_addstr(win, y, x, msg[:inner_w - x], curses.color_pair(C_NORMAL))
 
 # ── PANEL: OUTPUT ─────────────────────────────────────────────────────────────
 def draw_output_panel(win, active):
-    draw_box(win, "OUTPUT  [F3 nav]", active)
-    h, w = win.getmaxyx()
+    draw_box(win, "OUTPUT  [F3]", active)
+    h, w    = win.getmaxyx()
     inner_h = h - 2
     inner_w = w - 2
-
-    lines = state.output_lines
-    max_scroll = max(0, len(lines) - inner_h)
-    if state.output_scroll > max_scroll:
-        state.output_scroll = max_scroll
-
+    lines   = state.output_lines
+    max_s   = max(0, len(lines) - inner_h)
+    if state.output_scroll > max_s:
+        state.output_scroll = max_s
     if not lines:
-        msg = "No output yet — press F5 to run"
-        safe_addstr(win, inner_h // 2, max(1, (inner_w - len(msg)) // 2), msg, curses.color_pair(C_DIM))
+        msg = "No output yet — press R to run"
+        safe_addstr(win, inner_h // 2, max(1, (inner_w - len(msg)) // 2),
+                    msg, curses.color_pair(C_DIM))
         return
-
     for row in range(inner_h):
         li = row + state.output_scroll
-        y = row + 1
+        y  = row + 1
         fill_line(win, y)
         if li < len(lines):
             line = lines[li]
-            # line number gutter
-            gutter = f"{li+1:3} "
-            safe_addstr(win, y, 1, gutter, curses.color_pair(C_DIM))
-            col = curses.color_pair(C_GREEN)
-            if not line.strip():
-                safe_addstr(win, y, 5, "~", curses.color_pair(C_DIM))
+            safe_addstr(win, y, 1, f"{li+1:3} ", curses.color_pair(C_DIM))
+            if line.strip():
+                safe_addstr(win, y, 5, line[:inner_w - 5], curses.color_pair(C_GREEN))
             else:
-                safe_addstr(win, y, 5, line[:inner_w-5], col)
-
-# ── PANEL: CHART ──────────────────────────────────────────────────────────────
-SPARK_CHARS = " ▁▂▃▄▅▆▇█"
+                safe_addstr(win, y, 5, "~", curses.color_pair(C_DIM))
 
-def draw_chart_panel(win, active):
-    draw_box(win, "EXECUTION METRICS  [F4 nav]", active)
-    h, w = win.getmaxyx()
+# ── PANEL: MEMORY MAP ─────────────────────────────────────────────────────────
+def _cell_attr(typ, is_ic):
+    if is_ic:
+        return curses.color_pair(C_MEM_IC) | curses.A_BOLD | curses.A_REVERSE
+    if typ == 'I': return curses.color_pair(C_MEM_INSTR) | curses.A_BOLD
+    if typ == 'D': return curses.color_pair(C_MEM_DATA)
+    return curses.color_pair(C_MEM_EMPTY)
+
+def draw_memory_panel(win, active):
+    # mem_view: 'grid' | 'list' | 'chart'  — Tab cycles through all three
+    h, w    = win.getmaxyx()
     inner_h = h - 2
     inner_w = w - 2
-    y = 1
 
-    # Registers / stats row
-    et = f"{state.exec_time_ms:.3f}ms" if state.exec_time_ms else "--"
-    runs = str(state.run_count)
-    hist = state.run_history
+    # ── Tab bar (row 0 = border, row 1 = tabs) ──────────────────────────────
+    view = state.mem_view
+    tabs = [('MEMORY GRID', 'grid'), ('MEMORY LIST', 'list'), ('EXEC CHART', 'chart')]
+    title_parts = []
+    for lbl, key in tabs:
+        marker = f"[{lbl}]" if view == key else f" {lbl} "
+        title_parts.append((marker, key))
+
+    # Draw box with dynamic title
+    active_lbl = next(lbl for lbl, key in tabs if key == view)
+    draw_box(win, f"{active_lbl}  Tab:switch  T:grid/list", active)
+
+    # ── Tab row ──────────────────────────────────────────────────────────────
+    x = 1
+    for lbl, key in tabs:
+        attr = (curses.color_pair(C_HEADER) | curses.A_BOLD) if view == key else curses.color_pair(C_DIM)
+        tag  = f"[{lbl}]" if view == key else f" {lbl} "
+        safe_addstr(win, 1, x, tag, attr)
+        x += len(tag) + 1
+
+    # ── Route to sub-view ────────────────────────────────────────────────────
+    if view == 'chart':
+        _draw_chart_content(win, 2, inner_h - 2, inner_w)
+        return
 
-    stats = [
-        ("EXEC TIME", et, C_GREEN),
-        ("RUNS",      runs, C_BORDER),
-        ("LAST RUN",  hist[-1][0] if hist else "--", C_YELLOW),
-    ]
+    mem = state.memory
+    if not mem.loaded:
+        msg = "Run a program first (R) to see memory"
+        safe_addstr(win, inner_h // 2,
+                    max(1, (inner_w - len(msg)) // 2),
+                    msg, curses.color_pair(C_DIM))
+        return
 
-    col_w = (inner_w) // 3
-    for i, (label, val, col) in enumerate(stats):
-        bx = 1 + i * col_w
-        safe_addstr(win, y,   bx, label[:col_w-1], curses.color_pair(C_DIM))
-        safe_addstr(win, y+1, bx, val[:col_w-1],   curses.color_pair(col) | curses.A_BOLD)
-    y += 3
+    # Row 2: registers
+    reg_line = (f" IC={mem.ic:02d}  IR={mem.ir.rstrip():<6}"
+                f"R={mem.r_reg.rstrip():<6}C={mem.c_reg}  SI={mem.si}")
+    safe_addstr(win, 2, 1, reg_line[:inner_w], curses.color_pair(C_YELLOW) | curses.A_BOLD)
+
+    # Row 3: legend + stats
+    used  = sum(1 for _, t in mem.cells if t != 'E')
+    instr = sum(1 for _, t in mem.cells if t == 'I')
+    data  = sum(1 for _, t in mem.cells if t == 'D')
+    safe_addstr(win, 3, 1, "  INSTR  DATA  EMPTY", curses.color_pair(C_DIM))
+    try:
+        win.addstr(3, 1, "█", curses.color_pair(C_MEM_INSTR) | curses.A_BOLD)
+        win.addstr(3, 8, "█", curses.color_pair(C_MEM_DATA)  | curses.A_BOLD)
+        win.addstr(3,14, "█", curses.color_pair(C_DIM))
+    except curses.error:
+        pass
+    safe_addstr(win, 3, 21,
+                f" {used}/100 used  {instr} instr  {data} data"[:inner_w-21],
+                curses.color_pair(C_DIM))
+
+    content_y = 4
+    content_h = inner_h - content_y
 
-    if y >= inner_h + 1:
+    if view == 'grid':
+        _draw_mem_grid(win, content_y, content_h, inner_w, mem)
+    else:
+        _draw_mem_list(win, content_y, content_h, inner_w, mem)
+
+def _draw_mem_grid(win, start_y, avail_h, inner_w, mem):
+    """
+    Adaptive grid: fills available width.
+    Each cell is "XX[CCCC]" = 8 chars. Prefix column = 0 chars (no row label).
+    Columns = max that fit: inner_w // 8, capped at 10.
+    Rows    = ceil(100 / cols), displayed with scrolling.
+    """
+    cell_w = 8          # "XX[CCCC]" — addr(2)+bracket+content(4)+bracket = 8
+    cols   = max(1, min(10, inner_w // cell_w))
+    total_rows = (100 + cols - 1) // cols
+
+    max_row_s = max(0, total_rows - avail_h)
+    if state.mem_scroll > max_row_s:
+        state.mem_scroll = max_row_s
+
+    for r in range(avail_h):
+        row_idx = r + state.mem_scroll
+        if row_idx >= total_rows:
+            break
+        y = start_y + r
+        for col in range(cols):
+            addr = row_idx * cols + col
+            if addr >= 100:
+                break
+            content, typ = mem.cells[addr]
+            is_ic  = (addr == mem.ic)
+            x      = col * cell_w
+            if x + cell_w > inner_w:
+                break
+            # addr in dim, content colored
+            safe_addstr(win, y, x,     f"{addr:02d}", curses.color_pair(C_DIM))
+            safe_addstr(win, y, x + 2, f"[{content}]", _cell_attr(typ, is_ic))
+
+def _decode_instr(content):
+    op  = content[:2].strip()
+    arg = content[2:].strip()
+    return {
+        'LR': f"Load R ← M[{arg}]",
+        'SR': f"Store M[{arg}] ← R",
+        'CR': f"Compare R, M[{arg}]",
+        'BT': f"Branch→{arg} if C=1",
+        'GD': f"Read input→M[{arg}]",
+        'PD': f"Print M[{arg}]",
+        'H':  "Halt",
+    }.get(op, "")
+
+def _draw_mem_list(win, start_y, avail_h, inner_w, mem):
+    """Detailed list — only non-empty cells + current IC row."""
+    rows = [(i, c, t, i == mem.ic)
+            for i, (c, t) in enumerate(mem.cells)
+            if t != 'E' or i == mem.ic]
+
+    if not rows:
+        safe_addstr(win, start_y, 1, "  All cells empty.", curses.color_pair(C_DIM))
         return
 
-    # separator
-    safe_addstr(win, y, 1, "─" * inner_w, curses.color_pair(C_DIM))
-    y += 1
+    max_s = max(0, len(rows) - (avail_h - 1))
+    if state.mem_scroll > max_s:
+        state.mem_scroll = max_s
 
-    # chart title
-    safe_addstr(win, y, 1, " EXEC TIME HISTORY (ms):", curses.color_pair(C_DIM))
-    y += 1
+    # header
+    safe_addstr(win, start_y, 1,
+        f"  {'ADDR':>4}  {'CONTENT':<8}  {'TYPE':<6}  DECODED",
+        curses.color_pair(C_DIM) | curses.A_BOLD)
+
+    for row in range(avail_h - 1):
+        ri = row + state.mem_scroll
+        y  = start_y + 1 + row
+        fill_line(win, y)
+        if ri >= len(rows): continue
+        addr, content, typ, is_ic = rows[ri]
+        type_lbl = {'I':'INSTR','D':'DATA','E':'EMPTY'}.get(typ, typ)
+        note = "← IC" if is_ic else (_decode_instr(content) if typ == 'I' else "")
+        line = f"  {addr:>4}  {repr(content):<10}  {type_lbl:<6}  {note}"
+        safe_addstr(win, y, 1, line[:inner_w], _cell_attr(typ, is_ic))
+
+# ── PANEL: CHART ──────────────────────────────────────────────────────────────
+SPARK = " ▁▂▃▄▅▆▇█"
+
+def _draw_chart_content(win, start_y, avail_h, inner_w):
+    """Draw the execution time chart starting at start_y inside any window."""
+    hist = state.run_history
+    y    = start_y
+
+    # Stats row
+    et  = f"{state.exec_time_ms:.3f}ms" if state.exec_time_ms else "--"
+    cw  = inner_w // 3
+    for i, (lbl, val, col) in enumerate([
+        ("EXEC TIME", et,                   C_GREEN),
+        ("RUNS",      str(state.run_count), C_BORDER),
+        ("LAST RUN",  hist[-1][0] if hist else "--", C_YELLOW),
+    ]):
+        bx = 1 + i * cw
+        safe_addstr(win, y,   bx, lbl[:cw-1], curses.color_pair(C_DIM))
+        safe_addstr(win, y+1, bx, val[:cw-1], curses.color_pair(col) | curses.A_BOLD)
+    y += 3
+
+    if y - start_y >= avail_h:
+        return
+    safe_addstr(win, y, 1, "─" * inner_w, curses.color_pair(C_DIM)); y += 1
+    safe_addstr(win, y, 1, " EXEC TIME HISTORY (ms):", curses.color_pair(C_DIM)); y += 1
 
     if not hist:
-        safe_addstr(win, y, 1, " No runs yet", curses.color_pair(C_DIM))
+        safe_addstr(win, y, 1, " No runs yet — press R to run", curses.color_pair(C_DIM))
         return
 
-    # bar chart area
-    chart_h = inner_h - (y - 1)
-    if chart_h < 3:
+    h, _ = win.getmaxyx()
+    chart_bottom = start_y + avail_h     # don't draw below this row
+    bar_area     = chart_bottom - y - 2  # rows available for bars
+    if bar_area < 2:
         return
 
-    max_ms = max(r[1] for r in hist)
-    bar_area_h = chart_h - 2  # leave rows for labels and scale
+    max_ms   = max(r[1] for r in hist)
+    bar_w, sp = 5, 1
+    max_bars  = max(1, inner_w // (bar_w + sp))
+    visible   = hist[-max_bars:]
+    BAR_COLS  = [C_BORDER, C_GREEN, C_YELLOW, C_ORANGE, C_RED]
 
-    # how many bars fit
-    bar_w   = 5
-    spacing = 1
-    max_bars = max(1, inner_w // (bar_w + spacing))
-    visible  = hist[-max_bars:]
+    for bi, (label, ms) in enumerate(visible):
+        bh  = max(1, int((ms / max_ms) * bar_area)) if max_ms > 0 else 1
+        bx  = 1 + bi * (bar_w + sp)
+        col = curses.color_pair(BAR_COLS[bi % len(BAR_COLS)]) | curses.A_BOLD
+        for brow in range(bar_area):
+            ry = y + bar_area - 1 - brow
+            if ry >= h - 1 or ry >= chart_bottom:
+                continue
+            safe_addstr(win, ry, bx,
+                        ("█" * bar_w) if brow < bh else ("░" * bar_w),
+                        col if brow < bh else curses.color_pair(C_DIM))
+        # value label above bar
+        val_row = y - 1
+        if val_row >= start_y:
+            safe_addstr(win, val_row, bx,
+                        f"{ms:.1f}"[:bar_w].center(bar_w),
+                        curses.color_pair(C_YELLOW))
+        # run label below bar
+        lbl_row = y + bar_area
+        if lbl_row < chart_bottom:
+            safe_addstr(win, lbl_row, bx,
+                        label.split()[-1][:bar_w].center(bar_w),
+                        curses.color_pair(C_DIM))
+
+    # Sparkline
+    spark_y = y + bar_area + 1
+    if spark_y < chart_bottom and len(hist) > 1:
+        max_v  = max(r[1] for r in hist)
+        SPARK  = " ▁▂▃▄▅▆▇█"
+        sp_str = "".join(SPARK[min(8, int((r[1]/max_v)*8))] for r in hist[-inner_w+4:])
+        safe_addstr(win, spark_y, 1, "▸ " + sp_str, curses.color_pair(C_BORDER))
 
-    bar_colors = [C_BORDER, C_GREEN, C_YELLOW, C_ORANGE, C_RED]
 
-    for bi, (label, ms) in enumerate(visible):
-        bar_height = max(1, int((ms / max_ms) * bar_area_h)) if max_ms > 0 else 1
-        bx = 1 + bi * (bar_w + spacing)
-        col = curses.color_pair(bar_colors[bi % len(bar_colors)]) | curses.A_BOLD
+def draw_chart_panel(win, active):
+    draw_box(win, "EXEC TIME CHART", active)
+    h, w    = win.getmaxyx()
+    inner_h = h - 2
+    inner_w = w - 2
+    hist    = state.run_history
+    y       = 1
+
+    cw = inner_w // 3
+    for i, (lbl, val, col) in enumerate([
+        ("EXEC TIME", f"{state.exec_time_ms:.3f}ms" if state.exec_time_ms else "--", C_GREEN),
+        ("RUNS",      str(state.run_count), C_BORDER),
+        ("LAST",      hist[-1][0] if hist else "--", C_YELLOW),
+    ]):
+        bx = 1 + i * cw
+        safe_addstr(win, y,   bx, lbl[:cw-1], curses.color_pair(C_DIM))
+        safe_addstr(win, y+1, bx, val[:cw-1], curses.color_pair(col) | curses.A_BOLD)
+    y += 3
 
-        # draw bar from bottom up
-        for brow in range(bar_area_h):
-            ry = y + bar_area_h - 1 - brow
-            if ry >= h - 1:
-                continue
-            if brow < bar_height:
-                safe_addstr(win, ry, bx, "█" * bar_w, col)
-            else:
-                safe_addstr(win, ry, bx, "░" * bar_w, curses.color_pair(C_DIM))
+    safe_addstr(win, y, 1, "─" * inner_w, curses.color_pair(C_DIM)); y += 1
+    safe_addstr(win, y, 1, " EXEC TIME HISTORY (ms):", curses.color_pair(C_DIM)); y += 1
 
-        # value above bar
-        val_str = f"{ms:.1f}"[:bar_w]
-        safe_addstr(win, y - 1, bx, val_str.center(bar_w), curses.color_pair(C_YELLOW))
+    if not hist:
+        safe_addstr(win, y, 1, " No runs yet", curses.color_pair(C_DIM))
+        return
 
-        # label below
-        lbl = (label.split()[1] if ' ' in label else label)[:bar_w]
-        ly = y + bar_area_h
-        if ly < h - 1:
-            safe_addstr(win, ly, bx, lbl.center(bar_w), curses.color_pair(C_DIM))
+    chart_h  = inner_h - (y - 1)
+    if chart_h < 3: return
+    bar_area = chart_h - 2
+    max_ms   = max(r[1] for r in hist)
+    bar_w, sp = 5, 1
+    max_bars = max(1, inner_w // (bar_w + sp))
+    visible  = hist[-max_bars:]
+    BAR_COLS = [C_BORDER, C_GREEN, C_YELLOW, C_ORANGE, C_RED]
 
-    # sparkline summary
-    spark_y = y + bar_area_h + 1
+    for bi, (label, ms) in enumerate(visible):
+        bh  = max(1, int((ms / max_ms) * bar_area)) if max_ms > 0 else 1
+        bx  = 1 + bi * (bar_w + sp)
+        col = curses.color_pair(BAR_COLS[bi % len(BAR_COLS)]) | curses.A_BOLD
+        for brow in range(bar_area):
+            ry = y + bar_area - 1 - brow
+            if ry >= h - 1: continue
+            safe_addstr(win, ry, bx,
+                        ("█" * bar_w) if brow < bh else ("░" * bar_w),
+                        col if brow < bh else curses.color_pair(C_DIM))
+        safe_addstr(win, y-1, bx, f"{ms:.1f}"[:bar_w].center(bar_w), curses.color_pair(C_YELLOW))
+        if y + bar_area < h - 1:
+            safe_addstr(win, y + bar_area, bx, label.split()[-1][:bar_w].center(bar_w),
+                        curses.color_pair(C_DIM))
+
+    spark_y = y + bar_area + 1
     if spark_y < h - 1 and len(hist) > 1:
-        max_v = max(r[1] for r in hist)
-        spark = "".join(SPARK_CHARS[min(8, int((r[1]/max_v)*8))] for r in hist[-inner_w+4:])
-        safe_addstr(win, spark_y, 1, "▸ " + spark, curses.color_pair(C_BORDER))
-
-# ── STATUS BAR ────────────────────────────────────────────────────────────────
-STATUS_COLORS = {
-    "READY":   C_GREEN,
-    "RUNNING": C_YELLOW,
-    "HALTED":  C_BORDER,
-    "ERROR":   C_RED,
-    "TIMEOUT": C_RED,
-    "COMPILING": C_YELLOW,
-}
+        max_v  = max(r[1] for r in hist)
+        sp_str = "".join(SPARK[min(8, int((r[1]/max_v)*8))] for r in hist[-inner_w+4:])
+        safe_addstr(win, spark_y, 1, "▸ " + sp_str, curses.color_pair(C_BORDER))
 
-def draw_statusbar(stdscr, H, W):
-    y = H - 1
+# ── STATUS / TITLE ────────────────────────────────────────────────────────────
+def draw_titlebar(stdscr, W):
+    comp = "  [COMPILED ✓]" if state.compiled else "  [NOT COMPILED — F6]"
+    full = f" MOS  Multiprogramming OS Simulator  ──  {os.path.basename(SOURCE)}{comp}"
     try:
-        stdscr.addstr(y, 0, " " * (W - 1), curses.color_pair(C_HEADER))
+        stdscr.addstr(0, 0, " " * (W - 1), curses.color_pair(C_HEADER))
+        stdscr.addstr(0, 0, full[:W-1],    curses.color_pair(C_HEADER) | curses.A_BOLD)
     except curses.error:
         pass
 
-    sc = STATUS_COLORS.get(state.status, C_NORMAL)
-    left = f" MOS v1.0 │ {state.status} │ Runs: {state.run_count} │ {SOURCE}"
-    right = f"F1:Input F2:Debug F3:Output F4:Chart F5:Run F6:Compile Q:Quit "
-    safe_addstr(stdscr, y, 0, left, curses.color_pair(C_HEADER) | curses.A_BOLD)
-    rx = W - len(right) - 1
-    if rx > len(left):
-        safe_addstr(stdscr, y, rx, right, curses.color_pair(C_HEADER))
-
-def draw_titlebar(stdscr, W):
-    title = " ┌─ MOS ─┐  Multiprogramming OS Simulator  ──  OS_CP.c "
-    compiled_str = "  [COMPILED ✓]" if state.compiled else "  [NOT COMPILED]"
-    full = title + compiled_str
-    col = curses.color_pair(C_HEADER) | curses.A_BOLD
+def draw_statusbar(stdscr, H, W):
+    y     = H - 1
+    left  = f" {state.status} │ Runs:{state.run_count} │ {_CWD}"
+    right = " F1:Input F2:Debug F3:Output F4:Memory F5:Metrics R:Run F6:Compile Q:Quit "
     try:
-        stdscr.addstr(0, 0, " " * (W - 1), col)
-        stdscr.addstr(0, 0, full[:W-1], col)
+        stdscr.addstr(y, 0, " " * (W - 1), curses.color_pair(C_HEADER))
     except curses.error:
         pass
+    safe_addstr(stdscr, y, 0,     left[:W-1], curses.color_pair(C_HEADER) | curses.A_BOLD)
+    rx = W - len(right) - 1
+    if rx > len(left):
+        safe_addstr(stdscr, y, rx, right,     curses.color_pair(C_HEADER))
 
-# ── SAMPLE PROGRAMS ───────────────────────────────────────────────────────────
+# ── SAMPLES ───────────────────────────────────────────────────────────────────
 SAMPLES = [
-# Sample 1: Read data into addr 10, print from addr 10
-"""$AMJ
-GD10
-PD10
-H
-$DTA
-Hello MOS!
-$END""",
-# Sample 2: Read two lines, print both
-"""$AMJ
-GD10
-PD10
-GD30
-PD30
-H
-$DTA
-First Line
-Second Line
-$END""",
-# Sample 3: Load, store, compare, branch
-"""$AMJ
-GD10
-LR10
-SR20
-PD20
-H
-$DTA
-Stored Data
-$END""",
+"$AMJ\nGD10\nPD10\nH\n$DTA\nHello MOS!\n$END",
+"$AMJ\nGD10\nPD10\nGD30\nPD30\nH\n$DTA\nFirst Line\nSecond Line\n$END",
+"$AMJ\nGD10\nLR10\nSR20\nPD20\nH\n$DTA\nStored Data\n$END",
 ]
-_sample_idx = [0]
+_sidx = [0]
 
 def load_sample():
-    prog = SAMPLES[_sample_idx[0] % len(SAMPLES)].strip()
-    _sample_idx[0] += 1
-    state.input_lines = prog.splitlines()
+    state.input_lines  = SAMPLES[_sidx[0] % len(SAMPLES)].strip().splitlines()
+    _sidx[0] += 1
     state.input_cursor = [0, 0]
     state.input_scroll = 0
-    state.add_debug("INFO", f"Sample #{_sample_idx[0]} loaded — press F5 to run")
+    state.add_debug("INFO", f"Sample #{_sidx[0]} loaded — press R to run")
 
-# ── CURSOR / INPUT NAVIGATION ─────────────────────────────────────────────────
+# ── INPUT EDITING ─────────────────────────────────────────────────────────────
 def ensure_line(r):
     while len(state.input_lines) <= r:
         state.input_lines.append("")
 
-def cur_line():
-    r, c = state.input_cursor
-    ensure_line(r)
-    return state.input_lines[r]
-
 def input_key(key, panel_h):
-    r, c = state.input_cursor
+    r, c    = state.input_cursor
     inner_h = panel_h - 3
-
     if key == curses.KEY_UP:
         if r > 0:
-            r -= 1
-            c = min(c, len(state.input_lines[r]) if r < len(state.input_lines) else 0)
-            if r < state.input_scroll:
-                state.input_scroll = r
+            r -= 1; c = min(c, len(state.input_lines[r]) if r < len(state.input_lines) else 0)
+            if r < state.input_scroll: state.input_scroll = r
     elif key == curses.KEY_DOWN:
         if r < len(state.input_lines) - 1:
-            r += 1
-            c = min(c, len(state.input_lines[r]))
-            if r >= state.input_scroll + inner_h:
-                state.input_scroll = r - inner_h + 1
+            r += 1; c = min(c, len(state.input_lines[r]))
+            if r >= state.input_scroll + inner_h: state.input_scroll = r - inner_h + 1
     elif key == curses.KEY_LEFT:
-        if c > 0:
-            c -= 1
-        elif r > 0:
-            r -= 1
-            c = len(state.input_lines[r])
+        if c > 0: c -= 1
+        elif r > 0: r -= 1; c = len(state.input_lines[r])
     elif key == curses.KEY_RIGHT:
-        line = cur_line()
-        if c < len(line):
-            c += 1
-        elif r < len(state.input_lines) - 1:
-            r += 1; c = 0
-    elif key == curses.KEY_HOME:
-        c = 0
-    elif key == curses.KEY_END:
-        c = len(cur_line())
-    elif key in (curses.KEY_BACKSPACE, 127, 8):
         ensure_line(r)
-        line = state.input_lines[r]
-        if c > 0:
-            state.input_lines[r] = line[:c-1] + line[c:]
-            c -= 1
+        if c < len(state.input_lines[r]): c += 1
+        elif r < len(state.input_lines) - 1: r += 1; c = 0
+    elif key == curses.KEY_HOME: c = 0
+    elif key == curses.KEY_END:  ensure_line(r); c = len(state.input_lines[r])
+    elif key in (curses.KEY_BACKSPACE, 127, 8):
+        ensure_line(r); ln = state.input_lines[r]
+        if c > 0: state.input_lines[r] = ln[:c-1] + ln[c:]; c -= 1
         elif r > 0:
-            prev = state.input_lines[r-1]
-            c = len(prev)
-            state.input_lines[r-1] = prev + line
-            del state.input_lines[r]
-            r -= 1
-    elif key == curses.KEY_DC:  # Delete
-        ensure_line(r)
-        line = state.input_lines[r]
-        if c < len(line):
-            state.input_lines[r] = line[:c] + line[c+1:]
+            prev = state.input_lines[r-1]; c = len(prev)
+            state.input_lines[r-1] = prev + ln; del state.input_lines[r]; r -= 1
+    elif key == curses.KEY_DC:
+        ensure_line(r); ln = state.input_lines[r]
+        if c < len(ln): state.input_lines[r] = ln[:c] + ln[c+1:]
         elif r < len(state.input_lines) - 1:
-            state.input_lines[r] = line + state.input_lines[r+1]
-            del state.input_lines[r+1]
-    elif key in (10, 13):  # Enter
-        ensure_line(r)
-        line = state.input_lines[r]
-        state.input_lines[r] = line[:c]
-        state.input_lines.insert(r+1, line[c:])
+            state.input_lines[r] = ln + state.input_lines[r+1]; del state.input_lines[r+1]
+    elif key in (10, 13):
+        ensure_line(r); ln = state.input_lines[r]
+        state.input_lines[r] = ln[:c]; state.input_lines.insert(r+1, ln[c:])
         r += 1; c = 0
-        if r >= state.input_scroll + inner_h:
-            state.input_scroll += 1
-    elif 32 <= key <= 126:  # printable
-        ensure_line(r)
-        line = state.input_lines[r]
-        state.input_lines[r] = line[:c] + chr(key) + line[c:]
-        c += 1
-
+        if r >= state.input_scroll + inner_h: state.input_scroll += 1
+    elif 32 <= key <= 126:
+        ensure_line(r); ln = state.input_lines[r]
+        state.input_lines[r] = ln[:c] + chr(key) + ln[c:]; c += 1
     state.input_cursor = [r, c]
 
-# ── MAIN TUI LOOP ─────────────────────────────────────────────────────────────
+# ── MAIN ──────────────────────────────────────────────────────────────────────
+
+# ── IMPROVED MEMORY GRID PANEL ────────────────────────────────────────────────
+def draw_mem_grid_panel(win, active):
+    """
+    Standalone memory grid panel with improved spacing and visual design.
+    Layout:
+      Row 0  : border + title
+      Row 1  : register bar
+      Row 2  : separator + legend
+      Row 3+ : grid cells, each rendered as a styled block
+    Each cell:  addr(2) + space + [content(4)] = 9 chars wide with 1-char gap = 10
+    Colour:  cyan=instruction  green=data  dim=empty  yellow+reverse=IC pointer
+    """
+    draw_box(win, "MEMORY  [F4] ↑↓scroll", active)
+    h, w    = win.getmaxyx()
+    inner_h = h - 2
+    inner_w = w - 2
+    mem     = state.memory
+
+    if not mem.loaded:
+        msg = "No memory yet — run a program (R)"
+        safe_addstr(win, inner_h // 2,
+                    max(1, (inner_w - len(msg)) // 2),
+                    msg, curses.color_pair(C_DIM))
+        return
+
+    # ── Row 1: register bar ───────────────────────────────────────────────────
+    ir_s  = mem.ir.rstrip()  or '----'
+    r_s   = mem.r_reg.rstrip() or '----'
+    reg   = f" IC={mem.ic:02d}  IR={ir_s:<4}  R={r_s:<4}  C={mem.c_reg}  SI={mem.si}"
+    safe_addstr(win, 1, 1, reg[:inner_w], curses.color_pair(C_YELLOW) | curses.A_BOLD)
+
+    # ── Row 2: legend ─────────────────────────────────────────────────────────
+    used  = sum(1 for _, t in mem.cells if t != 'E')
+    instr = sum(1 for _, t in mem.cells if t == 'I')
+    data  = sum(1 for _, t in mem.cells if t == 'D')
+    stats = f"  {used}/100 cells   {instr} instr   {data} data"
+    safe_addstr(win, 2, 1, stats[:inner_w], curses.color_pair(C_DIM))
+    # colour swatches
+    try:
+        win.addstr(2, 2,  "▐", curses.color_pair(C_MEM_INSTR) | curses.A_BOLD)
+        win.addstr(2, 12, "▐", curses.color_pair(C_MEM_DATA))
+    except curses.error:
+        pass
+
+    # ── Row 3: column headers ─────────────────────────────────────────────────
+    # cell_w = 9: " XX[CCCC]" — space + addr(2) + bracket + content(4) + bracket
+    cell_w = 9
+    cols   = max(1, min(10, inner_w // cell_w))
+    # header row: column indices 0..cols-1
+    hdr = ""
+    for c in range(cols):
+        hdr += f"  +{c}     "[:cell_w]
+    safe_addstr(win, 3, 1, hdr[:inner_w], curses.color_pair(C_DIM))
+
+    # ── Rows 4+: grid ─────────────────────────────────────────────────────────
+    content_y = 4
+    avail_h   = inner_h - content_y
+    total_rows = (100 + cols - 1) // cols
+
+    max_scroll = max(0, total_rows - avail_h)
+    if state.mem_scroll > max_scroll:
+        state.mem_scroll = max_scroll
+
+    for r in range(avail_h):
+        row_idx = r + state.mem_scroll
+        if row_idx >= total_rows:
+            break
+        y = content_y + r
+
+        # row base address label
+        base = row_idx * cols
+        lbl  = f"{base:02d}"
+        safe_addstr(win, y, 1, lbl, curses.color_pair(C_DIM) | curses.A_BOLD)
+
+        for c in range(cols):
+            addr = base + c
+            if addr >= 100:
+                break
+            cell_content, typ = mem.cells[addr]
+            is_ic = (addr == mem.ic)
+            x     = 1 + c * cell_w   # start of this cell
+
+            # addr in dim (small, 2 chars)
+            safe_addstr(win, y, x, f"{addr:02d}", curses.color_pair(C_DIM))
+
+            # content block: [CCCC]
+            bracket_attr = _cell_attr(typ, is_ic)
+            if is_ic:
+                block = f">{cell_content}<"
+            elif typ == 'E':
+                block = " ·  "           # empty placeholder — dots look cleaner
+            else:
+                block = cell_content     # exactly 4 chars from dump
+            safe_addstr(win, y, x + 2, f"[{block}]", bracket_attr)
+
+    # ── Scrollbar indicator ───────────────────────────────────────────────────
+    if total_rows > avail_h:
+        pct = state.mem_scroll / max(1, total_rows - avail_h)
+        bar_y = content_y + int(pct * (avail_h - 1))
+        safe_addstr(win, bar_y, inner_w, "▐", curses.color_pair(C_DIM))
+
+
+# ── EXEC METRICS PANEL ────────────────────────────────────────────────────────
+def draw_metrics_panel(win, active):
+    draw_box(win, "EXECUTION METRICS  [F5]", active)
+    h, w    = win.getmaxyx()
+    inner_h = h - 2
+    inner_w = w - 2
+    hist    = state.run_history
+    y       = 1
+
+    # ── Stat cards ────────────────────────────────────────────────────────────
+    et   = f"{state.exec_time_ms:.4f}ms" if state.exec_time_ms else "---"
+    cw   = max(1, inner_w // 3)
+    for i, (lbl, val, col) in enumerate([
+        ("EXEC TIME",  et,                   C_GREEN),
+        ("TOTAL RUNS", str(state.run_count), C_BORDER),
+        ("LAST RUN",   hist[-1][0] if hist else "---", C_YELLOW),
+    ]):
+        bx = 1 + i * cw
+        safe_addstr(win, y,   bx, lbl[:cw-1],
+                    curses.color_pair(C_DIM))
+        safe_addstr(win, y+1, bx, val[:cw-1],
+                    curses.color_pair(col) | curses.A_BOLD)
+    y += 3
+
+    safe_addstr(win, y, 1, "─" * inner_w, curses.color_pair(C_DIM)); y += 1
+
+    if not hist:
+        safe_addstr(win, y, 1, " Run a program to see chart", curses.color_pair(C_DIM))
+        return
+
+    # ── Bar chart ─────────────────────────────────────────────────────────────
+    safe_addstr(win, y, 1, " EXEC TIME (ms) per run:",
+                curses.color_pair(C_DIM)); y += 1
+
+    bottom    = inner_h        # last usable row inside border
+    bar_area  = bottom - y - 2
+    if bar_area < 2:
+        return
+
+    max_ms    = max(r[1] for r in hist)
+    BAR_W, SP = 6, 2
+    max_bars  = max(1, inner_w // (BAR_W + SP))
+    visible   = hist[-max_bars:]
+    BAR_COLS  = [C_BORDER, C_GREEN, C_YELLOW, C_ORANGE, C_RED]
+
+    for bi, (label, ms) in enumerate(visible):
+        bh   = max(1, int((ms / max_ms) * bar_area)) if max_ms > 0 else 1
+        bx   = 1 + bi * (BAR_W + SP)
+        col  = curses.color_pair(BAR_COLS[bi % len(BAR_COLS)]) | curses.A_BOLD
+        dim  = curses.color_pair(C_DIM)
+
+        for brow in range(bar_area):
+            ry = y + bar_area - 1 - brow
+            if ry >= h - 1:
+                continue
+            if brow < bh:
+                safe_addstr(win, ry, bx, "█" * BAR_W, col)
+            else:
+                safe_addstr(win, ry, bx, "░" * BAR_W, dim)
+
+        # value above bar
+        val_s = f"{ms:.2f}"[:BAR_W]
+        safe_addstr(win, y - 1, bx, val_s.center(BAR_W),
+                    curses.color_pair(C_YELLOW))
+
+        # label below
+        run_lbl = label.split()[-1][:BAR_W]
+        lbl_y   = y + bar_area
+        if lbl_y < h - 1:
+            safe_addstr(win, lbl_y, bx, run_lbl.center(BAR_W),
+                        curses.color_pair(C_DIM))
+
+    # ── Sparkline ─────────────────────────────────────────────────────────────
+    spark_y = y + bar_area + 1
+    if spark_y < h - 1 and len(hist) > 1:
+        SPARK  = " ▁▂▃▄▅▆▇█"
+        max_v  = max(r[1] for r in hist)
+        sp_str = "".join(
+            SPARK[min(8, int((r[1] / max_v) * 8))]
+            for r in hist[-(inner_w - 4):]
+        )
+        safe_addstr(win, spark_y, 1, "▸ " + sp_str, curses.color_pair(C_BORDER))
+
+
+# ── MAIN ──────────────────────────────────────────────────────────────────────
 def main(stdscr):
     curses.curs_set(0)
     curses.start_color()
     curses.use_default_colors()
-
-    curses.init_pair(C_NORMAL,   curses.COLOR_WHITE,   -1)
-    curses.init_pair(C_BORDER,   curses.COLOR_CYAN,    -1)
-    curses.init_pair(C_TITLE,    curses.COLOR_CYAN,    -1)
-    curses.init_pair(C_GREEN,    curses.COLOR_GREEN,   -1)
-    curses.init_pair(C_YELLOW,   curses.COLOR_YELLOW,  -1)
-    curses.init_pair(C_RED,      curses.COLOR_RED,     -1)
-    curses.init_pair(C_DIM,      curses.COLOR_WHITE,   -1)
-    curses.init_pair(C_HEADER,   curses.COLOR_BLACK,   curses.COLOR_CYAN)
-    curses.init_pair(C_INPUT,    curses.COLOR_GREEN,   -1)
-    curses.init_pair(C_ORANGE,   curses.COLOR_YELLOW,  -1)
-    curses.init_pair(C_STAT_VAL, curses.COLOR_CYAN,    -1)
+    for pair, fg, bg in [
+        (C_NORMAL,  curses.COLOR_WHITE,   -1),
+        (C_BORDER,  curses.COLOR_CYAN,    -1),
+        (C_TITLE,   curses.COLOR_CYAN,    -1),
+        (C_GREEN,   curses.COLOR_GREEN,   -1),
+        (C_YELLOW,  curses.COLOR_YELLOW,  -1),
+        (C_RED,     curses.COLOR_RED,     -1),
+        (C_DIM,     curses.COLOR_WHITE,   -1),
+        (C_HEADER,  curses.COLOR_BLACK,   curses.COLOR_CYAN),
+        (C_INPUT,   curses.COLOR_GREEN,   -1),
+        (C_ORANGE,  curses.COLOR_YELLOW,  -1),
+        (C_MAGENTA, curses.COLOR_MAGENTA, -1),
+        (C_BLUE,    curses.COLOR_BLUE,    -1),
+    ]:
+        curses.init_pair(pair, fg, bg)
 
     stdscr.nodelay(True)
     stdscr.keypad(True)
@@ -640,49 +997,71 @@ def main(stdscr):
     state.add_debug("INFO", "MOS Terminal UI started")
     state.add_debug("INFO", f"Working dir: {_CWD}")
     if os.path.exists(SOURCE):
-        state.add_debug("OK",   f"Found OS_CP.c — press F6 to compile")
+        state.add_debug("OK",   "Found OS_CP.c — F6 compile, R run")
+        state.add_debug("INFO", "F1:Input  F2:Debug  F3:Output  F4:Memory  F5:Metrics")
     else:
         state.add_debug("ERR",  f"OS_CP.c not found in: {_CWD}")
-        state.add_debug("WARN", "cd into your project folder, then rerun ./mos.sh")
+        state.add_debug("WARN", "cd into project folder and rerun ./mos.sh")
 
     load_sample()
-
-    _running_thread = [None]
+    _running = [None]
 
     def redraw():
         try:
             H, W = stdscr.getmaxyx()
-            if H < 20 or W < 60:
+            if H < 24 or W < 80:
                 stdscr.clear()
-                stdscr.addstr(0, 0, "Terminal too small! Need 60x20 minimum.", curses.A_BOLD)
+                stdscr.addstr(0, 0,
+                    f"Terminal too small — need 80x24 min (now {W}x{H})",
+                    curses.A_BOLD)
                 stdscr.refresh()
                 return
 
             stdscr.erase()
 
-            # Layout: title(1) + panels(H-3) + statusbar(1) + gap(1)
-            content_h = H - 2   # minus title and status
-            half_h    = content_h // 2
-            half_w    = W // 2
+            # ── Layout ────────────────────────────────────────────────────────
+            #
+            #  title (1 row)
+            #  ┌──────────────────┬──────────────────────────────┐
+            #  │  INPUT  [F1]     │  DEBUG LOG  [F2]             │  top_h rows
+            #  ├────────┬─────────┼──────────────────────────────┤
+            #  │ OUTPUT │ MEMORY  │  EXEC METRICS  [F5]          │  bot_h rows
+            #  │  [F3]  │  [F4]  │                              │
+            #  └────────┴─────────┴──────────────────────────────┘
+            #  status (1 row)
+            #
+            content_h = H - 2          # minus title + status
+            top_h     = content_h // 2
+            bot_h     = content_h - top_h
+
+            # Column split: left 60% | right 40%
+            left_w    = (W * 6) // 10
+            right_w   = W - left_w
+
+            # Bottom-left further split: output | memory  (50/50 of left_w)
+            out_w     = left_w // 2
+            mem_w     = left_w - out_w
 
             draw_titlebar(stdscr, W)
             draw_statusbar(stdscr, H, W)
 
-            # Create sub-windows (top-left, top-right, bot-left, bot-right)
-            panels = [
-                stdscr.derwin(half_h,       half_w,       1,       0),
-                stdscr.derwin(half_h,       W - half_w,   1,       half_w),
-                stdscr.derwin(content_h - half_h, half_w, 1+half_h, 0),
-                stdscr.derwin(content_h - half_h, W-half_w, 1+half_h, half_w),
-            ]
+            # Top row
+            p_input  = stdscr.derwin(top_h, left_w,  1, 0)
+            p_debug  = stdscr.derwin(top_h, right_w, 1, left_w)
+
+            # Bottom row
+            p_output  = stdscr.derwin(bot_h, out_w,   1 + top_h, 0)
+            p_memory  = stdscr.derwin(bot_h, mem_w,   1 + top_h, out_w)
+            p_metrics = stdscr.derwin(bot_h, right_w, 1 + top_h, left_w)
 
-            draw_input_panel (panels[0], state.focus == 0)
-            draw_debug_panel (panels[1], state.focus == 1)
-            draw_output_panel(panels[2], state.focus == 2)
-            draw_chart_panel (panels[3], state.focus == 3)
+            draw_input_panel   (p_input,   state.focus == 0)
+            draw_debug_panel   (p_debug,   state.focus == 1)
+            draw_output_panel  (p_output,  state.focus == 2)
+            draw_mem_grid_panel(p_memory,  state.focus == 3)
+            draw_metrics_panel (p_metrics, state.focus == 4)
 
             stdscr.refresh()
-            for p in panels:
+            for p in (p_input, p_debug, p_output, p_memory, p_metrics):
                 p.refresh()
         except curses.error:
             pass
@@ -691,109 +1070,97 @@ def main(stdscr):
 
     while True:
         now = time.monotonic()
-        if now - last_draw[0] > 0.08:   # ~12fps
-            redraw()
-            last_draw[0] = now
+        if now - last_draw[0] > 0.05:
+            redraw(); last_draw[0] = now
 
         key = stdscr.getch()
         if key == -1:
-            time.sleep(0.02)
-            continue
+            time.sleep(0.02); continue
 
-        H, W = stdscr.getmaxyx()
-        half_h = (H - 2) // 2
+        H, W   = stdscr.getmaxyx()
+        top_h  = (H - 2) // 2
 
-        # ── GLOBAL KEYS ──
+        # ── Global keys ───────────────────────────────────────────────────────
         if key in (ord('q'), ord('Q')):
             break
 
-        elif key == curses.KEY_F1:
-            state.focus = 0
-        elif key == curses.KEY_F2:
-            state.focus = 1
-        elif key == curses.KEY_F3:
-            state.focus = 2
-        elif key == curses.KEY_F4:
-            state.focus = 3
+        elif key == curses.KEY_F1: state.focus = 0
+        elif key == curses.KEY_F2: state.focus = 1
+        elif key == curses.KEY_F3: state.focus = 2
+        elif key == curses.KEY_F4: state.focus = 3
+        elif key == curses.KEY_F5: state.focus = 4
 
         elif key == curses.KEY_F6:
-            # Compile
-            state.status = "COMPILING"
-            state.compiled = False
-            redraw()
-            if compile_source():
-                state.status = "READY"
-            else:
-                state.status = "ERROR"
-
-        elif key == curses.KEY_F5:
-            # Run
-            if not state.compiled:
-                state.add_debug("WARN", "Not compiled — press F6 first")
-            elif _running_thread[0] and _running_thread[0].is_alive():
-                state.add_debug("WARN", "Already running")
-            else:
-                input_text = "\n".join(state.input_lines) + "\n"
-                state.run_count += 1
-                state.output_lines = []
-                state.output_scroll = 0
-                state.debug_scroll = 0
-
-                def done():
-                    state.focus = 2          # auto-switch to Output panel
-                    state.output_scroll = 0  # scroll to top of output
-                    redraw()
-
-                t = threading.Thread(target=run_program, args=(input_text, done), daemon=True)
-                _running_thread[0] = t
-                t.start()
-
-        # ── F2 sample key (also mapped to load sample when focus=input) ──
-        elif key == ord('s') or key == ord('S'):
-            if state.focus == 0:
-                load_sample()
-
-        elif key == ord('c') or key == ord('C'):
-            if state.focus == 0:
-                state.input_lines = []
+            state.status = "COMPILING"; state.compiled = False; redraw()
+            state.status = "READY" if compile_source() else "ERROR"
+
+        elif key in (ord('r'), ord('R')):
+            _do_run(_running, redraw)
+
+        elif key in (ord('s'), ord('S')):
+            if state.focus == 0: load_sample()
+
+        elif key in (ord('c'), ord('C')):
+            if   state.focus == 0:
+                state.input_lines  = []
                 state.input_cursor = [0, 0]
                 state.input_scroll = 0
                 state.add_debug("INFO", "Input cleared")
-            elif state.focus == 1:
-                state.debug_lines = []
-            elif state.focus == 2:
-                state.output_lines = []
+            elif state.focus == 1: state.debug_lines  = []
+            elif state.focus == 2: state.output_lines = []
 
-        # ── FOCUS-SPECIFIC NAVIGATION ──
+        # ── Focus-specific nav ────────────────────────────────────────────────
         elif state.focus == 0:
-            input_key(key, half_h)
+            input_key(key, top_h)
 
         elif state.focus == 1:
-            if key == curses.KEY_UP:
-                state.debug_scroll = max(0, state.debug_scroll - 1)
-            elif key == curses.KEY_DOWN:
-                state.debug_scroll += 1
-            elif key == curses.KEY_PPAGE:
-                state.debug_scroll = max(0, state.debug_scroll - 10)
-            elif key == curses.KEY_NPAGE:
-                state.debug_scroll += 10
+            if   key == curses.KEY_UP:    state.debug_scroll = max(0, state.debug_scroll - 1)
+            elif key == curses.KEY_DOWN:  state.debug_scroll += 1
+            elif key == curses.KEY_PPAGE: state.debug_scroll = max(0, state.debug_scroll - 10)
+            elif key == curses.KEY_NPAGE: state.debug_scroll += 10
             elif key == ord('G'):
-                state.debug_scroll = max(0, len(state.debug_lines) - (half_h - 2))
+                state.debug_scroll = max(0, len(state.debug_lines) - (top_h - 2))
 
         elif state.focus == 2:
-            if key == curses.KEY_UP:
-                state.output_scroll = max(0, state.output_scroll - 1)
-            elif key == curses.KEY_DOWN:
-                state.output_scroll += 1
-            elif key == curses.KEY_PPAGE:
-                state.output_scroll = max(0, state.output_scroll - 10)
-            elif key == curses.KEY_NPAGE:
-                state.output_scroll += 10
+            if   key == curses.KEY_UP:    state.output_scroll = max(0, state.output_scroll - 1)
+            elif key == curses.KEY_DOWN:  state.output_scroll += 1
+            elif key == curses.KEY_PPAGE: state.output_scroll = max(0, state.output_scroll - 10)
+            elif key == curses.KEY_NPAGE: state.output_scroll += 10
 
         elif state.focus == 3:
-            pass  # chart panel is display-only
+            if   key == curses.KEY_UP:    state.mem_scroll = max(0, state.mem_scroll - 1)
+            elif key == curses.KEY_DOWN:  state.mem_scroll += 1
+            elif key == curses.KEY_PPAGE: state.mem_scroll = max(0, state.mem_scroll - 5)
+            elif key == curses.KEY_NPAGE: state.mem_scroll += 5
+
+        elif state.focus == 4:
+            pass  # metrics panel is display-only
+
+
+def _do_run(running_ref, redraw_fn):
+    if not state.compiled:
+        state.add_debug("WARN", "Not compiled — press F6 first"); return
+    if running_ref[0] and running_ref[0].is_alive():
+        state.add_debug("WARN", "Already running"); return
+
+    input_text          = "\n".join(state.input_lines) + "\n"
+    state.run_count    += 1
+    state.output_lines  = []
+    state.output_scroll = 0
+    state.debug_scroll  = 0
+    state.mem_scroll    = 0
+
+    def done():
+        state.focus      = 2   # switch to output first, user can press F4 for memory
+        state.mem_scroll = 0
+        redraw_fn()
+
+    t = threading.Thread(target=run_program, args=(input_text, done), daemon=True)
+    running_ref[0] = t
+    t.start()
+
 
-# ── ENTRY POINT ───────────────────────────────────────────────────────────────
+# ── ENTRY ─────────────────────────────────────────────────────────────────────
 def entry():
     os.environ.setdefault('TERM', 'xterm-256color')
     try:
@@ -801,11 +1168,10 @@ def entry():
     except KeyboardInterrupt:
         pass
     finally:
-        # cleanup binary
         if os.path.exists(BINARY):
             try: os.unlink(BINARY)
             except: pass
-    print("\n\033[36mMOS TUI exited.\033[0m Thanks for using the simulator!")
+    print("\n\033[36mMOS TUI exited.\033[0m")
 
 if __name__ == "__main__":
     entry()