@modelstatus/cli 0.1.34 → 0.1.36

package/src/tui/game/term.js

@@ -0,0 +1,330 @@
+/* Direct-ANSI terminal control + double-buffered cell renderer for the game.
+ * NO Ink, NO React. This is the renderer half of the DECISION: a diff-based
+ * cell buffer that emits ONLY changed cells (cursor-move on run-break + sticky
+ * SGR fg) so a near-static frame writes ~0 bytes and the screen is NEVER cleared
+ * during play — that is what removes the old Ink clearTerminal flicker.
+ *
+ * The pieces here are deliberately split so they're unit-testable WITHOUT a TTY:
+ *   - Backbuffer: pure cell store + diff() string builder (front/back typed
+ *     arrays). diff-minimality is asserted directly in tests.
+ *   - Term: the IO shell (alt-screen, raw mode, hide cursor, SIGWINCH) with a
+ *     SINGLE idempotent restore() wired to every exit path — the #1 safety risk.
+ *
+ * Color: GAME_COLORS are hex strings ("#rrggbb"); we pack to a 24-bit int once
+ * and emit truecolor SGR (\x1b[38;2;r;g;bm), sticky so a run of one color emits
+ * one SGR. When color is off (NO_COLOR / MM_ASCII / TERM=dumb) we skip ALL SGR
+ * and just place glyphs — matching the rest of the TUI's degrade discipline. */
+
+// ---- env flags (read once, mirror ui.js / dk-render.js) --------------------
+const ASCII = process.env.MM_ASCII === "1" || process.env.TERM === "dumb";
+export const COLOR_ON = !ASCII && process.env.NO_COLOR == null;
+
+// ---- ANSI primitives -------------------------------------------------------
+export const ESC = "\x1b";
+const CSI = ESC + "[";
+export const ALT_ENTER = CSI + "?1049h"; // enter alternate screen buffer
+export const ALT_LEAVE = CSI + "?1049l"; // leave it (restores prior screen)
+export const CURSOR_HIDE = CSI + "?25l";
+export const CURSOR_SHOW = CSI + "?25h";
+export const SGR_RESET = CSI + "0m";
+const CLEAR_SCREEN = CSI + "2J" + CSI + "H";
+
+/** 1-based cursor positioning (terminals are 1-indexed). */
+export function cursorTo(x, y) {
+  return CSI + (y + 1) + ";" + (x + 1) + "H";
+}
+/** Truecolor foreground SGR for a packed 24-bit RGB int. */
+export function fgSeq(rgb) {
+  return CSI + "38;2;" + ((rgb >> 16) & 255) + ";" + ((rgb >> 8) & 255) + ";" + (rgb & 255) + "m";
+}
+
+/** "#rrggbb" | "#rgb" | "rrggbb" -> packed 24-bit int. Unparseable -> -1
+ * (sentinel = "no color", so the diff path skips SGR for that cell). */
+export function packHex(hex) {
+  if (typeof hex !== "string") return -1;
+  let h = hex[0] === "#" ? hex.slice(1) : hex;
+  if (h.length === 3) h = h[0] + h[0] + h[1] + h[1] + h[2] + h[2];
+  if (h.length !== 6) return -1;
+  const n = parseInt(h, 16);
+  return Number.isNaN(n) ? -1 : n & 0xffffff;
+}
+
+const SPACE = 32; // char code for a blank cell
+const NO_FG = -1; // packed-fg sentinel for "default / no SGR"
+const DIRTY = -2; // front-buffer sentinel forcing every cell to differ once
+
+/**
+ * Double-buffered cell grid. Cells are two flat typed arrays:
+ *   ch  : Uint16Array of char codes (BMP glyphs — DK's glyph set is all BMP)
+ *   fg  : Int32Array of packed 24-bit RGB (or NO_FG = -1 = default)
+ * `front` is what's on screen; you write the next frame into `back` (via set /
+ * clear / setCell or fillFromCells), then diff() returns the minimal escape
+ * string and (when applied) swaps the buffers.
+ *
+ * Pure + TTY-free: construct, write cells, call diff() — assert the string.
+ */
+export class Backbuffer {
+  constructor(width, height, { color = COLOR_ON } = {}) {
+    this.color = color;
+    this.resize(width, height);
+  }
+
+  resize(width, height) {
+    this.width = Math.max(0, width | 0);
+    this.height = Math.max(0, height | 0);
+    this.n = this.width * this.height;
+    this.frontCh = new Uint16Array(this.n);
+    this.frontFg = new Int32Array(this.n);
+    this.backCh = new Uint16Array(this.n);
+    this.backFg = new Int32Array(this.n);
+    this.frontCh.fill(SPACE);
+    this.backCh.fill(SPACE);
+    this.frontFg.fill(NO_FG);
+    this.backFg.fill(NO_FG);
+    // Force the very next diff() to be a full paint (front all-dirty).
+    this.markAllDirty();
+  }
+
+  /** Poison the front buffer so EVERY cell differs from back -> full repaint on
+   * the next diff(). Used at game start and after SIGWINCH (size changed). */
+  markAllDirty() {
+    this.frontCh.fill(0xffff);
+    this.frontFg.fill(DIRTY);
+  }
+
+  /** Reset the BACK buffer to blank before composing a frame. */
+  clearBack(fg = NO_FG) {
+    this.backCh.fill(SPACE);
+    this.backFg.fill(fg);
+  }
+
+  /** Write one cell into the back buffer. Out-of-bounds is a safe no-op so the
+   * caller never has to bounds-check (e.g. a HUD string longer than the row). */
+  setCell(x, y, chCode, fg = NO_FG) {
+    if (x < 0 || y < 0 || x >= this.width || y >= this.height) return;
+    const i = y * this.width + x;
+    this.backCh[i] = chCode & 0xffff;
+    this.backFg[i] = this.color ? fg : NO_FG;
+  }
+
+  /** Write a string starting at (x,y), one column per code unit, clipped to the
+   * row. fg applies to the whole run. Returns the x after the last glyph. */
+  setText(x, y, text, fg = NO_FG) {
+    for (let k = 0; k < text.length; k++) {
+      this.setCell(x + k, y, text.charCodeAt(k), fg);
+    }
+    return x + text.length;
+  }
+
+  /**
+   * Fill a rectangle of the back buffer from a flat cell descriptor produced by
+   * dk-render.fillCells: arrays `ch` (char codes) and `fg` (packed RGB) of
+   * length w*h, placed with the top-left at (ox, oy). Lets the renderer hand the
+   * board straight into the buffer with no per-cell call overhead.
+   */
+  blit(cells, ox, oy, w, h) {
+    const { ch, fg } = cells;
+    for (let cy = 0; cy < h; cy++) {
+      const dy = oy + cy;
+      if (dy < 0 || dy >= this.height) continue;
+      const srcRow = cy * w;
+      const dstRow = dy * this.width;
+      for (let cx = 0; cx < w; cx++) {
+        const dx = ox + cx;
+        if (dx < 0 || dx >= this.width) continue;
+        const di = dstRow + dx;
+        this.backCh[di] = ch[srcRow + cx] & 0xffff;
+        this.backFg[di] = this.color ? fg[srcRow + cx] : NO_FG;
+      }
+    }
+  }
+
+  /**
+   * Build the MINIMAL escape string that turns the on-screen (front) buffer into
+   * the composed (back) buffer:
+   *   - skip cells that are unchanged (no bytes)
+   *   - emit a cursor-move ONLY when the cursor isn't already where it needs to
+   *     be (i.e. only at the start of a changed run / after a skipped cell)
+   *   - emit an fg SGR ONLY when the color changes (sticky across the frame)
+   *   - reset SGR once at the very end (and only if any color was emitted)
+   * Does NOT mutate buffers; call swap() after writing the result to apply.
+   */
+  diff() {
+    let out = "";
+    let cx = -1, cy = -1;          // tracked cursor position (-1 = unknown)
+    let curFg = -1;                 // currently-active SGR fg (-1 = none set)
+    let emittedColor = false;
+    const { width, n, backCh, backFg, frontCh, frontFg, color } = this;
+    for (let i = 0; i < n; i++) {
+      if (backCh[i] === frontCh[i] && backFg[i] === frontFg[i]) {
+        continue; // unchanged — emit nothing; the next change will reposition
+      }
+      const y = (i / width) | 0;
+      const x = i - y * width;
+      if (x !== cx || y !== cy) {
+        out += cursorTo(x, y);
+        cx = x; cy = y;
+      }
+      if (color) {
+        const fg = backFg[i];
+        if (fg !== curFg) {
+          if (fg === NO_FG) {
+            out += SGR_RESET;
+            curFg = NO_FG;
+            emittedColor = false; // reset clears the sticky color
+          } else {
+            out += fgSeq(fg);
+            curFg = fg;
+            emittedColor = true;
+          }
+        }
+      }
+      out += String.fromCharCode(backCh[i]);
+      cx += 1; // we advanced one column by printing the glyph
+    }
+    if (emittedColor) out += SGR_RESET;
+    return out;
+  }
+
+  /** Apply: copy back -> front so the next frame diffs against what's now shown.
+   * (Call after writing diff() output to the terminal.) */
+  swap() {
+    this.frontCh.set(this.backCh);
+    this.frontFg.set(this.backFg);
+  }
+
+  /** Convenience for headless tests: returns the diff string AND applies it. */
+  render() {
+    const s = this.diff();
+    this.swap();
+    return s;
+  }
+}
+
+/**
+ * Term: the IO shell that owns alt-screen, raw mode, the hidden cursor, resize,
+ * and — most importantly — a SINGLE idempotent restore() registered on every
+ * exit path so a crash mid-game can NEVER leave the user in raw mode + alt
+ * screen + hidden cursor (the "broken terminal").
+ *
+ * Injectable streams/hooks (`out`, `inp`, `proc`) make it fully testable: tests
+ * pass fakes and assert the exact teardown sequence without touching a TTY.
+ */
+export class Term {
+  constructor({
+    out = process.stdout,
+    inp = process.stdin,
+    proc = process,
+    color = COLOR_ON,
+  } = {}) {
+    this.out = out;
+    this.inp = inp;
+    this.proc = proc;
+    this.color = color;
+    this.started = false;
+    this.restored = false;
+    this._wasRaw = false;
+    this._signalHandlers = null;
+    this._onResize = null;
+  }
+
+  write(s) {
+    if (s) this.out.write(s);
+  }
+
+  /** Enter the game's terminal mode: alt screen, hide cursor, raw stdin, and
+   * wire bulletproof teardown. Idempotent. */
+  start() {
+    if (this.started) return;
+    this.started = true;
+    this.restored = false;
+
+    // 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);
+
+    // 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.
+    const inp = this.inp;
+    if (inp && typeof inp.setRawMode === "function" && inp.isTTY) {
+      this._wasRaw = !!inp.isRaw;
+      inp.setRawMode(true);
+    }
+    if (inp && typeof inp.resume === "function") inp.resume();
+
+    // Bulletproof teardown: a single restore() on EVERY way out.
+    const restore = () => this.restore();
+    const handlers = {
+      exit: restore,
+      SIGINT: () => { this.restore(); this.proc.exit(130); },
+      SIGTERM: () => { this.restore(); this.proc.exit(143); },
+      SIGHUP: () => { this.restore(); this.proc.exit(129); },
+      uncaughtException: (err) => {
+        this.restore();
+        // Surface the error on the now-restored terminal, then exit non-zero.
+        try { (this.proc.stderr || process.stderr).write(String(err && err.stack || err) + "\n"); } catch {}
+        this.proc.exit(1);
+      },
+    };
+    this._signalHandlers = handlers;
+    for (const [evt, fn] of Object.entries(handlers)) this.proc.on(evt, fn);
+  }
+
+  /** Register a resize callback. On SIGWINCH we recompute nothing here (the loop
+   * owns board math) — we just notify; the loop reallocs + forces a full repaint
+   * via Backbuffer.markAllDirty(). Debounced is the loop's concern; we pass the
+   * raw signal. */
+  onResize(cb) {
+    this._onResize = cb;
+    const handler = () => { if (this._onResize) this._onResize(this.size()); };
+    this._resizeHandler = handler;
+    this.proc.on("SIGWINCH", handler);
+  }
+
+  size() {
+    return {
+      width: (this.out && this.out.columns) || 80,
+      height: (this.out && this.out.rows) || 24,
+    };
+  }
+
+  /**
+   * IDEMPOTENT restore: leave alt screen, show cursor, reset SGR, drop raw mode
+   * back to its prior state, and unhook every signal handler. Safe to call
+   * twice (double-restore is a no-op) — which it WILL be (try/finally in the loop
+   * plus the exit handler both call it).
+   */
+  restore() {
+    if (this.restored) return;
+    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 {}
+
+    const inp = this.inp;
+    try {
+      if (inp && typeof inp.setRawMode === "function" && inp.isTTY) {
+        inp.setRawMode(this._wasRaw);
+      }
+    } catch {}
+    // Don't pause stdin here — the caller (TUI remount) may want to keep reading.
+
+    // Unhook our signal/exit handlers so a subsequent normal exit doesn't double-
+    // fire and so the process can exit cleanly when nothing else is listening.
+    if (this._signalHandlers) {
+      for (const [evt, fn] of Object.entries(this._signalHandlers)) {
+        try { this.proc.removeListener(evt, fn); } catch {}
+      }
+      this._signalHandlers = null;
+    }
+    if (this._resizeHandler) {
+      try { this.proc.removeListener("SIGWINCH", this._resizeHandler); } catch {}
+      this._resizeHandler = null;
+    }
+    this.started = false;
+  }
+}
+
+export const _internals = { SPACE, NO_FG, DIRTY, CLEAR_SCREEN };

package/src/tui/views/add.js

@@ -2,7 +2,7 @@ import React from "react";
 import { Box, Text, useInput } from "ink";
 import { h, C, GLYPH, useAsync, clampCursor } from "../ui.js";
 
-const ENV_ORDER = ["prod", "staging", "dev", "other"];
+const ENV_ORDER = ["prod", "staging", "dev", "unknown"];
 
 export const meta = {
   keys: [

package/src/tui/views/integrations.js

@@ -0,0 +1,224 @@
+import React from "react";
+import { Box, Text, useInput } from "ink";
+import {
+  h, C, GLYPH, ListRow, EmptyCard, envTag as envTagSeg,
+  cell, cellE, SPINNER, useTick, useAsync, clampCursor,
+} from "../ui.js";
+import { getSource } from "../../sources/index.js";
+import {
+  INTEGRATION_IDS, INTEGRATION_META, readIntegrations,
+  setEnabled, setEnvTag, getEnvTag,
+} from "../../integrations.js";
+
+const ENV_TAGS = ["prod", "staging", "dev", "unknown"];
+
+// kind → accent pill color (mirrors the channel KIND_COLOR taste in alerts.js).
+const KIND_COLOR = {
+  "aws-lambda": "#ff9900", // AWS orange
+  vercel: C.FG_STRONG,
+  "supabase-edge": "#3ecf8e", // Supabase green
+  "github-actions": "#a78bfa",
+};
+
+/** A compact provider pill text (kept ≤ the 14-col column). */
+const PILL = {
+  "aws-lambda": "aws",
+  vercel: "vercel",
+  "supabase-edge": "supabase",
+  "github-actions": "github",
+};
+
+/**
+ * Integrations view: a single fixed list of the 4 LIVE integration sources, with
+ * a per-source enabled toggle (the authoritative local switch that drives what
+ * `mm scan` runs by default) + a declared env label. Authorization is NOT stored
+ * here — it's the user's already-authenticated local CLI (aws/gh/vercel/supabase);
+ * `t` runs a one-off read-only identity probe and toasts the result.
+ *
+ * needsAuth:false in app.js — the toggle is local-first and scanning is free; the
+ * web row (best-effort PATCH) is only for cross-device visibility + plan display.
+ * No idle timers / setState-on-tick (the spinner ticks ONLY while a probe runs).
+ */
+export function IntegrationsView({ client, me, ui, active, width = 78, height = 14 }) {
+  const ROWS = Math.max(3, height - 3); // hint line + a little overhead
+  const [cursor, setCursor] = React.useState(0);
+  // Local toggle state, re-read from integrations.json. `gen` bumps to force a
+  // re-read after a write (the file is the source of truth, not React state).
+  const [gen, setGen] = React.useState(0);
+  const local = React.useMemo(() => readIntegrations(), [gen]);
+  // Probing state: which id is mid-probe (drives the spinner) + last results.
+  const [probing, setProbing] = React.useState(null);
+  const [probed, setProbed] = React.useState({}); // id -> { connected, account?, reason? }
+  const tick = useTick(80, probing != null);
+
+  // Availability is the cheap PATH check (no spawn) per source.
+  const avail = useAsync(
+    async () => {
+      const out = {};
+      for (const id of INTEGRATION_IDS) {
+        const src = getSource(id);
+        out[id] = src ? await src.available({}) : false;
+      }
+      return out;
+    },
+    [gen],
+  );
+  const availMap = avail.data || {};
+
+  const rows = INTEGRATION_IDS.map((id) => ({
+    id,
+    meta: INTEGRATION_META[id],
+    enabled: !!local[id]?.enabled,
+    env: getEnvTag(id) || "unknown",
+    hasCmd: !!availMap[id],
+    probe: probed[id] || null,
+  }));
+  const cur = rows[clampCursor(cursor, rows.length)] || null;
+  const enabledCount = rows.filter((r) => r.enabled).length;
+
+  React.useEffect(
+    () => ui?.reportStatus?.({ context: `${enabledCount}/${rows.length} on` }),
+    [enabledCount, rows.length, ui],
+  );
+
+  function refresh() {
+    setProbed({});
+    setGen((g) => g + 1);
+    avail.reload();
+  }
+
+  function toggle(r) {
+    const next = !r.enabled;
+    setEnabled(r.id, next); // local write is authoritative + instant
+    setGen((g) => g + 1);
+    ui.showToast(`${r.id} ${next ? "enabled" : "disabled"}`);
+    // Best-effort cloud mirror (cross-device + plan-gating). The local toggle
+    // already applied; a 402/anything else just toasts and leaves it local.
+    if (me) {
+      client
+        .setIntegration({ action: next ? "enable" : "disable", kind: r.id, env: r.env })
+        .catch((e) => {
+          if (e.status === 402) ui.showToast("Live integrations sync is a Pro feature (toggle still applies locally)", "yellow");
+        });
+    }
+  }
+
+  function setEnv(r) {
+    ui.askPrompt(`Env for ${r.id} (${ENV_TAGS.join("/")})`, {
+      initial: r.env,
+      onSubmit: (val) => {
+        const tag = (val || "").trim().toLowerCase();
+        if (!ENV_TAGS.includes(tag)) return ui.showToast("env must be prod/staging/dev/unknown", "red");
+        try {
+          setEnvTag(r.id, tag); // "unknown" clears the override (guessEnvFrom resumes)
+          setGen((g) => g + 1);
+          ui.showToast(tag === "unknown" ? `${r.id} env override cleared` : `${r.id} env → ${tag}`);
+          if (me) client.setIntegration({ action: r.enabled ? "enable" : "disable", kind: r.id, env: tag }).catch(() => {});
+        } catch (e) {
+          ui.showToast(e.message, "red");
+        }
+      },
+    });
+  }
+
+  async function testAuth(r) {
+    if (!r.hasCmd) return ui.showToast(`${r.meta.requiresCmd} not installed`, "red");
+    const src = getSource(r.id);
+    if (!src || typeof src.authState !== "function") return ui.showToast("no auth probe for this source", "yellow");
+    setProbing(r.id);
+    try {
+      const st = await src.authState({ region: local[r.id]?.ref });
+      setProbed((p) => ({ ...p, [r.id]: st }));
+      if (st.connected) ui.showToast(`${r.id} authorized${st.account ? ` · ${st.account}` : ""}`, "#16a34a");
+      else ui.showToast(`${r.id}: ${st.reason || "not authorized"}`, "red");
+    } catch (e) {
+      setProbed((p) => ({ ...p, [r.id]: { connected: false, reason: e.message } }));
+      ui.showToast(e.message, "red");
+    } finally {
+      setProbing(null);
+    }
+  }
+
+  useInput(
+    (input, key) => {
+      if (!active) return;
+      if (key.downArrow || input === "j") return setCursor((c) => clampCursor(c + 1, rows.length));
+      if (key.upArrow || input === "k") return setCursor((c) => clampCursor(c - 1, rows.length));
+      if (input === "g") return refresh();
+      if (!cur) return;
+      if (input === " " || key.return) return toggle(cur);
+      if (input === "e") return setEnv(cur);
+      if (input === "t") return testAuth(cur);
+    },
+    { isActive: active },
+  );
+
+  // Column budget: rail(1) + toggle(2) + label + gap(1) + kind(10) + status(rest) + env(8).
+  const ENV_W = 8;
+  const KIND_W = 10;
+  const LABEL_W = 30;
+  const restW = Math.max(8, width - 1 - 2 - LABEL_W - 1 - KIND_W - ENV_W);
+
+  // Status string per row: not-installed › off/available › on › on·authorized / auth failed.
+  function statusFor(r) {
+    if (!r.hasCmd) return { text: `${r.meta.requiresCmd} not installed`, color: C.FG_FAINT };
+    if (r.probe && !r.probe.connected) return { text: "auth failed", color: "#dc2626" };
+    if (r.probe && r.probe.connected) {
+      const who = r.probe.account ? ` · ${r.probe.account}` : "";
+      return { text: `authorized${who}`, color: "#16a34a" };
+    }
+    if (r.enabled) return { text: "on", color: C.ACCENT };
+    return { text: "available · off", color: C.FG_DIM };
+  }
+
+  const curIdx = clampCursor(cursor, rows.length);
+  let body;
+  if (avail.loading) {
+    body = h(Text, {}, h(Text, { color: C.ACCENT }, ` ${SPINNER[tick % SPINNER.length]} `), h(Text, { color: C.FG_DIM }, "checking installed CLIs…"));
+  } else if (!rows.length) {
+    body = h(EmptyCard, {
+      icon: GLYPH.spark,
+      title: "Connect your live deployments",
+      lines: ["Scan AWS Lambda, Vercel, Supabase Edge and GitHub Actions for the models you actually ship.", "Toggle one on with space — it then scans by default. Authorization is your own CLI; we never store a token."],
+      width,
+    });
+  } else {
+    body = h(
+      Box,
+      { flexDirection: "column" },
+      ...rows.slice(0, ROWS).map((r, i) => {
+        const isCur = i === curIdx;
+        const st = statusFor(r);
+        const spin = probing === r.id ? `${SPINNER[tick % SPINNER.length]} ` : "";
+        const et = envTagSeg(r.env);
+        const cells = [
+          { text: `${r.enabled ? GLYPH.check : GLYPH.dot} `, color: r.enabled ? C.ACCENT : C.FG_FAINT },
+          { text: cellE(r.meta.label, LABEL_W), color: isCur ? C.FG_STRONG : r.enabled ? C.FG : C.FG_FAINT, bold: isCur },
+          { text: " ", color: C.FG },
+          { text: cell(PILL[r.id] || "", KIND_W), color: KIND_COLOR[r.id] || C.FG_DIM, bold: true },
+          { text: cellE(spin + st.text, restW), color: st.color },
+          { text: cell(et.text, ENV_W), color: et.color },
+        ];
+        return h(ListRow, { key: r.id, active: isCur, cells, width });
+      }),
+    );
+  }
+
+  const hint = "  Toggle which live deployments scan by default · space on/off · t authorize · e env. Secrets stay on your machine.";
+  return h(
+    Box,
+    { flexDirection: "column" },
+    h(Text, { color: C.FG_FAINT }, cellE(hint, width)),
+    body,
+  );
+}
+
+export const meta = {
+  keys: [
+    { k: "↑↓", label: "nav" },
+    { k: "space", label: "toggle" },
+    { k: "e", label: "env" },
+    { k: "t", label: "test" },
+    { k: "g", label: "refresh" },
+  ],
+};

package/src/tui/views/inventory.js

@@ -11,12 +11,13 @@ import {
 } from "../ui.js";
 import { readSnippet, findSourceFile } from "../snippet.js";
 
-const ENV_ORDER = ["prod", "staging", "dev", "other"];
+const ENV_ORDER = ["prod", "staging", "dev", "unknown"];
 
 export const meta = {
   keys: [
     { k: "↑↓", label: "nav" },
     { k: "e", label: "env" },
+    { k: "t", label: "tag untagged" },
     { k: "c", label: "critical" },
     { k: "d", label: "delete" },
     { k: "C", label: "clear all" },
@@ -26,6 +27,10 @@ export const meta = {
   ],
 };
 
+// A row whose env is genuinely unknown — disk had no signal and nobody tagged it.
+// Legacy null/empty + the old "other" bucket count as untagged too.
+const isUntagged = (u) => !u.environment || u.environment === "unknown" || u.environment === "other";
+
 export function InventoryView({ client, ui, dir = ".", active, width = 78, height = 14 }) {
   const q = useAsync(async () => {
     const [u, p] = await Promise.all([client.listUsages(), client.listProjects()]);
@@ -82,6 +87,27 @@ export function InventoryView({ client, ui, dir = ".", active, width = 78, heigh
       if (input === "g") return q.reload();
       if (input === "r") return ui.switchTo("scan");
       if (input === "n") return ui.switchTo("add");
+      if (input === "t") {
+        const untagged = usages.filter(isUntagged);
+        if (!untagged.length) return ui.showToast("nothing untagged");
+        return ui.askPrompt(`Tag ${untagged.length} untagged → type prod / staging / dev`, {
+          onSubmit: async (v) => {
+            const env = String(v || "").trim().toLowerCase();
+            if (!["prod", "staging", "dev"].includes(env)) return ui.showToast("tag cancelled");
+            let n = 0;
+            for (const u of untagged) {
+              try {
+                await client.patchUsage(u.id, { environment: env });
+                n += 1;
+              } catch {
+                /* skip the row that failed; report the rest */
+              }
+            }
+            ui.showToast(`${GLYPH.check} tagged ${n} → ${env}`);
+            q.reload();
+          },
+        });
+      }
       if (input === "C" && usages.length) {
         return ui.askPrompt(`Type "clear" to delete ALL ${usages.length} usages`, {
           onSubmit: (v) => {
@@ -98,7 +124,10 @@ export function InventoryView({ client, ui, dir = ".", active, width = 78, heigh
         });
       }
       if (!cur) return;
-      if (input === "e") return patch(cur, { environment: ENV_ORDER[(ENV_ORDER.indexOf(cur.environment) + 1) % 4] }, "env updated");
+      if (input === "e") {
+        const i = ENV_ORDER.indexOf(cur.environment);
+        return patch(cur, { environment: ENV_ORDER[(i + 1) % ENV_ORDER.length] }, "env updated");
+      }
       if (input === "c") return patch(cur, { is_critical: !cur.is_critical }, "critical toggled");
       if (input === "d")
         return client