@modelstatus/cli 0.1.47 → 0.1.49

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelstatus/cli",
-  "version": "0.1.47",
+  "version": "0.1.49",
   "description": "Track which AI models you use, where, and never get surprised by a retirement. Free offline model-health for any repo (mm status), browser sign-in for cloud inventory + alerts.",
   "keywords": [
     "llm",

package/src/tui/app.js

@@ -69,11 +69,17 @@ function useTermDims() {
   const cols = Number.isFinite(fw) && fw > 0 ? fw : dims.cols;
   const rows = Number.isFinite(fh) && fh > 0 ? fh : dims.rows;
   // Never exceed the real terminal width (a wider frame soft-wraps every chrome
-  // line and shatters the window). Fill the FULL terminal height: when the frame
-  // height ≥ the terminal rows, ink redraws with a full clear each frame; render
-  // shorter than the screen (the old 80-row cap did this on tall external
-  // monitors) and ink falls back to cursor-up diffing, which drifts/scrolls.
-  return { outer: Math.min(cols || 80, 220), termRows: Math.max(8, Math.min(rows || 24, 200)) };
+  // line and shatters the window).
+  //
+  // Height: RESERVE THE LAST ROW (rows - 1). A frame that fills the full height
+  // makes ink write+newline the bottom line, which scrolls the buffer up by 1
+  // EVERY render; across the handful of renders during load/settle that scroll
+  // accumulates and creeps the window's top off-screen (the "not full-screen after
+  // the game / in Warp" clip). One row short keeps the last line blank so nothing
+  // ever scrolls. This is safe now that the TUI lives in the ALT SCREEN: ink's
+  // cursor-up diffing (which it uses when the frame is shorter than the terminal)
+  // stays inside the fixed alt buffer and can't drift the way it did inline.
+  return { outer: Math.min(cols || 80, 220), termRows: Math.max(8, Math.min((rows || 24) - 1, 200)) };
 }
 
 function PromptRow({ prompt }) {
@@ -269,12 +275,37 @@ export const appController = {
   remount(next = {}) {
     const opts = { ...(this._opts || {}), ...next };
     this._opts = opts;
+    // We're still in the alt screen (entered by runApp; the game kept it). Clear +
+    // home so the fresh Ink tree paints the whole screen from the top with no
+    // leftover game frame and no inline-cursor drift.
+    try { process.stdout.write("\x1b[2J\x1b[H"); } catch { /* ignore */ }
     this._instance = render(h(Bootstrap, opts));
     return this._instance;
   },
 };
 
 export function runApp(opts) {
+  // Run the TUI in the ALTERNATE SCREEN BUFFER (a clean full-screen surface, like
+  // the game). Ink's default INLINE rendering drifts after the game's alt-screen
+  // round-trip in block-model terminals (Warp) — the window scrolls off the top
+  // and Ctrl-L can't recover it. Owning the alt screen ourselves makes every
+  // (re)mount paint a clean full screen, and leaving it on quit restores the
+  // host's scrollback. The in-TUI game keeps this alt screen (keepAlt) instead of
+  // toggling its own, so there's no unreliable nested-alt-screen handling.
+  const out = process.stdout;
+  const leaveAlt = () => {
+    if (!appController._inAlt) return;
+    try { out.write("\x1b[?1049l\x1b[?25h"); } catch { /* ignore */ }
+    appController._inAlt = false;
+  };
+  appController._leaveAlt = leaveAlt;
+  // Never strand the terminal in the alt buffer on a crash/signal.
+  process.once("exit", leaveAlt);
+  process.once("SIGINT", () => { leaveAlt(); process.exit(130); });
+  process.once("SIGTERM", () => { leaveAlt(); process.exit(143); });
+  try { out.write("\x1b[?1049h\x1b[2J\x1b[H"); } catch { /* ignore */ }
+  appController._inAlt = true;
+
   appController._opts = opts;
   const app = render(h(Bootstrap, opts));
   appController._instance = app;
@@ -289,6 +320,7 @@ export function runApp(opts) {
         if (appController._instance && appController._instance !== inst) {
           arm(appController._instance);
         } else {
+          leaveAlt(); // real quit → restore the host screen + scrollback
           resolve();
         }
       });

package/src/tui/game/launch.js

@@ -67,6 +67,7 @@ export async function playGameInTui({ dir, width, height, initialView = "scan",
         height: process.stdout.rows || height,
         level: 1,
         scanStore: handle,
+        inTui: true, // render in the TUI's alt screen; don't toggle a nested one
       });
     } finally {
       try { handle && handle.abort(); } catch { /* ignore */ }
@@ -80,12 +81,10 @@ export async function playGameInTui({ dir, width, height, initialView = "scan",
     // TUI comes back shifted down / not full-height until the next resize. Reset
     // the scroll region (\x1b[r), clear the screen, and home the cursor so the
     // remounted tree fills the whole terminal from the top (same as Ctrl-L).
-    try { process.stdout.write("\x1b[r\x1b[2J\x1b[3J\x1b[H"); } catch { /* ignore */ }
-    // Let the terminal re-flow after leaving the alt screen before Ink measures —
-    // some terminals (Warp's block model) report a stale size for a beat, which
-    // would make Ink render too short and drift. useTermDims also re-measures a
-    // few beats post-mount as a backstop.
-    await new Promise((r) => setTimeout(r, 80));
+    // The game kept the TUI's alt screen intact (inTui → keepAlt), so we never
+    // left it — just let the game's restore() flush, then remount. remount() clears
+    // + homes inside the alt screen so the fresh tree paints a clean full screen.
+    await new Promise((r) => setImmediate(r));
     appController.remount({ initialView, fresh: false });
   } catch (e) {
     if (onError) onError(e); else throw e;

package/src/tui/game/loop.js

@@ -74,7 +74,7 @@ const fmtNum = (n) => (n == null ? "0" : Number(n).toLocaleString("en-US"));
  * @param {object} [o._inject]        test seams: { out, inp, proc, now, schedule, autoExitAfterMs }
  * @returns {Promise<{score:number, level:number, best:number, status:string}>}
  */
-export function runGame({ width, height, level = 1, scanStore = null, onExit, _inject = {} } = {}) {
+export function runGame({ width, height, level = 1, scanStore = null, onExit, inTui = false, _inject = {} } = {}) {
   return new Promise((resolve) => {
     const proc = _inject.proc || process;
     const out = _inject.out || proc.stdout || process.stdout;
@@ -89,7 +89,7 @@ export function runGame({ width, height, level = 1, scanStore = null, onExit, _i
     try { best = Number(loadConfig().dkHighScore) || 0; } catch { best = 0; }
 
     const dims = { width, height };
-    const term = new Term({ out, inp, proc, color: COLOR_ON });
+    const term = new Term({ out, inp, proc, color: COLOR_ON, keepAlt: inTui });
     const input = new InputState({ now });
 
     // Allocate the buffer for the WHOLE frame: HUD rows + board + key row, BOARD_W

package/src/tui/game/term.js

@@ -216,11 +216,17 @@ export class Term {
     inp = process.stdin,
     proc = process,
     color = COLOR_ON,
+    // When launched from inside the TUI (which now OWNS the alternate screen),
+    // don't toggle the alt buffer ourselves — render into the TUI's alt screen and
+    // leave it intact on exit so the remounted TUI stays on a clean full screen
+    // (toggling a nested alt screen is unreliable, esp. in Warp's block model).
+    keepAlt = false,
   } = {}) {
     this.out = out;
     this.inp = inp;
     this.proc = proc;
     this.color = color;
+    this.keepAlt = keepAlt;
     this.started = false;
     this.restored = false;
     this._wasRaw = false;
@@ -241,8 +247,9 @@ export class Term {
 
     // Enter alt screen + hide cursor ONCE (never per frame — that's the anti-
     // flicker invariant). Clear the alt buffer so a stale prior frame can't show
-    // through before the first diff paints.
-    this.write(ALT_ENTER + CURSOR_HIDE + CLEAR_SCREEN);
+    // through before the first diff paints. keepAlt → the TUI already owns the alt
+    // screen, so only hide-cursor + clear (don't re-enter / nest the alt buffer).
+    this.write((this.keepAlt ? "" : ALT_ENTER) + CURSOR_HIDE + CLEAR_SCREEN);
 
     // Raw mode so we get bytes immediately (no line buffering / no echo). Save
     // the prior state so restore() returns the terminal exactly as it was.
@@ -300,8 +307,10 @@ export class Term {
     this.restored = true;
 
     // Order matters: reset SGR + show cursor + leave alt LAST so the chrome
-    // lands back on the normal buffer with a visible cooked cursor.
-    try { this.write(SGR_RESET + CURSOR_SHOW + ALT_LEAVE); } catch {}
+    // lands back on the normal buffer with a visible cooked cursor. keepAlt → the
+    // TUI owns the alt screen and will remount into it, so only reset SGR (don't
+    // show the cursor or leave the alt buffer).
+    try { this.write(this.keepAlt ? SGR_RESET : SGR_RESET + CURSOR_SHOW + ALT_LEAVE); } catch {}
 
     const inp = this.inp;
     try {