Cheaper cursor, a fortify panic that names its function; Finch's gap

The cursor now costs nothing for a byte inside an escape sequence and
one cell fewer for a plain glyph: the grid is the truth, so the old
cursor cell is repainted after the byte, and not at all when a glyph
has just been drawn over it.

__fortify_panic says "r8169: rtl_open.cold+0x..." through ldlsd's module
list, so a photograph of the screen is enough, and exits instead of
spinning on a core and holding /dev/netdev.

docs/plan/finch.md: only integrating Finch is later; finishing it is
not. The self-hosting gap measured against Finch's own bootstrap test.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_015f73FesGZGYPkmDvUcj6QX

docs/plan/finch.md

@@ -1,8 +1,12 @@
 # Finch, for SchOS's own programs
 
-**Later. Not being worked on** — it is behind [1.0.md](1.0.md)'s freeze like
-everything else here that is not named there. This records the decision so it
-is not rediscovered.
+**Two things, and only one of them is later.**
+
+- *Bringing Finch into SchOS* (below) is **later** — behind [1.0.md](1.0.md)'s
+  freeze like everything else here that is not named there.
+- *Finishing Finch itself*, and making it fully self-hosting, is work on the
+  Finch repository and does not touch this tree. It can proceed now; see
+  [the gap](#the-self-hosting-gap).
 
 Finch is the author's own language: <https://pandor.pl/git/nexoniarz/Finch>
 (GitHub mirror: `Nexoniarz/Finch`). The plan is to write SchOS's own
@@ -31,7 +35,7 @@ Measured from the repository, not from its README alone:
 - **Tooling:** a language server (`finch lsp`), VS Code and Kate support, 74
   tests.
 - **Self-hosting:** `boot/` is a Finch compiler written in Finch (about 3,100
-  lines, against about 5,000 for the C++ one in `src/`) that builds itself to a
+  lines, against about 5,900 for the C++ one in `src/`, language server included) that builds itself to a
   byte-identical result — `tests/boot.sh`.
 
 ## What SchOS would need to do
@@ -53,16 +57,37 @@ Measured from the repository, not from its README alone:
    the headers in `include/uapi/`, so they are not hand-written and cannot
    drift from the kernel.
 
-## What "finishing Finch" means is not settled
+## The self-hosting gap
 
-The repository has no list of what is unfinished. Before work starts, the
-author names it. Candidates seen in the tree: `note.txt` and `notatka.txt` are
-scratch files; `OpenGL.fn` was deleted in the last commit; the `boot/` compiler
-is shorter than the C++ one, so some language features may exist only in the
-latter. **The first task is to diff the two feature sets**, not to guess.
+"Rewrite it in Finch itself" is mostly done: `boot/` compiles itself. What it
+does **not** yet do is stated by its own test, `tests/boot.sh`, which skips
+every test that uses a feature `boot/` lacks. Counting mentions in the two
+sources confirms it (`boot/` vs `src/`):
+
+| Feature | `boot/` | `src/` | Needed for |
+|---|---|---|---|
+| maps | 0 | 185 | `codegen_map.cpp` (242 lines) to port |
+| errors as values (`or`, `try`) | few | hundreds | most real programs |
+| methods on user types | 17 | 87 | partial |
+| `defer` | 2 | 31 | partial |
+| sized numbers (`u8`..`u64`, `i8`..`i32`, `f32`, `f64`) | none | throughout | kernel-facing code |
+| enums | 0 | 14 | |
+| C import (`import "x.h"`, `link`) | none | `cimport.cpp`, 373 lines on libclang | **the way into every C library, SchOS's included** |
+| target and ABI layer (AArch64, macOS, Windows) | 0 | `target.cpp`, `abi.cpp` | non-Linux-x86 targets |
+| language server | 0 | `lsp.cpp`, 580 lines | editors |
+
+So "finishing" has a concrete order: **errors as values and maps first** (they
+are what the rest uses), then sized numbers and `defer`, then C import — which
+needs libclang bindings, so it needs C import's own simpler form first — and
+the target layer last. `tests/boot.sh` is the measure: the list of skipped
+tests shrinks to nothing.
+
+The scratch files `note.txt` and `notatka.txt` in the repository are not
+Finch's and can go.
 
 ## Rules
 
-- Nothing in the kernel is rewritten in Finch. It is for applications and tools.
+- Inference, not an instruction: the kernel stays in C. Finch is for
+  applications and tools; the user said "our apps or stuff like that".
 - No new capability starts until [the register of unfinished work](1.0.md#the-freeze-and-the-register-of-unfinished-work)
-  is empty; this document is a plan, not an exception to that.
+  is empty; the SchOS half of this document is a plan, not an exception to that.