@modelstatus/cli 0.1.40 → 0.1.41

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@modelstatus/cli",
-  "version": "0.1.40",
+  "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,
 };