@standardagents/code 0.4.0 → 0.5.1

package/dist/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import os6 from 'os';
+import os6, { homedir } from 'os';
 import fs4 from 'fs';
 import path3 from 'path';
 import readline2 from 'readline/promises';
@@ -572,6 +572,20 @@ function gradAt(t) {
     Math.round(a[2] + (b[2] - a[2]) * k)
   ];
 }
+function cyclePos(t) {
+  const p = t - Math.floor(t);
+  return p < 0.5 ? p * 2 : 2 - p * 2;
+}
+function colorAtCycle(tri, tc) {
+  if (tc) {
+    const [r, g, b] = gradAt(tri);
+    return `\x1B[38;2;${r};${g};${b}m`;
+  }
+  return `\x1B[38;5;${GRAD_256[Math.min(GRAD_256.length - 1, Math.floor(tri * GRAD_256.length))]}m`;
+}
+function brandCycleColor(ms, periodMs = 1200) {
+  return colorAtCycle(cyclePos(ms / periodMs), truecolor());
+}
 function gradientText(text, phase = 0) {
   const chars = [...text];
   const visible = chars.filter((ch) => ch.trim().length > 0).length;
@@ -1832,6 +1846,130 @@ var SystemEvents = class {
   }
 };
 
+// src/wordmill.ts
+var MILL_WORDS = [
+  "Working",
+  "Thinking",
+  "Building",
+  "Brewing",
+  "Crafting",
+  "Scheming",
+  "Tinkering",
+  "Noodling",
+  "Pondering",
+  "Wrangling",
+  "Conjuring",
+  "Percolating",
+  "Assembling",
+  "Cogitating",
+  "Hatching",
+  "Forging",
+  // The silly shelf — irreverent, never profane.
+  "Pickling",
+  "Spooning",
+  "Marinating",
+  "Squishing",
+  "Wiggling",
+  "Frolicking",
+  "Moisturizing",
+  "Bamboozling",
+  "Skedaddling",
+  "Discombobulating",
+  "Waffling",
+  "Yodeling",
+  "Shimmying",
+  "Galumphing",
+  "Snorkeling",
+  "Bedazzling"
+];
+var FLIP_POOL = "abcdefghjkmnopqrstuvwxyz#$%&@!*+=.:~";
+var HOLD_MS = 2600;
+var LAZY_MS = 320;
+var LAZY_PERIOD = 200;
+var FAST_PERIOD = 70;
+var BOLD = "\x1B[1m";
+var DIM2 = "\x1B[2m";
+var OFF = "\x1B[22m";
+function glyphAt(slot, bucket) {
+  let h = (slot + 1) * 2654435761 ^ (bucket + 1) * 40503;
+  h = Math.imul(h ^ h >>> 13, 1274126177);
+  h ^= h >>> 16;
+  return FLIP_POOL[(h >>> 0) % FLIP_POOL.length];
+}
+var WordMill = class {
+  word = MILL_WORDS[0];
+  target = null;
+  // non-null while morphing
+  phaseAt = 0;
+  // clock time the current phase began
+  slots = [];
+  morphLen = 0;
+  rng;
+  constructor(rng = Math.random) {
+    this.rng = rng;
+  }
+  /** Restart at "Working" (called when a turn begins). */
+  reset(now) {
+    this.word = MILL_WORDS[0];
+    this.target = null;
+    this.phaseAt = now;
+  }
+  /** The plain word currently displayed or being formed (for tests). */
+  get current() {
+    return this.target ?? this.word;
+  }
+  /** The styled label for this frame (contains only bold/dim ANSI). */
+  text(now) {
+    if (this.phaseAt === 0) this.phaseAt = now;
+    if (!this.target) {
+      if (now - this.phaseAt >= HOLD_MS) this.beginMorph(now);
+      else return `${BOLD}${this.word}${OFF}`;
+    }
+    return this.morphFrame(now);
+  }
+  beginMorph(now) {
+    const options = MILL_WORDS.filter((w) => w !== this.word);
+    this.target = options[Math.floor(this.rng() * options.length)];
+    this.phaseAt = now;
+    const n = Math.max(this.word.length, this.target.length);
+    this.slots = [];
+    let maxLand = 0;
+    for (let i = 0; i < n; i++) {
+      const start = this.rng() * 500;
+      const land = 750 + i * 90 + this.rng() * 350;
+      this.slots.push({ start, land });
+      if (land > maxLand) maxLand = land;
+    }
+    this.morphLen = maxLand + 60;
+  }
+  morphFrame(now) {
+    const target = this.target;
+    const t = now - this.phaseAt;
+    if (t >= this.morphLen) {
+      this.word = target;
+      this.target = null;
+      this.phaseAt = now;
+      return `${BOLD}${this.word}${OFF}`;
+    }
+    let out = "";
+    for (let i = 0; i < this.slots.length; i++) {
+      const s = this.slots[i];
+      if (t < s.start) {
+        const ch = this.word[i];
+        if (ch) out += `${BOLD}${ch}${OFF}`;
+      } else if (t < s.land) {
+        const age = t - s.start;
+        const period = age < LAZY_MS ? LAZY_PERIOD : FAST_PERIOD;
+        out += `${DIM2}${glyphAt(i, Math.floor(t / period))}${OFF}`;
+      } else {
+        const ch = target[i];
+        if (ch) out += `${BOLD}${ch}${OFF}`;
+      }
+    }
+    return out;
+  }
+};
+
 // src/types.ts
 var LEVELS = [1, 2, 3, 4, 5];
 var LEVEL_DETAIL = {
@@ -1950,6 +2088,7 @@ var C = {
   teal: "\x1B[38;5;37m"
 };
 var FRAMES = ["\u28F7", "\u28EF", "\u28DF", "\u287F", "\u28BF", "\u28FB", "\u28FD", "\u28FE"];
+var SPINNER_MS = 70;
 var SUBAGENT_COLORS = [
   "\x1B[35m",
   // magenta
@@ -1966,6 +2105,19 @@ var SUBAGENT_COLORS = [
 ];
 var COMPACTION_COLOR = "\x1B[38;5;208m";
 var COMPACTION_AGENT = "compaction_agent";
+function isWideCodePoint(cp) {
+  return cp >= 4352 && cp <= 4447 || // Hangul Jamo
+  cp >= 11904 && cp <= 42191 || // CJK radicals … Yi
+  cp >= 44032 && cp <= 55203 || // Hangul syllables
+  cp >= 63744 && cp <= 64255 || // CJK compatibility ideographs
+  cp >= 65072 && cp <= 65103 || // CJK compatibility forms
+  cp >= 65280 && cp <= 65376 || // fullwidth forms
+  cp >= 65504 && cp <= 65510 || cp >= 127744 && cp <= 129791 || // emoji
+  cp >= 131072;
+}
+function sanitizeHudRow(s) {
+  return s.replace(/\x1b(?!\[)/g, "").replace(/[\x00-\x1a\x1c-\x1f\x7f]/g, " ");
+}
 var Tui = class _Tui {
   constructor(level = 1) {
     this.level = level;
@@ -1986,6 +2138,8 @@ var Tui = class _Tui {
   // caret's row offset from the input region top, last render
   working = false;
   workingStart = 0;
+  // Slot-machine morph for the working label (Working → Brewing → …).
+  wordMill = new WordMill();
   spinnerTimer = null;
   bgCount = 0;
   // The `[⚙ n bg]` prompt badge can be selected with ← from the start of the
@@ -2495,7 +2649,8 @@ var Tui = class _Tui {
     return `${(n / 1e6).toFixed(2)}M`;
   }
   spinnerFrame() {
-    return `${C.bold}${C.cyan}${FRAMES[Math.floor(Date.now() / 100) % FRAMES.length]}${C.reset}`;
+    const now = Date.now();
+    return `${C.bold}${brandCycleColor(now)}${FRAMES[Math.floor(now / SPINNER_MS) % FRAMES.length]}${C.reset}`;
   }
   /** "↑X ↓Y" cumulative token totals (greyed — low-priority). */
   tokensText() {
@@ -2568,7 +2723,7 @@ var Tui = class _Tui {
     if (this.working) {
       const el = this.formatElapsed(Date.now() - this.workingStart);
       const right = `${C.dim}${el}${C.reset}${tk ? " " + tk : ""}`;
-      const head = `${this.spinnerFrame()} ${C.bold}Working${C.reset}`;
+      const head = `${this.spinnerFrame()} ${this.wordMill.text(Date.now())}`;
       const avail = Math.max(
         0,
         cols2 - this.visibleWidth(head) - this.visibleWidth(right) - 2 - gaugeReserve
@@ -2599,7 +2754,50 @@ var Tui = class _Tui {
     return `${q}${bg}${this.levelColor()}\u276F${C.reset} `;
   }
   visibleWidth(s) {
-    return s.replace(/\x1b\[[0-9;]*m/g, "").length;
+    let w = 0;
+    for (const ch of s.replace(/\x1b\[[0-9;]*m/g, "")) {
+      w += isWideCodePoint(ch.codePointAt(0)) ? 2 : 1;
+    }
+    return w;
+  }
+  /**
+   * Truncate a styled string to at most `max` VISIBLE columns, copying ANSI
+   * escape sequences through without counting them and appending a reset if it
+   * cut mid-style. The redraw's whole height math assumes every HUD row is
+   * exactly ONE physical terminal row — true only while each row's visible
+   * width is strictly less than `cols`. A row of width == cols hits the
+   * terminal's auto-wrap boundary: many terminals push the cursor to the next
+   * line, so the following CR/LF yields an EXTRA physical row we didn't count,
+   * and the region marches down the screen leaving a trail on every tick. Every
+   * HUD row is clamped through here to keep that invariant no matter what any
+   * individual line builder produces.
+   */
+  clampVisible(s, max) {
+    let out = "";
+    let width = 0;
+    let i = 0;
+    let truncated = false;
+    while (i < s.length) {
+      if (s[i] === "\x1B" && s[i + 1] === "[") {
+        let j = i + 2;
+        while (j < s.length && !/[a-zA-Z]/.test(s[j])) j++;
+        out += s.slice(i, j + 1);
+        i = j + 1;
+        continue;
+      }
+      const cp = s.codePointAt(i);
+      const chLen = cp > 65535 ? 2 : 1;
+      const chWidth = isWideCodePoint(cp) ? 2 : 1;
+      if (width + chWidth > max) {
+        truncated = true;
+        break;
+      }
+      out += s.slice(i, i + chLen);
+      width += chWidth;
+      i += chLen;
+    }
+    if (truncated) out += C.reset;
+    return out;
   }
   /**
    * The slash-palette block rendered BELOW the input. While the palette is open
@@ -2612,7 +2810,7 @@ var Tui = class _Tui {
    */
   paletteBlockLines(cols2) {
     if (!this.paletteOpen()) return [];
-    const rows = this.paletteLines(cols2);
+    const rows = this.paletteLines(cols2).map((r) => this.clampVisible(r, Math.max(1, cols2 - 1)));
     const reserved = Math.max(this.commands.length, rows.length);
     while (rows.length < reserved) rows.push("");
     return rows;
@@ -2681,11 +2879,13 @@ var Tui = class _Tui {
     if (!this.started || this.takeoverHandler) return;
     const cols2 = process.stdout.columns || 80;
     this.moveToRegionTop();
-    process.stdout.write("\x1B[J");
     const hudWidths = [];
+    const hudRows = [];
+    const rowCap = Math.max(1, cols2 - 1);
     const writeHudRow = (line) => {
-      hudWidths.push(this.visibleWidth(line));
-      process.stdout.write(line + "\r\n");
+      const row = this.clampVisible(sanitizeHudRow(line), rowCap);
+      hudWidths.push(this.visibleWidth(row));
+      hudRows.push(row);
     };
     const previewLines = this.streamPreviewLines(cols2);
     for (const line of previewLines) writeHudRow(line);
@@ -2697,7 +2897,7 @@ var Tui = class _Tui {
     const quitLine = this.quitArmed ? `${C.dim}Press Control-C again to exit${C.reset}` : null;
     const quitRows = quitLine ? 1 : 0;
     if (quitLine) writeHudRow(quitLine);
-    const frame = FRAMES[Math.floor(Date.now() / 100) % FRAMES.length];
+    const frame = FRAMES[Math.floor(Date.now() / SPINNER_MS) % FRAMES.length];
     for (const sub of this.subagents) {
       const color = sub.agentName === COMPACTION_AGENT ? COMPACTION_COLOR : SUBAGENT_COLORS[this.subagentColorByID.get(sub.id) ?? 0];
       const budget = cols2 - 10;
@@ -2716,8 +2916,8 @@ var Tui = class _Tui {
     const prefix = this.promptPrefix();
     const pw = this.visibleWidth(prefix);
     const lines = this.inputBuffer.split("\n");
-    process.stdout.write(prefix + lines[0]);
-    for (let i = 1; i < lines.length; i++) process.stdout.write("\r\n" + lines[i]);
+    const tail = [prefix + lines[0]];
+    for (let i = 1; i < lines.length; i++) tail.push("\r\n" + lines[i]);
     const rowsOf = (len, lead) => Math.max(1, Math.ceil((lead + len) / cols2));
     const lineRows = lines.map((l, i) => rowsOf(l.length, i === 0 ? pw : 0));
     const inputRows = lineRows.reduce((a, b) => a + b, 0);
@@ -2732,18 +2932,18 @@ var Tui = class _Tui {
     for (let i = 0; i < caretLine; i++) caretRow += lineRows[i];
     const caretCol = caretCell % cols2;
     const paletteBlock = this.paletteBlockLines(cols2);
-    for (const line of paletteBlock) process.stdout.write("\r\n" + line);
+    for (const line of paletteBlock) tail.push("\r\n" + line);
     if (paletteBlock.length > 0) {
-      process.stdout.write("\r");
+      tail.push("\r");
       const up = inputRows - 1 + paletteBlock.length - caretRow;
-      if (up > 0) process.stdout.write(`\x1B[${up}A`);
-      if (caretCol > 0) process.stdout.write(`\x1B[${caretCol}C`);
+      if (up > 0) tail.push(`\x1B[${up}A`);
+      if (caretCol > 0) tail.push(`\x1B[${caretCol}C`);
       this.lastCursorRow = aboveRows + caretRow;
     } else if (this.cursorPos < this.inputBuffer.length) {
-      process.stdout.write("\r");
+      tail.push("\r");
       const up = inputRows - 1 - caretRow;
-      if (up > 0) process.stdout.write(`\x1B[${up}A`);
-      if (caretCol > 0) process.stdout.write(`\x1B[${caretCol}C`);
+      if (up > 0) tail.push(`\x1B[${up}A`);
+      if (caretCol > 0) tail.push(`\x1B[${caretCol}C`);
       this.lastCursorRow = aboveRows + caretRow;
     } else {
       this.lastCursorRow = aboveRows + (inputRows - 1);
@@ -2751,6 +2951,8 @@ var Tui = class _Tui {
     this.drawnHudWidths = hudWidths;
     this.lastDrawnCols = cols2;
     this.bottomDrawn = true;
+    const out = "\x1B[J" + hudRows.join("\r\n") + "\r\n" + tail.join("");
+    process.stdout.write(out);
   }
   clearBottom() {
     if (!this.bottomDrawn) return;
@@ -2986,6 +3188,7 @@ var Tui = class _Tui {
     if (on && !this.working) {
       this.working = true;
       this.workingStart = Date.now();
+      this.wordMill.reset(this.workingStart);
       this.goalComplete = false;
     } else if (!on) {
       this.working = false;
@@ -3017,7 +3220,7 @@ var Tui = class _Tui {
   syncSpinner() {
     const spinning = this.working || this.subagents.length > 0;
     if (spinning && !this.spinnerTimer) {
-      this.spinnerTimer = setInterval(() => this.renderBottom(), 100);
+      this.spinnerTimer = setInterval(() => this.renderBottom(), SPINNER_MS);
     } else if (!spinning && this.spinnerTimer) {
       clearInterval(this.spinnerTimer);
       this.spinnerTimer = null;
@@ -3063,7 +3266,7 @@ var Tui = class _Tui {
    * resets whenever the label changes.
    */
   setStep(label, outTokens) {
-    const next = label && label.trim() ? label.trim() : null;
+    const next = label && label.trim() ? label.replace(/\s+/g, " ").trim() : null;
     if (next !== this.step) {
       this.step = next;
       this.stepStart = Date.now();
@@ -3296,8 +3499,8 @@ function appendHistory(store, threadId, history, text) {
 // src/markdown.ts
 var ESC = "\x1B[";
 var R = ESC + "0m";
-var BOLD = ESC + "1m";
-var DIM2 = ESC + "2m";
+var BOLD2 = ESC + "1m";
+var DIM3 = ESC + "2m";
 var ITAL = ESC + "3m";
 var UNDER = ESC + "4m";
 var TEAL = ESC + "38;5;37m";
@@ -3319,11 +3522,11 @@ function inline(s) {
   });
   s = s.replace(
     /\[([^\]]+)\]\(([^)\s]+)\)/g,
-    (_, text, url) => `${CYAN}${UNDER}${text}${R} ${DIM2}${url}${R}`
+    (_, text, url) => `${CYAN}${UNDER}${text}${R} ${DIM3}${url}${R}`
   );
-  s = s.replace(/\*\*([^*]+)\*\*/g, (_, t) => `${BOLD}${t}${R}`);
+  s = s.replace(/\*\*([^*]+)\*\*/g, (_, t) => `${BOLD2}${t}${R}`);
   s = s.replace(/\*([^*\n]+)\*/g, (_, t) => `${ITAL}${t}${R}`);
-  s = s.replace(/~~([^~]+)~~/g, (_, t) => `${DIM2}${t}${R}`);
+  s = s.replace(/~~([^~]+)~~/g, (_, t) => `${DIM3}${t}${R}`);
   s = s.replace(/\x00(\d+)\x00/g, (_, i) => `${TEAL}${codes[+i].replace(/ /g, String.fromCharCode(160))}${R}`);
   return s;
 }
@@ -3376,7 +3579,7 @@ function renderTable(rows) {
     const cells = [];
     for (let c2 = 0; c2 < cols2; c2++) {
       const raw = r[c2] ?? "";
-      const styled = ri === 0 ? `${BOLD}${inline(raw)}${R}` : inline(raw);
+      const styled = ri === 0 ? `${BOLD2}${inline(raw)}${R}` : inline(raw);
       cells.push(padEndVisible(styled, widths[c2]));
     }
     out.push(("  " + cells.join(sep)).replace(/\s+$/, ""));
@@ -3416,7 +3619,7 @@ function renderMarkdown(src, cols2 = 80) {
     }
     const heading = line.match(/^(#{1,6})\s+(.*)$/);
     if (heading) {
-      for (const ln of wrapStyled(heading[2].trim(), cols2)) out.push(`${BOLD}${TEAL}${ln}${R}`);
+      for (const ln of wrapStyled(heading[2].trim(), cols2)) out.push(`${BOLD2}${TEAL}${ln}${R}`);
       i++;
       continue;
     }
@@ -3428,7 +3631,7 @@ function renderMarkdown(src, cols2 = 80) {
     const quote = line.match(/^\s*>\s?(.*)$/);
     if (quote) {
       for (const ln of wrapStyled(inline(quote[1]), Math.max(8, cols2 - 2))) {
-        out.push(`${GRAY}\u2502${R} ${DIM2}${ln}${R}`);
+        out.push(`${GRAY}\u2502${R} ${DIM3}${ln}${R}`);
       }
       i++;
       continue;
@@ -3444,7 +3647,7 @@ function renderMarkdown(src, cols2 = 80) {
     if (numbered) {
       const marker = `${numbered[2]}${numbered[3]}`;
       const leadWidth = numbered[1].length + marker.length + 1;
-      wrapBlock(out, cols2, `${numbered[1]}${BOLD}${marker}${R} `, " ".repeat(leadWidth), leadWidth, inline(numbered[4]));
+      wrapBlock(out, cols2, `${numbered[1]}${BOLD2}${marker}${R} `, " ".repeat(leadWidth), leadWidth, inline(numbered[4]));
       i++;
       continue;
     }
@@ -3733,7 +3936,7 @@ var McpManager = class {
       }));
       return {
         ok: true,
-        result: servers.length ? JSON.stringify({ servers }, null, 2) : "No MCP servers are connected. The user can add one with the /mcp command, or you can install one with install_mcp."
+        result: servers.length ? JSON.stringify({ servers }, null, 2) : 'No MCP servers are connected. The user can add one with the /mcp command, or you can install one with the mcp tool (action "install").'
       };
     }
     if (action === "list_tools") {
@@ -3889,6 +4092,107 @@ function saveDefaultEndpoint(endpoint) {
   } catch {
   }
 }
+var PKG_NAME = "@standardagents/code";
+var REGISTRY_URL = `https://registry.npmjs.org/${encodeURIComponent(PKG_NAME)}`;
+var CACHE_REL_DIR = ".config/standardagents-cli";
+var CACHE_FILE = "update-check.json";
+var CACHE_TTL_MS = 1e3 * 60 * 60 * 24;
+var CHECK_TIMEOUT_MS = 4e3;
+function cacheDir() {
+  return path3.join(homedir(), CACHE_REL_DIR);
+}
+function cachePath() {
+  return path3.join(cacheDir(), CACHE_FILE);
+}
+function readCache() {
+  try {
+    const raw = fs4.readFileSync(cachePath(), "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function writeCache(latest) {
+  try {
+    const dir = cacheDir();
+    if (!fs4.existsSync(dir)) fs4.mkdirSync(dir, { recursive: true });
+    fs4.writeFileSync(cachePath(), JSON.stringify({ latest, timestamp: Date.now() }));
+  } catch {
+  }
+}
+async function checkForUpdate(currentVersion) {
+  if (!currentVersion) return null;
+  if (process.env.NO_UPDATE_NOTIFIER || process.env.CI) return null;
+  const cached = readCache();
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
+    if (cached.latest !== currentVersion) {
+      return { current: currentVersion, latest: cached.latest };
+    }
+    return null;
+  }
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), CHECK_TIMEOUT_MS);
+  try {
+    const res = await fetch(REGISTRY_URL, {
+      signal: controller.signal,
+      headers: {
+        Accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*",
+        "User-Agent": `${PKG_NAME}/${currentVersion}`
+      }
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    const latest = data["dist-tags"]?.latest;
+    if (!latest) return null;
+    writeCache(latest);
+    if (latest !== currentVersion) {
+      return { current: currentVersion, latest };
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function forceCheckForUpdate(currentVersion) {
+  if (!currentVersion) return null;
+  if (process.env.NO_UPDATE_NOTIFIER || process.env.CI) return null;
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), CHECK_TIMEOUT_MS);
+  try {
+    const res = await fetch(REGISTRY_URL, {
+      signal: controller.signal,
+      headers: {
+        Accept: "application/vnd.npm.install-v1+json; q=1.0, application/json; q=0.8, */*",
+        "User-Agent": `${PKG_NAME}/${currentVersion}`
+      }
+    });
+    if (!res.ok) return null;
+    const data = await res.json();
+    const latest = data["dist-tags"]?.latest;
+    if (!latest) return null;
+    writeCache(latest);
+    if (latest !== currentVersion) {
+      return { current: currentVersion, latest };
+    }
+    return null;
+  } catch {
+    return null;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+function runNpmUpdate() {
+  return new Promise((resolve) => {
+    const child = spawn("npm", ["i", "-g", `${PKG_NAME}@latest`], {
+      stdio: "inherit",
+      shell: true
+    });
+    child.on("close", (code) => resolve(code === 0));
+    child.on("error", () => resolve(false));
+  });
+}
 
 // src/index.ts
 var AGENT_ID = "standard_code_agent";
@@ -3992,7 +4296,25 @@ function printAssistant(tui, text) {
   }
   tui.print("");
 }
+function startLoader(label) {
+  const frames = ["\u28F7", "\u28EF", "\u28DF", "\u287F", "\u28BF", "\u28FB", "\u28FD", "\u28FE"];
+  stdout.write("\x1B[?25l");
+  const draw = () => {
+    const now = Date.now();
+    const f = frames[Math.floor(now / 70) % frames.length];
+    stdout.write(`\r\x1B[K${brandCycleColor(now)}${f}${c.reset} ${c.dim}${label}\u2026${c.reset}`);
+  };
+  draw();
+  const timer = setInterval(draw, 70);
+  return {
+    stop: () => {
+      clearInterval(timer);
+      stdout.write("\r\x1B[K\x1B[?25h");
+    }
+  };
+}
 function farewell(stoppedProcs = 0) {
+  stdout.write("\x1B[?25h");
   if (stoppedProcs > 0) {
     stdout.write(
       `
@@ -4041,7 +4363,7 @@ function printWelcome(endpoint, projectDir) {
   const meta = [
     `${c.bold}${gradientText("Standard Code")}${c.reset}${version ? `  ${c.dim}v${version}${c.reset}` : ""}`,
     `${c.dim}terminal coding agent${c.reset}`,
-    `${c.teal}${host}${c.reset}`,
+    ...endpoint === PRODUCTION_ENDPOINT ? [] : [`${c.teal}${host}${c.reset}`],
     `${c.dim}${dir}${c.reset}`
   ];
   const markWidth = Math.max(...LOGO_MARK.map((l) => [...l].length));
@@ -4155,9 +4477,29 @@ ${c.dim}Press Control-C again to exit${c.reset}
 
 `);
   }
+  const version = readVersion();
+  let updateAvailable = null;
+  {
+    const loading = startLoader("Checking for updates");
+    updateAvailable = await checkForUpdate(version);
+    loading.stop();
+    if (updateAvailable) {
+      stdout.write(
+        `  ${c.teal}\u25C7${c.reset} ${c.dim}Update available:${c.reset} ${c.dim}v${updateAvailable.current}${c.reset} \u2192 ${c.bold}v${updateAvailable.latest}${c.reset}
+  ${c.dim}Run ${c.reset}${c.bold}npm i -g @standardagents/code@latest${c.reset}${c.dim} to update${c.reset}
+
+`
+      );
+    }
+  }
   const stored = getCredential(endpoint);
   let api = stored ? new ApiClient(endpoint, stored.access_token) : null;
-  const storedCheck = api ? await api.verifyDetailed() : null;
+  let storedCheck = null;
+  if (api) {
+    const connecting = startLoader("Connecting to Standard Agents");
+    storedCheck = await api.verifyDetailed();
+    connecting.stop();
+  }
   if (!api || !storedCheck?.ok) {
     const host = endpoint.replace(/^https?:\/\//, "").replace(/\/$/, "");
     if (storedCheck && !storedCheck.ok) {
@@ -4199,7 +4541,9 @@ ${c.dim}Press Control-C again to exit${c.reset}
         });
         if (!got) continue;
         api = new ApiClient(endpoint, got);
+        const connecting2 = startLoader("Connecting to Standard Agents");
         const check2 = await api.verifyDetailed();
+        connecting2.stop();
         if (check2.ok) {
           saveCredential(
             { endpoint, access_token: got, token_type: "Bearer", saved_at: Date.now() },
@@ -4213,7 +4557,9 @@ ${c.dim}Press Control-C again to exit${c.reset}
         continue;
       }
       api = new ApiClient(endpoint, token);
+      const connecting = startLoader("Connecting to Standard Agents");
       const check = await api.verifyDetailed();
+      connecting.stop();
       if (check.ok) {
         saveCredential(
           { endpoint, access_token: token, token_type: "Bearer", saved_at: Date.now() },
@@ -4232,18 +4578,20 @@ ${c.dim}Press Control-C again to exit${c.reset}
   handoffClosing = true;
   reader.rl?.close();
   const tags = [`path:${projectDir}`, `machine:${machine}`];
+  const loadingSessions = startLoader("Loading sessions");
   let existing = [];
   try {
     existing = await api.listThreads(AGENT_ID_VARIANTS, tags);
   } catch {
     existing = [];
   }
+  const summaries = existing.length > 0 ? await summarizeThreads(api, existing.slice(0, 8)) : [];
+  loadingSessions.stop();
   const tui = new Tui(1);
   let threadId;
   let resumed = false;
   let historySeed;
   if (existing.length > 0) {
-    const summaries = await summarizeThreads(api, existing.slice(0, 8));
     const items = summaries.map((s) => ({
       label: s.label,
       hint: s.hint,
@@ -4409,6 +4757,7 @@ async function runInteractive(tui, api, threadId, projectDir, machine, resumed,
   saveApprovals(api, threadId, perm);
   void api.kvSet(threadId, "session_info", { cwd: projectDir, machine }).catch(() => {
   });
+  const attaching = startLoader("Attaching to thread");
   let busy = false;
   let interrupting = false;
   const queued = [];
@@ -4502,7 +4851,8 @@ ${c.bold}why: ${req.requestPermission}${c.reset}` : ""}`,
       for (const s of subs) {
         const status = (s.status || "").trim();
         if (status === "idle" || status === "terminated") continue;
-        const detail = status && status !== "running" ? ` \u2014 ${status.slice(0, 80)}` : "";
+        const oneLineStatus = status.replace(/\s+/g, " ");
+        const detail = oneLineStatus && oneLineStatus !== "running" ? ` \u2014 ${oneLineStatus.slice(0, 80)}` : "";
         activeSubagents.set(s.id, {
           label: `${subagentLabel(s, agentTitles)}${detail}`,
           agentName: s.agent_name ?? void 0
@@ -4599,7 +4949,8 @@ ${c.bold}why: ${req.requestPermission}${c.reset}` : ""}`,
       return mcpCtl.connect(cfg);
     },
     // Seed the request into the main chat — the agent researches + installs it
-    // there (using research_agent + install_mcp), visible in the transcript.
+    // there (using research_agent + the mcp tool's install action), visible in
+    // the transcript.
     requestInstall: (query) => {
       void sendNow(
         `Install an MCP server for me: ${query}. Research the best one and its exact launch command, then install it.`
@@ -4649,10 +5000,11 @@ ${c.bold}why: ${req.requestPermission}${c.reset}` : ""}`,
     setEnabled: (name, enabled) => api.setSkillEnabled(name, enabled),
     remove: (name) => api.removeSkill(name),
     // Seed the request into the main chat — the agent researches or authors
-    // the skill there (research_agent + install_skill), visible in the transcript.
+    // the skill there (research_agent + the skill tool's install action),
+    // visible in the transcript.
     requestInstall: (query) => {
       void sendNow(
-        `Install a skill for me: ${query}. Find the skill's published files (or author a proper SKILL.md from your research), install it with install_skill, then tell me what it can do.`
+        `Install a skill for me: ${query}. Find the skill's published files (or author a proper SKILL.md from your research), install it, then tell me what it can do.`
       );
     }
   };
@@ -4696,6 +5048,7 @@ ${c.bold}why: ${req.requestPermission}${c.reset}` : ""}`,
     },
     { name: "background", label: "Background processes", hint: "list / stop", run: () => runProcessMenu(tui, bgMgr) },
     { name: "keybindings", label: "Keyboard shortcuts", run: () => showKeybindings(tui) },
+    { name: "update", label: "Check for updates", hint: "check npm for a newer version", run: () => runUpdateCommand(tui) },
     { name: "logout", label: "Sign out", hint: "delete the saved token & quit", run: () => logout() },
     { name: "quit", label: "Quit", run: () => quit() }
   ]);
@@ -4751,6 +5104,7 @@ ${c.bold}why: ${req.requestPermission}${c.reset}` : ""}`,
   await Promise.all([bridge.connect(), stream.connect()]);
   void api.getGoal(threadId).then((g) => tui.setGoal(g)).catch(() => {
   });
+  attaching.stop();
   tui.banner([
     `${c.bold}${c.magenta}Standard Code${c.reset} ${c.dim}\u2014 coding agent${c.reset}`,
     `${c.gray}project:${c.reset} ${projectDir}`,
@@ -4951,6 +5305,36 @@ function showKeybindings(tui) {
   tui.print(`${c.gray}  \u2190${c.reset}          from the start of the input: select the [\u2699 n bg] badge (enter opens it)`);
   tui.print(`${c.gray}  ctrl-c${c.reset}     quit`);
 }
+async function runUpdateCommand(tui) {
+  const version = readVersion();
+  const result = await forceCheckForUpdate(version);
+  if (!result) {
+    tui.print(`${c.green}\u2713${c.reset} ${c.gray}@standardagents/code${c.reset} is up to date (v${version})`);
+    return;
+  }
+  const { latest } = result;
+  tui.print(`
+  ${c.yellow}\u27F3${c.reset} Update available: ${c.gray}v${version}${c.reset} \u2192 ${c.green}v${latest}${c.reset}`);
+  const choice = await tui.select(`Update now with \`npm i -g @standardagents/code@latest\`?`, [
+    { label: "Yes, update now", value: "yes" },
+    { label: "No, skip", value: "no" }
+  ]);
+  if (choice === "yes") {
+    tui.print(`  ${c.gray}Running npm i -g @standardagents/code@latest\u2026${c.reset}`);
+    try {
+      const ok = await runNpmUpdate();
+      if (ok) {
+        tui.print(`  ${c.green}\u2713${c.reset} Updated to v${latest}. Restart to use the new version.`);
+      } else {
+        tui.print(`  ${c.red}\u2717${c.reset} Update failed.`);
+      }
+    } catch (e) {
+      tui.print(`  ${c.red}\u2717${c.reset} Update failed: ${e}`);
+    }
+  } else {
+    tui.print(`  ${c.gray}Skipped. Run /update later.${c.reset}`);
+  }
+}
 async function runProcessMenu(tui, bg) {
   const procs = await bg.list();
   if (!procs.length) {