@modelstatus/cli 0.1.39 → 0.1.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelstatus/cli",
-  "version": "0.1.39",
+  "version": "0.1.41",
   "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/game/dk-core.js

@@ -85,7 +85,7 @@ export function bonusForLevel(level) {
   return 5000 + level * 1000;
 }
 
-const SCHEMA = 2;
+const SCHEMA = 3; // bumped: board contract now varies per level (N/slope/ladder placement)
 
 // ---- Level scaling (pure, tested monotonic) --------------------------------
 /** DK barrel-throw cadence in TICKS — faster (shorter) as you climb. */
@@ -121,16 +121,145 @@ export function boardSize(width, height) {
   return { BOARD_W, BOARD_H };
 }
 
-function buildSlope(baseRow, w, down, amp) {
+function buildSlope(baseRow, w, down, amp, slopeEvery = SLOPE_EVERY) {
   const offs = new Array(w);
   for (let x = 0; x < w; x++) {
-    const steps = Math.floor(x / SLOPE_EVERY);
+    const steps = Math.floor(x / slopeEvery);
     const off = down ? steps : -steps;
     offs[x] = baseRow + Math.max(-amp, Math.min(amp, off));
   }
   return offs;
 }
 
+// ---- Per-level layout generator (PURE, deterministic) ----------------------
+/* `levelLayout(level, BOARD_W, BOARD_H)` returns the few geometry knobs initGame
+ * reads instead of hardcoded values, keyed on k = (level-1) % 10 so levels 1-10
+ * are distinct and 11+ cycle (L11 === L1). It is a pure function of its three
+ * args only — no Math.random / Date.now / rngSeed — so the same (size, level)
+ * yields a byte-identical board on node and the bun binary (INVARIANT 4).
+ *
+ * Every knob is CLAMPED to the feasible window so it can never break an invariant:
+ *  - N is clamped to [3, Nmax(BOARD_H)] (Nmax = largest N<=5 with gap>=GAP_MIN),
+ *    so on the minimum 28x12 board every level collapses to N=3 (== today) and a
+ *    small terminal never gets an unsafe extra girder. (INVARIANT 3.)
+ *  - amp is only ever LOWERED below the existing floor((gap-1)/2) clamp, AND
+ *    further capped so every ladder spans >=2 rows (gap-2*amp>=2 → amp<=(gap-2)/2)
+ *    — so girders never cross (amp<gap/2, INVARIANT 2) and ladders are never the
+ *    1-row fragile latches the critic flagged (B3).
+ *  - ladder columns are clamped to [2, BOARD_W-3] (double-wide [col,col+1] fits,
+ *    INVARIANT 1) AND nudged so no two ladders' footprints overlap (>=2 apart),
+ *    which the critic flagged would otherwise shadow a ladder in ladderAt (B2).
+ *  - dkCol / princessCol clamped to [2, BOARD_W-3].
+ * The slope DIRECTION/cadence knobs (slopeDownFor, slopeEvery) only move points
+ * WITHIN the ±amp band, so no pattern can induce a crossing. Up-slope traversal
+ * (the critic's B1) is handled in stepPlaying's grounded branch (riser auto-mount).
+ */
+const GAP_MIN = 4; // min girder spacing for the N-delta to take effect on tall boards
+const clampInt = (v, lo, hi) => (v < lo ? lo : v > hi ? hi : v);
+// Per-k knob tables (k = (level-1) % 10). All bounded; clamps make them safe.
+const L_NDELTA   = [0, 0, 1, 0, 1, 0, 2, 1, 0, 2]; // extra girders (capped at Nmax)
+const L_AMPCAP   = [2, 1, 2, 0, 2, 1, 2, 1, 2, 0]; // some levels flatter (amp 0/1)
+const L_SLOPEEV  = [6, 5, 7, 6, 4, 6, 8, 5, 6, 4]; // stair cadence (cosmetic)
+const L_SLOPEPAT = [0, 0, 1, 2, 3, 4, 5, 6, 7, 1]; // slope-direction pattern id
+const L_LADSTY   = [0, 1, 0, 5, 4, 0, 0, 1, 5, 0]; // ladder placement style id
+const L_STAGMAG  = [3, 2, 4, 3, 5, 2, 3, 4, 2, 3]; // ladder stagger magnitude
+const L_DKSTY    = [0, 0, 1, 0, 2, 3, 1, 0, 2, 3]; // DK column style id (cosmetic)
+const L_PRSTY    = [0, 0, 1, 2, 0, 3, 4, 0, 5, 0]; // princess column style id
+
+/** Largest girder count N in [3,5] whose even spacing gap>=GAP_MIN; else 3. The
+ * Math.max(3,…) floor (not the gap gate) is what guarantees the small board. */
+function nMaxForHeight(BOARD_H) {
+  let best = 3;
+  for (let n = 3; n <= 5; n++) if (Math.floor((BOARD_H - 2) / n) >= GAP_MIN) best = n;
+  return best;
+}
+/** Per-girder slope direction (down-rightward) for a slope pattern. ANY value is
+ * safe (clamped to ±amp around distinct baseRows → never crosses). */
+function slopeDownFor(pat, i) {
+  switch (pat) {
+    case 1: return i % 2 === 1;             // alternating from odd (phase flip)
+    case 2: return true;                    // all-down
+    case 3: return false;                   // all-up
+    case 4: return Math.floor(i / 2) % 2 === 0; // zig-zag pairs
+    case 5: return true;                    // all-down (gentle via slopeEvery)
+    case 6: return false;                   // all-up
+    case 7: return i % 2 === 0;             // alternating from even
+    case 0:
+    default: return i % 2 === 0;            // alternating from even (classic)
+  }
+}
+export function levelLayout(level, BOARD_W, BOARD_H) {
+  const k = (((level - 1) % 10) + 10) % 10;
+  const Nmax = nMaxForHeight(BOARD_H);
+  const N = clampInt(3 + L_NDELTA[k], 3, Nmax);
+  const gap = Math.floor((BOARD_H - 2) / N);
+  // amp: never above today's floor((gap-1)/2); also cap so every ladder spans
+  // >=2 rows (gap - 2*amp >= 2 ⇒ amp <= (gap-2)/2). amp<gap/2 ⇒ no girder cross.
+  let amp = Math.max(0, Math.min(L_AMPCAP[k], Math.floor((gap - 1) / 2)));
+  amp = Math.max(0, Math.min(amp, Math.floor((gap - 2) / 2)));
+  const slopeEvery = L_SLOPEEV[k];
+  const pat = L_SLOPEPAT[k];
+  const sty = L_LADSTY[k];
+  const stag = L_STAGMAG[k];
+  const lo = 2, hi = BOARD_W - 3;
+
+  // Ladder columns: one per adjacent pair, per-level placement style, then nudged
+  // so no two footprints [col,col+1] overlap (>=2 apart) and all in [lo,hi].
+  const cols = [];
+  for (let i = 0; i < N - 1; i++) {
+    const frac = (i + 1) / N;
+    let base;
+    switch (sty) {
+      case 1: base = lo + 2 + i * 2 + (i % 2 ? 0 : 1); break;             // clustered-left
+      case 2: base = hi - 2 - i * 2; break;                              // clustered-right
+      case 3: base = Math.floor(frac * BOARD_W) + (i % 2 ? stag : -stag); break; // reversed stagger
+      case 4: base = hi - 3 - (N - 2 - i) * 2 - (i % 2 ? stag : 0); break; // clustered-right staggered
+      case 5: base = (i % 2 === 0) ? lo + 1 + i : hi - 1 - i; break;       // near-edges alternating
+      case 0:
+      default: base = Math.floor(frac * BOARD_W) + (i % 2 ? -stag : stag); // spread (classic)
+    }
+    cols.push(clampInt(base, lo, hi));
+  }
+  for (let i = 1; i < cols.length; i++) {
+    for (let j = 0; j < i; j++) {
+      let guard = 0;
+      while (Math.abs(cols[i] - cols[j]) < 2 && guard++ < 256) {
+        cols[i] = cols[i] + 2 <= hi ? cols[i] + 2 : cols[i] - 2;
+        if (cols[i] < lo) { cols[i] = lo; break; }
+      }
+    }
+    cols[i] = clampInt(cols[i], lo, hi);
+  }
+
+  let dkCol;
+  switch (L_DKSTY[k]) {
+    case 1: dkCol = BOARD_W - 3; break;
+    case 2: dkCol = BOARD_W - 4; break;
+    case 3: dkCol = 3; break;
+    case 0:
+    default: dkCol = 2;
+  }
+  const cen = Math.floor(BOARD_W / 2);
+  let princessCol;
+  switch (L_PRSTY[k]) {
+    case 1: princessCol = Math.floor(BOARD_W / 3); break;
+    case 2: princessCol = Math.floor((2 * BOARD_W) / 3); break;
+    case 3: princessCol = Math.floor(BOARD_W / 4); break;
+    case 4: princessCol = Math.floor((3 * BOARD_W) / 4); break;
+    case 5: princessCol = cen + 4; break;
+    case 0:
+    default: princessCol = cen;
+  }
+
+  return {
+    k, N, gap, amp, slopeEvery, slopePat: pat,
+    slopeDownFor: (i) => slopeDownFor(pat, i),
+    ladderCols: cols,
+    dkCol: clampInt(dkCol, lo, hi),
+    princessCol: clampInt(princessCol, lo, hi),
+  };
+}
+
 /** Girder index whose standing row is at-or-just-below row y at column x. */
 function girderBelow(platforms, x, y) {
   let best = -1, bestRow = Infinity;
@@ -182,34 +311,40 @@ export function initGame({
   const { BOARD_W, BOARD_H } = boardSize(width, height);
   if (BOARD_W < MIN_W || BOARD_H < MIN_H) return { tooSmall: true, BOARD_W, BOARD_H };
 
-  // Fewer girders → bigger vertical gaps → real jump headroom (a jump head-bonks
-  // the girder overhead, so girders ~3 rows apart capped jumps at ~1 cell; ~4+
-  // rows lets the higher JUMP_VY actually read as a tall jump).
-  const N = Math.max(3, Math.min(4, Math.floor(BOARD_H / 4)));
-  const gap = Math.floor((BOARD_H - 2) / N);
-  const amp = Math.max(0, Math.min(2, Math.floor((gap - 1) / 2)));
+  // Per-level layout: a PURE function of (level, BOARD_W, BOARD_H) — see
+  // levelLayout for the clamps that keep every knob within its invariant window.
+  // Fewer girders → bigger vertical gaps → real jump headroom (~4+ rows apart so
+  // the higher JUMP_VY reads as a tall jump); levelLayout's Nmax(BOARD_H) gate
+  // preserves that on small boards (N collapses to 3 exactly as the old gen did).
+  const layout = levelLayout(level, BOARD_W, BOARD_H);
+  const { N, gap, amp, slopeEvery } = layout;
   const platforms = [];
   for (let i = 0; i < N; i++) {
     const baseRow = BOARD_H - 2 - amp - i * gap; // 0 = bottom-most girder
-    const down = i % 2 === 0;
-    platforms.push({ row: baseRow, slopeOffsets: buildSlope(baseRow, BOARD_W, down, amp) });
+    const down = layout.slopeDownFor(i);
+    platforms.push({ row: baseRow, slopeOffsets: buildSlope(baseRow, BOARD_W, down, amp, slopeEvery) });
   }
   // platforms[0] is the LOWEST (largest row); platforms[N-1] the HIGHEST.
 
+  // One ladder per adjacent pair, IN ORDER (ladders[i] connects platforms[i]→[i+1])
+  // so the autopilot's ladders[gi] assumption holds verbatim. The column comes from
+  // the layout (already clamped to [2,BOARD_W-3] + footprint-deconflicted); the
+  // endpoints are recomputed from the slope AT THAT column so both rails touch both
+  // standing rows even on sloped girders.
   const ladders = [];
   for (let i = 0; i < N - 1; i++) {
     const lower = platforms[i];
     const upper = platforms[i + 1];
-    const col = Math.max(2, Math.min(BOARD_W - 3, Math.floor(((i + 1) / N) * BOARD_W) + (i % 2 ? -3 : 3)));
+    const col = layout.ladderCols[i];
     const yBottom = lower.slopeOffsets[col] - 1;
     const yTop = upper.slopeOffsets[col] - 1;
     ladders.push({ col, yTop: Math.min(yTop, yBottom), yBottom: Math.max(yTop, yBottom) });
   }
 
   const top = platforms[N - 1];
-  const dkCol = 2;
+  const dkCol = layout.dkCol;
   const donkeyKong = { x: dkCol, y: top.slopeOffsets[dkCol] - 1, throwCooldown: 2, animPhase: 0 };
-  const princessCol = Math.floor(BOARD_W / 2);
+  const princessCol = layout.princessCol;
   const princess = { x: princessCol, y: top.slopeOffsets[princessCol] - 1, animPhase: 0 };
 
   const player = makePlayer(platforms);
@@ -498,10 +633,24 @@ function stepPlaying(s, input, dt) {
       }
     } else {
       // Grounded: follow the slope at the current column, detect walk-off.
+      // A sloped girder steps ±1 row every `slopeEvery` columns, so when walking
+      // INTO a riser the girder's stand row at the next column is one ABOVE the
+      // player's current cell (girderIndexAt at cell(py)+1 then misses → the
+      // player walks off the riser and falls — the critic's B1). Re-snap to the
+      // girder whose stand row is within ±1 of the player's cell so the player
+      // auto-mounts a one-row riser (and follows a one-row drop) instead of
+      // falling off. This is the same riser the player was already standing on
+      // (girders are >=2 rows apart, so at most one girder qualifies), so it
+      // never teleports between platforms — it just walks the staircase.
       const c = cell(p.px);
-      const gi = girderIndexAt(platforms, c, cell(p.py) + 1);
+      const cy = cell(p.py);
+      // girder cell one below the player (flat / down-step → stand row stays cy).
+      let gi = girderIndexAt(platforms, c, cy + 1);
+      // up-step: the girder cell is AT the player's current row (stand row cy-1),
+      // so the next-column girder stepped up one — auto-mount it.
+      if (gi < 0) gi = girderIndexAt(platforms, c, cy);
       if (gi >= 0) {
-        p.py = toFx(platforms[gi].slopeOffsets[c] - 1); // re-snap to slope
+        p.py = toFx(platforms[gi].slopeOffsets[c] - 1); // re-snap to slope (auto-mount the riser)
         p.vy = 0;
       } else {
         // walked off the edge → coyote window, begin falling
@@ -686,5 +835,5 @@ export function deserialize(obj) {
 // Expose internals for focused unit tests.
 export const _internals = {
   girderBelow, isGirderAt, girderIndexAt, ladderAt, rng, between,
-  makePlayer, advanceBarrels, syncCell,
+  makePlayer, advanceBarrels, syncCell, levelLayout, nMaxForHeight,
 };

package/src/tui/game/dk-render.js

@@ -29,16 +29,38 @@ const G_ASCII = {
 };
 export const GAME_GLYPH = ASCII ? G_ASCII : G_UNICODE;
 
+// Animation frames cycled by state.frame / entity fields so the board feels alive:
+// barrels spin, the player bobs while walking/climbing + opens up airborne, the
+// princess pulses a heart. ASCII variants stay pure-ASCII for the MM_ASCII path.
+const PLAYER_FRAMES = ASCII ? ["P", "p"] : ["☻", "☺"];
+const BARREL_FRAMES = ASCII ? ["o", "O", "0"] : ["◐", "◓", "◑", "◒"];
+const PRINCESS_FRAMES = ASCII ? ["V", "v"] : ["♥", "♡"];
+export const GAME_FRAMES = {
+  player: PLAYER_FRAMES, barrel: BARREL_FRAMES, princess: PRINCESS_FRAMES,
+  dk: [GAME_GLYPH.dk], girder: [GAME_GLYPH.girder], ladder: [GAME_GLYPH.ladder],
+};
+
+/** Animated player glyph from motion state + the global frame counter. */
+function playerFrame(state) {
+  const p = state.jumpman || state.player;
+  const f = state.frame || 0;
+  if (!p) return PLAYER_FRAMES[0];
+  if (p.onLadder) return PLAYER_FRAMES[(f >> 2) & 1];                // climb bob
+  if (!p.onGround) return PLAYER_FRAMES[1];                          // airborne
+  if (Math.abs(p.vx || 0) > 30) return PLAYER_FRAMES[(f >> 2) & 1];  // walk bob
+  return PLAYER_FRAMES[0];                                           // standing
+}
+
 // Entity color keys (resolved against the C palette by the wrapper; kept here as
 // literal hex so the renderer stays dependency-free + the colorize output is
 // directly usable by tests without importing the design system).
 export const GAME_COLORS = {
-  jumpman: "#22d3ee", // C.ACCENT
-  barrel: "#ea580c", // retiring-orange
-  girder: "#243042", // C.BORDER
-  ladder: "#8b98a5", // C.FG_DIM
-  dk: "#dc2626", // retired-red
-  princess: "#a78bfa", // violet
+  jumpman: "#ef4444", // Mario red — pops off the board
+  barrel: "#f97316", // bright orange
+  girder: "#e0698c", // classic DK rose girders
+  ladder: "#38bdf8", // sky-blue ladders (cool contrast vs the warm board)
+  dk: "#c2630a", // gorilla amber-brown
+  princess: "#f472b6", // pink
   empty: "#5b6673", // C.FG_FAINT
 };
 
@@ -67,11 +89,12 @@ function buildGrid(state, glyph) {
   for (const l of ladders) {
     for (let y = l.yTop; y <= l.yBottom; y++) { put(l.col, y, glyph.ladder, "ladder"); put(l.col + 1, y, glyph.ladder, "ladder"); }
   }
-  // goal + actors
-  put(princess.x, princess.y, glyph.princess, "princess");
+  // goal + actors (animated: princess pulse, barrel spin, player bob)
+  const f = state.frame || 0;
+  put(princess.x, princess.y, PRINCESS_FRAMES[(f >> 4) & 1], "princess");
   put(donkeyKong.x, donkeyKong.y, glyph.dk, "dk");
-  for (const b of barrels) put(b.x, b.y, glyph.barrel, "barrel");
-  put(jumpman.x, jumpman.y, glyph.jumpman, "jumpman");
+  for (const b of barrels) put(b.x, b.y, BARREL_FRAMES[(b.spin >> 1) % BARREL_FRAMES.length], "barrel");
+  put(jumpman.x, jumpman.y, playerFrame(state), "jumpman");
   return grid;
 }
 

package/src/tui/game/loop.js

@@ -51,8 +51,14 @@ const COL = {
   green: packHex("#16a34a"),
   amber: packHex("#d97706"),
   violet: packHex("#a78bfa"),
+  pink: packHex("#f472b6"),
+  gold: packHex("#fbbf24"),
 };
 
+// Win-celebration sparkles + a color-cycle palette (the flare on a level clear).
+const WIN_SPARK = ASCII ? ["*", "+", ".", "'", "o"] : ["✦", "✧", "✺", "·", "♥"];
+const WIN_PAL = [COL.pink, COL.gold, COL.accent, COL.green, COL.red, COL.violet];
+
 const fmtNum = (n) => (n == null ? "0" : Number(n).toLocaleString("en-US"));
 
 /**
@@ -213,7 +219,9 @@ export function runGame({ width, height, level = 1, scanStore = null, onExit, _i
       bb.blit(cells, 0, HUD_ROWS, cells.width, cells.height);
       // Respawn blink: hide the player glyph on alternate frames during invuln.
       maybeBlinkPlayer(bb, game, curW);
-      drawBanner(bb, game, curW, curH);
+      // Level-clear gets the full celebration; everything else the plain banner.
+      if (game.status === "levelclear") drawWinFlare(bb, game, curW, curH);
+      else drawBanner(bb, game, curW, curH);
       drawKeybar(bb, curW, HUD_ROWS + curH);
       const s = bb.render();
       if (s) term.write(s);
@@ -323,6 +331,36 @@ function drawBanner(bb, game, w, boardH) {
   }
 }
 
+/** Win celebration: a drifting confetti field + a color-cycling heart banner +
+ * the bonus tally. Drawn over the board during the levelclear window (the loop is
+ * actively ticking, so animating here is fine — it's not idle). All deterministic
+ * off game.frame (no RNG), so it's stable + cheap (the diff renderer only emits
+ * the cells that changed). */
+function drawWinFlare(bb, game, w, boardH) {
+  const f = game.frame || 0;
+  // Confetti: a deterministic, gently-falling sparkle field across the board.
+  const count = Math.min(48, Math.max(16, Math.floor((w * boardH) / 10)));
+  for (let i = 0; i < count; i++) {
+    const col = (i * 17 + (i % 5)) % w;
+    const row = (i * 7 + (f >> 1)) % boardH;            // drifts downward each frame
+    const ch = WIN_SPARK[(i + (f >> 2)) % WIN_SPARK.length];
+    const c = WIN_PAL[(i + (f >> 3)) % WIN_PAL.length];
+    bb.setCell(col, HUD_ROWS + row, ch.charCodeAt(0), c);
+  }
+  // Flashing centered banner with hearts.
+  const text = `${G.spark} ${G.heart} YOU SAVED HER! ${G.heart} ${G.spark}`;
+  const brow = HUD_ROWS + Math.floor(boardH / 2);
+  const bx = Math.max(0, Math.floor((w - text.length) / 2));
+  for (let cx = 0; cx < w; cx++) bb.setCell(cx, brow, 32, -1); // clear row for legibility
+  bb.setText(bx, brow, clip(text, w - bx), WIN_PAL[(f >> 2) % WIN_PAL.length]);
+  // Bonus tally sub-line.
+  const sub = `+100   bonus ${fmtNum(game.bonus || 0)}   ${ASCII ? "->" : "→"} next level`;
+  const sy = Math.min(HUD_ROWS + boardH - 1, brow + 1);
+  const sx = Math.max(0, Math.floor((w - sub.length) / 2));
+  for (let cx = 0; cx < w; cx++) bb.setCell(cx, sy, 32, -1);
+  bb.setText(sx, sy, clip(sub, w - sx), COL.strong);
+}
+
 /** Bottom row: in-game keybar. */
 function drawKeybar(bb, w, y) {
   const bar = ASCII
@@ -335,3 +373,6 @@ function clip(s, w) {
   if (w <= 0) return "";
   return s.length > w ? s.slice(0, w) : s;
 }
+
+// Exposed for focused render tests (the win celebration + banners).
+export const _internals = { drawWinFlare, drawBanner, drawStats, HUD_ROWS, KEY_ROW };