3 files changed, 33 insertions, 9 deletions

diff --git a/rsnix/src/fs.rs b/rsnix/src/fs.rs
index 95a84bf..df9308b 100644
--- a/rsnix/src/fs.rs
+++ b/rsnix/src/fs.rs
@@ -418,7 +418,7 @@ pub fn remove_path(path: &str) -> Result<(), ()> {
 
 fn version_text() -> String {
     alloc::format!(
-        "rsnix v{} — TempleOS-inspired toy kernel\nUEFI x86_64, identity paging, free-list heap, bitmap pages\n",
+        "rsnix v{} — Official RS-DOS kernel\nUEFI x86_64, identity paging, free-list heap, bitmap pages\n",
         env!("CARGO_PKG_VERSION")
     )
 }
diff --git a/rsnix/src/memory.rs b/rsnix/src/memory.rs
index d33c781..c80edab 100644
--- a/rsnix/src/memory.rs
+++ b/rsnix/src/memory.rs
@@ -436,6 +436,11 @@ pub fn heap_stats() -> HeapStats {
 /// the heap itself (fixed-size stack arrays only).  Returns true on success.
 pub fn self_test() -> bool {
     unsafe {
+        // Snapshot the heap before we start: earlier boot code (e.g. the
+        // vt cell grids) may legitimately hold live allocations.  The test
+        // must return the heap to exactly this state, not to "empty".
+        let before = heap_stats();
+
         const N: usize = 128;
         // (ptr, size, align) triplets — fixed array on the stack.
         let mut blocks: [(usize, usize, usize); N] = [(0, 0, 0); N];
@@ -504,7 +509,7 @@ pub fn self_test() -> bool {
             ALLOCATOR.dealloc(*ptr as *mut u8, layout);
         }
         let stats = heap_stats();
-        stats.free_blocks == 1 && stats.free_bytes == stats.heap_size
+        stats.free_blocks == before.free_blocks && stats.free_bytes == before.free_bytes
     }
 }
 
diff --git a/rsnix/src/vt.rs b/rsnix/src/vt.rs
index 3b81d68..4db08fc 100644
--- a/rsnix/src/vt.rs
+++ b/rsnix/src/vt.rs
@@ -485,20 +485,29 @@ pub fn clear_all() {
 // ---------------------------------------------------------------------------
 
 /// Blit every cell whose content differs from what the framebuffer shows,
-/// then draw the logical cursor (inverse video) on top.
+/// then draw the logical cursor (inverse video) on top.  The cursor's
+/// inverse colours are mirrored into RENDERED so that pixel shifts
+/// (scrolling) or full clears can never leave a stale inverse block that
+/// the diff can't see (blank-vs-blank).
 fn flush() {
     let rows = unsafe { ROWS };
     let cols = unsafe { COLS };
     let n = rows * cols;
+    let cursor_visible = unsafe { CURSOR_VISIBLE };
+    let (cr, cc) = unsafe { (CURSOR_R, CURSOR_C) };
     {
         let cells = cells();
         let rendered = rendered_cells();
         for i in 0..n {
+            let row = i / cols;
+            let col = i % cols;
+            // The visible cursor cell is owned by the cursor pass below.
+            if cursor_visible && row == cr && col == cc {
+                continue;
+            }
             let c = cells[i];
             let r = rendered[i];
             if c != r {
-                let row = i / cols;
-                let col = i % cols;
                 let fg = PALETTE[c.fg as usize];
                 let bg = PALETTE[c.bg as usize];
                 gop::blit_glyph(col, row, c.ch, fg, bg);
@@ -510,20 +519,30 @@ fn flush() {
     unsafe {
         let (lr, lc) = LAST_CURSOR;
         let moved = (lr, lc) != (CURSOR_R, CURSOR_C);
-        // Erase the previous cursor position (restore its normal colours).
+        // Erase the previous cursor position (restore its normal colours)
+        // and record it in RENDERED so the diff stays in sync.
         if (moved || !CURSOR_VISIBLE) && lr < rows && lc < cols {
-            let c = cells()[idx(lr, lc)];
+            let i = idx(lr, lc);
+            let c = cells()[i];
             let fg = PALETTE[c.fg as usize];
             let bg = PALETTE[c.bg as usize];
             gop::blit_glyph(lc, lr, c.ch, fg, bg);
+            rendered_cells()[i] = c;
         }
         LAST_CURSOR = (CURSOR_R, CURSOR_C);
-        // Draw the cursor as an inverse-video cell.
+        // Draw the cursor as an inverse-video cell, mirroring the inverse
+        // colours into RENDERED (scrolling/clearing then repair it).
         if CURSOR_VISIBLE && CURSOR_R < rows && CURSOR_C < cols {
-            let c = cells()[idx(CURSOR_R, CURSOR_C)];
+            let i = idx(CURSOR_R, CURSOR_C);
+            let c = cells()[i];
             let fg = PALETTE[c.fg as usize];
             let bg = PALETTE[c.bg as usize];
             gop::blit_glyph(CURSOR_C, CURSOR_R, c.ch, bg, fg);
+            rendered_cells()[i] = Cell {
+                ch: c.ch,
+                fg: c.bg,
+                bg: c.fg,
+            };
         }
     }
 }