u-foo 2.5.8 → 2.5.9

package/src/agents/providers/directAuthStatus.js

@@ -12,6 +12,10 @@ const {
   resolveClaudeOauthPaths,
   resolveClaudeUpstreamCredentials,
 } = require("./credentials/claude");
+const {
+  resolveKimiCredentialPaths,
+  resolveKimiUpstreamCredentials,
+} = require("./credentials/kimi");
 
 function normalizeRefreshWindowMs(value) {
   const num = Number(value);
@@ -27,6 +31,7 @@ function normalizeDirectAuthProvider(value = "") {
   const text = String(value || "").trim().toLowerCase();
   if (text === "claude" || text === "claude-cli" || text === "claude-code" || text === "anthropic") return "claude";
   if (text === "agy" || text === "agy-cli" || text === "antigravity") return "agy";
+  if (text === "kimi" || text === "kimi-code" || text === "moonshot") return "kimi";
   return "codex";
 }
 
@@ -272,6 +277,41 @@ async function inspectAgyDirectAuth({
   };
 }
 
+async function inspectKimiDirectAuth({
+  env = process.env,
+  fetchImpl = global.fetch,
+  autoRefresh = false,
+} = {}) {
+  const paths = resolveKimiCredentialPaths({ env });
+  try {
+    const credential = await resolveKimiUpstreamCredentials({
+      env,
+      fetchImpl,
+      autoRefresh,
+    });
+    return {
+      ok: true,
+      provider: "kimi",
+      transport: "openai-chat",
+      credentialKind: String(credential.credentialKind || ""),
+      source: String(credential.source || ""),
+      state: String(credential.state || ""),
+      refreshable: credential.refreshable === true,
+      expiresAt: String(credential.expiresAt || ""),
+      credentialPath: String(credential.credentialPath || paths.credentialPath || ""),
+    };
+  } catch (err) {
+    return {
+      ok: false,
+      provider: "kimi",
+      error: err && err.message ? err.message : "Kimi direct API credentials are unavailable",
+      errorCode: normalizeErrorCode(err, "KIMI_AUTH_STATUS_FAILED"),
+      credentialPath: paths.credentialPath || "",
+      hint: "Run `kimi` once to sign in or set UFOO_UCODE_API_KEY; ufoo-agent will not fall back to the CLI.",
+    };
+  }
+}
+
 async function inspectDirectAuthStatus(options = {}) {
   const { projectRoot, loadConfigImpl = loadConfig, provider = "" } = options;
   const config = loadConfigImpl(projectRoot) || {};
@@ -286,6 +326,9 @@ async function inspectDirectAuthStatus(options = {}) {
   if (selected === "agy") {
     return inspectAgyDirectAuth(nextOptions);
   }
+  if (selected === "kimi") {
+    return inspectKimiDirectAuth(nextOptions);
+  }
   return inspectCodexDirectAuth(nextOptions);
 }
 
@@ -423,6 +466,52 @@ function formatAgyDirectAuthStatus(status = {}, options = {}) {
   return lines;
 }
 
+function formatKimiDirectAuthStatus(status = {}, options = {}) {
+  if (options.compact === true) {
+    if (status.ok) {
+      const credential = status.credentialKind || "credential";
+      const transport = status.transport || "openai-chat";
+      const state = status.state || "unknown";
+      const details = [
+        status.source || "",
+        status.expiresAt ? `expires ${formatCompactExpires(status.expiresAt)}` : "",
+        status.refreshable ? "refreshable" : "",
+      ].filter(Boolean);
+      const lines = [
+        `Kimi API: OK · ${credential}/${transport} · ${state}`,
+      ];
+      if (details.length > 0) lines.push(`  ${details.join(" · ")}`);
+      return lines;
+    }
+
+    const hint = String(status.hint || "Run `kimi` once to sign in or set UFOO_UCODE_API_KEY.").replace(/;.*$/, ".");
+    return [
+      `Kimi API: FAIL · ${status.errorCode || "KIMI_AUTH_STATUS_FAILED"}`,
+      `  ${status.error || "Kimi direct API credentials are unavailable"} · ${hint}`,
+    ];
+  }
+
+  if (status.ok) {
+    const state = status.state || "unknown";
+    const lines = [
+      `Kimi direct API: OK (${status.transport || "openai-chat"}, ${status.credentialKind || "credential"}, ${state})`,
+      `  - source: ${status.source || "(unknown)"}`,
+    ];
+    if (status.expiresAt) lines.push(`  - expires: ${status.expiresAt}`);
+    if (status.credentialPath) lines.push(`  - path: ${status.credentialPath}`);
+    if (status.refreshable) lines.push("  - refreshable: yes");
+    return lines;
+  }
+
+  const lines = [
+    `Kimi direct API: FAIL (${status.errorCode || "KIMI_AUTH_STATUS_FAILED"})`,
+    `  - ${status.error || "Kimi direct API credentials are unavailable"}`,
+  ];
+  if (status.credentialPath) lines.push(`  - expected path: ${status.credentialPath}`);
+  if (status.hint) lines.push(`  - ${status.hint}`);
+  return lines;
+}
+
 function formatDirectAuthStatus(status = {}, options = {}) {
   if (status.provider === "claude") {
     return formatClaudeDirectAuthStatus(status, options);
@@ -430,6 +519,9 @@ function formatDirectAuthStatus(status = {}, options = {}) {
   if (status.provider === "agy") {
     return formatAgyDirectAuthStatus(status, options);
   }
+  if (status.provider === "kimi") {
+    return formatKimiDirectAuthStatus(status, options);
+  }
   return formatCodexDirectAuthStatus(status, options);
 }
 
@@ -438,10 +530,12 @@ module.exports = {
   inspectCodexDirectAuth,
   inspectClaudeDirectAuth,
   inspectAgyDirectAuth,
+  inspectKimiDirectAuth,
   formatDirectAuthStatus,
   formatCodexDirectAuthStatus,
   formatClaudeDirectAuthStatus,
   formatAgyDirectAuthStatus,
+  formatKimiDirectAuthStatus,
   normalizeDirectAuthProvider,
   classifyAgyLogTail,
 };

package/src/app/chat/commandExecutor.js

@@ -59,6 +59,9 @@ function normalizeSettingsProvider(value = "", fallback = "codex-cli") {
   if (text === "agy" || text === "agy-cli" || text === "antigravity") {
     return "agy-cli";
   }
+  if (text === "kimi" || text === "kimi-cli" || text === "kimi-code" || text === "ukimi") {
+    return "kimi-cli";
+  }
   if (text === "codex" || text === "codex-cli" || text === "codex-code" || text === "openai") {
     return "codex-cli";
   }
@@ -69,6 +72,7 @@ function agentProviderKey(value = "") {
   const provider = normalizeSettingsProvider(value);
   if (provider === "claude-cli") return "claude";
   if (provider === "agy-cli") return "agy";
+  if (provider === "kimi-cli") return "kimi";
   return "codex";
 }
 
@@ -597,7 +601,7 @@ function createCommandExecutor(options = {}) {
     if (args.length === 0) {
       logMessage(
         "error",
-        "{white-fg}✗{/white-fg} Usage: /launch <claude|codex|agy|ucode> [nickname=<name>] [profile=<id>] [count=<n>] [scope=inplace|window]"
+        "{white-fg}✗{/white-fg} Usage: /launch <claude|codex|agy|kimi|ucode> [nickname=<name>] [profile=<id>] [count=<n>] [scope=inplace|window]"
       );
       return;
     }
@@ -606,8 +610,9 @@ function createCommandExecutor(options = {}) {
     // Accept friendly aliases the same way `ufoo launch` does in cli.js.
     let agentType = agentTypeInput;
     if (agentTypeInput === "antigravity" || agentTypeInput === "uagy") agentType = "agy";
-    if (agentType !== "claude" && agentType !== "codex" && agentType !== "agy" && agentType !== "ucode") {
-      logMessage("error", "{white-fg}✗{/white-fg} Unknown agent type. Use: claude, codex, agy, or ucode");
+    if (agentTypeInput === "kimi-cli" || agentTypeInput === "kimi-code" || agentTypeInput === "ukimi") agentType = "kimi";
+    if (agentType !== "claude" && agentType !== "codex" && agentType !== "agy" && agentType !== "kimi" && agentType !== "ucode") {
+      logMessage("error", "{white-fg}✗{/white-fg} Unknown agent type. Use: claude, codex, agy, kimi, or ucode");
       return;
     }
     const normalizedAgent = agentType === "ucode" ? "ufoo" : agentType;
@@ -1380,11 +1385,11 @@ function createCommandExecutor(options = {}) {
       return;
     }
 
-    if (action === "codex" || action === "claude" || action === "agy") {
+    if (action === "codex" || action === "claude" || action === "agy" || action === "kimi") {
       const kv = parseKeyValueArgs(args.slice(1));
       const provider = action === "claude"
         ? "claude-cli"
-        : (action === "agy" ? "agy-cli" : "codex-cli");
+        : (action === "agy" ? "agy-cli" : (action === "kimi" ? "kimi-cli" : "codex-cli"));
       const model = String(kv.model || defaultAgentModelForProvider(provider)).trim();
       saveConfig(projectRoot, {
         agentProvider: provider,

package/src/app/chat/commands.js

@@ -228,6 +228,7 @@ function normalizeAgentLabel(value = "") {
   if (raw === "claude" || raw === "uclaude") return "claude";
   if (raw === "codex" || raw === "ucodex") return "codex";
   if (raw === "agy" || raw === "antigravity" || raw === "uagy") return "agy";
+  if (raw === "kimi" || raw === "kimi-cli" || raw === "kimi-code" || raw === "ukimi") return "kimi";
   if (raw === "ucode" || raw === "ufoo") return "ufoo";
   return raw || "agent";
 }

package/src/app/chat/dashboardView.js

@@ -5,6 +5,7 @@ const DEFAULT_MODE_OPTIONS = ["auto", "host", "terminal", "tmux", "internal"];
 function providerLabel(value) {
   if (value === "claude-cli") return "claude";
   if (value === "agy-cli" || value === "agy" || value === "antigravity") return "agy";
+  if (value === "kimi-cli" || value === "kimi" || value === "kimi-code") return "kimi";
   if (value === "ucode" || value === "ufoo" || value === "ufoo-code") return "ucode";
   return "codex";
 }

package/src/app/chat/multiWindow/index.js

@@ -2,6 +2,11 @@ const { calculatePaneLayout } = require("./paneLayout");
 const { createPaneManager } = require("./paneManager");
 const { createRenderer } = require("./renderer");
 
+// Pane output bursts are coalesced into short batches; full chrome repaints
+// are throttled with a trailing frame so the final state always renders.
+const PANE_OUTPUT_BATCH_MS = 50;
+const RENDER_ALL_MIN_INTERVAL_MS = 100;
+
 function createMultiWindowController(options = {}) {
   const {
     processStdout = process.stdout,
@@ -30,6 +35,9 @@ function createMultiWindowController(options = {}) {
   let active = false;
   let renderThrottleTimer = null;
   let dirtyPanes = new Set();
+  let renderAllTimer = null;
+  let renderAllTrailing = false;
+  let lastRenderAllAt = 0;
   let lastCompletionPopup = null;
   const renderer = createRenderer({ write: (d) => processStdout.write(d) });
   const paneManager = createPaneManager({
@@ -37,18 +45,14 @@ function createMultiWindowController(options = {}) {
     onInternalSubmit,
     onPaneOutput: (agentId) => {
       if (!active) return;
-      if (getTerminalFocused()) {
-        renderSinglePane(agentId);
-      } else {
-        dirtyPanes.add(agentId);
-        if (!renderThrottleTimer) {
-          renderThrottleTimer = setTimeout(() => {
-            renderThrottleTimer = null;
-            const panes = [...dirtyPanes];
-            dirtyPanes.clear();
-            for (const id of panes) renderSinglePane(id);
-          }, 200);
-        }
+      dirtyPanes.add(agentId);
+      if (!renderThrottleTimer) {
+        renderThrottleTimer = setTimeout(() => {
+          renderThrottleTimer = null;
+          const panes = [...dirtyPanes];
+          dirtyPanes.clear();
+          for (const id of panes) renderSinglePane(id);
+        }, PANE_OUTPUT_BATCH_MS);
       }
     },
   });
@@ -62,7 +66,7 @@ function createMultiWindowController(options = {}) {
     renderer.hideCursor();
     renderer.clear();
     syncAgents();
-    renderAll();
+    renderAllNow();
     return true;
   }
 
@@ -74,6 +78,11 @@ function createMultiWindowController(options = {}) {
       renderThrottleTimer = null;
       dirtyPanes.clear();
     }
+    if (renderAllTimer) {
+      clearTimeout(renderAllTimer);
+      renderAllTimer = null;
+      renderAllTrailing = false;
+    }
     paneManager.disconnectAll();
     renderer.showCursor();
     restoreTerminal();
@@ -130,13 +139,41 @@ function createMultiWindowController(options = {}) {
     }
   }
 
-  function renderAll() {
+  function renderAllNow() {
     if (!active) return;
+    lastRenderAllAt = Date.now();
     try {
       const agents = paneManager.getAgentIds();
       const layout = calculatePaneLayout(getCols(), getRows(), agents.length);
       const cols = getCols();
 
+      // Resolve the completion popup up front so stale rows are cleared
+      // before anything repaints (clearing also invalidates renderer caches).
+      const cmp = getCompletions();
+      let nextCompletionPopup = null;
+      let nextCompletionItems = null;
+      let nextCompletionStart = 0;
+      if (cmp && Array.isArray(cmp.items) && cmp.items.length > 0 && layout.inputPane) {
+        const start = Math.min(cmp.windowStart || 0, Math.max(0, cmp.items.length - (cmp.pageSize || 8)));
+        const end = Math.min(cmp.items.length, start + (cmp.pageSize || 8));
+        const visible = cmp.items.slice(start, end);
+        const popupTop = layout.inputPane.top - visible.length - 1;
+        if (popupTop >= 0) {
+          nextCompletionPopup = { top: popupTop, left: 0, width: cols, height: visible.length + 1 };
+          nextCompletionItems = visible;
+          nextCompletionStart = start;
+        }
+      }
+      const prevPopup = lastCompletionPopup;
+      const samePopupRect = prevPopup && nextCompletionPopup &&
+        prevPopup.top === nextCompletionPopup.top &&
+        prevPopup.width === nextCompletionPopup.width &&
+        prevPopup.height === nextCompletionPopup.height &&
+        (prevPopup.left || 0) === (nextCompletionPopup.left || 0);
+      if (prevPopup && !samePopupRect && typeof renderer.clearRows === "function") {
+        renderer.clearRows(prevPopup.top, prevPopup.height, prevPopup.width, prevPopup.left || 0);
+      }
+
       renderer.renderChatLog(layout.chatPane, getChatLogLines());
 
       const focused = getTerminalFocused() ? paneManager.getFocused() : null;
@@ -173,35 +210,19 @@ function createMultiWindowController(options = {}) {
         renderer.renderDashboard(layout.dashboardPane, lines);
       }
 
-      const cmp = getCompletions();
-      let nextCompletionPopup = null;
-      if (lastCompletionPopup && typeof renderer.clearRows === "function") {
-        renderer.clearRows(
-          lastCompletionPopup.top,
-          lastCompletionPopup.height,
-          lastCompletionPopup.width,
-          lastCompletionPopup.left || 0
-        );
-      }
-      if (cmp && Array.isArray(cmp.items) && cmp.items.length > 0 && layout.inputPane) {
-        const start = Math.min(cmp.windowStart || 0, Math.max(0, cmp.items.length - (cmp.pageSize || 8)));
-        const end = Math.min(cmp.items.length, start + (cmp.pageSize || 8));
-        const visible = cmp.items.slice(start, end);
-        const popupTop = layout.inputPane.top - visible.length - 1;
-        if (popupTop >= 0) {
-          nextCompletionPopup = { top: popupTop, left: 0, width: cols, height: visible.length + 1 };
-          renderer.renderSeparator({ top: popupTop, left: 0, width: cols });
-          for (let i = 0; i < visible.length; i++) {
-            const idx = start + i;
-            const selected = idx === cmp.index;
-            const label = visible[i].label || "";
-            const desc = visible[i].description || "";
-            const line = selected
-              ? `\x1b[7;36m${label}\x1b[0m  \x1b[90m${desc}\x1b[0m`
-              : `\x1b[90m${label}  ${desc}\x1b[0m`;
-            const pad = Math.max(0, cols - renderer.visibleLength(line));
-            renderer.write(renderer.moveTo(popupTop + 1 + i, 0) + line + " ".repeat(pad) + "\x1b[0m");
-          }
+      if (nextCompletionPopup && nextCompletionItems) {
+        const popupTop = nextCompletionPopup.top;
+        renderer.renderSeparator({ top: popupTop, left: 0, width: cols });
+        for (let i = 0; i < nextCompletionItems.length; i++) {
+          const idx = nextCompletionStart + i;
+          const selected = idx === cmp.index;
+          const label = nextCompletionItems[i].label || "";
+          const desc = nextCompletionItems[i].description || "";
+          const line = selected
+            ? `\x1b[7;36m${label}\x1b[0m  \x1b[90m${desc}\x1b[0m`
+            : `\x1b[90m${label}  ${desc}\x1b[0m`;
+          const pad = Math.max(0, cols - renderer.visibleLength(line));
+          renderer.write(renderer.moveTo(popupTop + 1 + i, 0) + line + " ".repeat(pad) + "\x1b[0m");
         }
       }
       lastCompletionPopup = nextCompletionPopup;
@@ -210,6 +231,27 @@ function createMultiWindowController(options = {}) {
     }
   }
 
+  // Throttled entry point for external callers: renders immediately when idle,
+  // otherwise coalesces bursts into one trailing frame so state stays consistent.
+  function renderAll() {
+    if (!active) return;
+    const elapsed = Date.now() - lastRenderAllAt;
+    if (!renderAllTimer && elapsed >= RENDER_ALL_MIN_INTERVAL_MS) {
+      renderAllNow();
+      return;
+    }
+    renderAllTrailing = true;
+    if (!renderAllTimer) {
+      renderAllTimer = setTimeout(() => {
+        renderAllTimer = null;
+        if (!renderAllTrailing) return;
+        renderAllTrailing = false;
+        renderAllNow();
+      }, Math.max(RENDER_ALL_MIN_INTERVAL_MS - elapsed, 16));
+      if (typeof renderAllTimer.unref === "function") renderAllTimer.unref();
+    }
+  }
+
   function handleKey(key) {
     if (!active) return false;
 
@@ -219,7 +261,7 @@ function createMultiWindowController(options = {}) {
 
     if (key.name === "w" && key.ctrl) {
       paneManager.cycleFocus();
-      renderAll();
+      renderAllNow();
       return true;
     }
 
@@ -237,14 +279,14 @@ function createMultiWindowController(options = {}) {
     if (!agents.includes(agentId)) return;
     paneManager.setFocused(agentId);
     onFocusAgent(agentId);
-    renderAll();
+    renderAllNow();
   }
 
   function handleResize() {
     if (!active) return;
     syncAgents();
     renderer.clear();
-    renderAll();
+    renderAllNow();
   }
 
   function isActive() { return active; }

package/src/app/chat/multiWindow/renderer.js

@@ -10,10 +10,36 @@ function createRenderer(options = {}) {
     write: rawWrite = process.stdout.write.bind(process.stdout),
   } = options;
 
+  // Last-write caches used to skip redundant output. Both are reset by
+  // clear()/clearRows() so a blanked region is always repainted.
+  let slotCache = new Map();
+  let paneSigs = new WeakMap();
+
   function write(data) {
     try { rawWrite(data); } catch {}
   }
 
+  function writeIfChanged(slot, data, top, height) {
+    const prev = slotCache.get(slot);
+    if (prev && prev.data === data && prev.top === top) return;
+    slotCache.set(slot, { data, top, height });
+    write(data);
+  }
+
+  function paneSignature(pane, focused, extra) {
+    return [pane.top, pane.left, pane.width, pane.height, focused ? 1 : 0, extra || ""].join("|");
+  }
+
+  function shouldSkipPane(vt, sig, force) {
+    if (force || paneSigs.get(vt) !== sig) return false;
+    return typeof vt.isDirty === "function" ? !vt.isDirty() : false;
+  }
+
+  function markPaneRendered(vt, sig) {
+    paneSigs.set(vt, sig);
+    if (vt && typeof vt.clearDirty === "function") vt.clearDirty();
+  }
+
   function moveTo(row, col) {
     return `\x1b[${row + 1};${col + 1}H`;
   }
@@ -59,7 +85,9 @@ function createRenderer(options = {}) {
     );
   }
 
-  function renderPane(vt, pane, focused, label) {
+  function renderPane(vt, pane, focused, label, opts = {}) {
+    const sig = paneSignature(pane, focused, label || "");
+    if (shouldSkipPane(vt, sig, opts.force)) return;
     const { buffer, rows, cols, cursorRow, cursorCol } = vt.getScreen();
     const { top, left, width, height } = pane;
 
@@ -108,6 +136,7 @@ function createRenderer(options = {}) {
     out += moveTo(top + height - 1, left) + borderColor + botLine + reset;
 
     write(out);
+    markPaneRendered(vt, sig);
   }
 
   function renderCells(cells, maxWidth, cursorCol = -1) {
@@ -147,7 +176,13 @@ function createRenderer(options = {}) {
     return `${color}${truncated}${" ".repeat(pad)}${reset}`;
   }
 
-  function renderInternalPane(vt, pane, focused, info = {}) {
+  function renderInternalPane(vt, pane, focused, info = {}, opts = {}) {
+    const extra = JSON.stringify([
+      info.label || "", info.status || "", info.detail || "",
+      info.input || "", info.cursor ?? "",
+    ]);
+    const sig = paneSignature(pane, focused, extra);
+    if (shouldSkipPane(vt, sig, opts.force)) return;
     const { buffer, rows, cols } = vt.getScreen();
     const { top, left, width, height } = pane;
 
@@ -217,6 +252,7 @@ function createRenderer(options = {}) {
     out += moveTo(top + height - 1, left) + borderColor + botLine + reset;
 
     write(out);
+    markPaneRendered(vt, sig);
   }
 
   function stripControl(str) {
@@ -288,14 +324,14 @@ function createRenderer(options = {}) {
       out += truncated + reset + " ".repeat(pad);
       out += dim + BOX.v + reset;
     }
-    write(out);
+    writeIfChanged("chatlog", out, top, height);
   }
 
   function renderSeparator(pane, highlighted) {
     const { top, left, width } = pane;
     const reset = "\x1b[0m";
     const color = highlighted ? "\x1b[36m" : "\x1b[90m";
-    write(moveTo(top, left) + color + "─".repeat(width) + reset);
+    writeIfChanged(`sep:${top}:${left}`, moveTo(top, left) + color + "─".repeat(width) + reset, top, 1);
   }
 
   function renderStatusLine(pane, text) {
@@ -304,17 +340,19 @@ function createRenderer(options = {}) {
     const dim = "\x1b[90m";
     const truncated = truncateVisible(text || "", width);
     const pad = Math.max(0, width - visibleLength(truncated));
-    write(moveTo(top, left) + dim + truncated + " ".repeat(pad) + reset);
+    writeIfChanged("status", moveTo(top, left) + dim + truncated + " ".repeat(pad) + reset, top, 1);
   }
 
   function renderDashboard(pane, lines) {
     const { top, left, width } = pane;
     const reset = "\x1b[0m";
+    let out = "";
     for (let i = 0; i < lines.length; i++) {
       const line = lines[i] || "";
       const pad = Math.max(0, width - visibleLength(line));
-      write(moveTo(top + i, left) + line + " ".repeat(pad) + reset);
+      out += moveTo(top + i, left) + line + " ".repeat(pad) + reset;
     }
+    writeIfChanged("dashboard", out, top, lines.length);
   }
 
   function renderInputPrompt(pane, prefix, draft, cursor) {
@@ -331,17 +369,28 @@ function createRenderer(options = {}) {
     const promptLine = cyan + prefixStr + reset + before + inverse + cursorChar + reset + after;
     const truncated = truncateVisible(promptLine, width);
     const pad = Math.max(0, width - visibleLength(truncated));
-    write(moveTo(top, left) + truncated + " ".repeat(pad) + reset);
+    writeIfChanged("input", moveTo(top, left) + truncated + " ".repeat(pad) + reset, top, 1);
   }
 
   function hideCursor() { write("\x1b[?25l"); }
   function showCursor() { write("\x1b[?25h"); }
-  function clear() { write("\x1b[2J\x1b[H"); }
+  function clear() {
+    slotCache = new Map();
+    paneSigs = new WeakMap();
+    write("\x1b[2J\x1b[H");
+  }
 
   function clearRows(top, count, width, left = 0) {
     const rows = Math.max(0, Number(count) || 0);
     const cols = Math.max(0, Number(width) || 0);
     if (rows === 0 || cols === 0) return;
+    // Blanked rows must be repainted on the next pass: drop every cached
+    // slot overlapping the cleared range and reset pane signatures (kept
+    // in a WeakMap, so they cannot be filtered selectively).
+    for (const [slot, entry] of slotCache) {
+      if (entry.top < top + rows && top < entry.top + entry.height) slotCache.delete(slot);
+    }
+    paneSigs = new WeakMap();
     let out = "";
     const blank = " ".repeat(cols);
     for (let i = 0; i < rows; i++) {

package/src/app/cli/run.js

@@ -733,8 +733,8 @@ async function runCli(argv) {
 
     program
       .command("launch")
-      .description("Launch an agent (uclaude, ucodex, uagy, ucode)")
-      .argument("<agent>", "Agent type: uclaude|ucodex|uagy|ucode|claude|codex|agy")
+      .description("Launch an agent (uclaude, ucodex, uagy, ukimi, ucode)")
+      .argument("<agent>", "Agent type: uclaude|ucodex|uagy|ukimi|ucode|claude|codex|agy|kimi")
       .argument("[nickname]", "Optional nickname for the agent")
       .option("--profile <id>", "Prompt profile to assign after launch")
       .action(async (agent, nickname, opts) => {
@@ -751,11 +751,13 @@ async function runCli(argv) {
             normalizedAgent = "codex";
           } else if (agentLower === "uagy" || agentLower === "agy" || agentLower === "antigravity") {
             normalizedAgent = "agy";
+          } else if (agentLower === "ukimi" || agentLower === "kimi" || agentLower === "kimi-cli" || agentLower === "kimi-code") {
+            normalizedAgent = "kimi";
           } else if (agentLower === "ucode" || agentLower === "ufoo-code" || agentLower === "ufoo") {
             normalizedAgent = "ucode";
           } else {
             console.error(`Unknown agent type: ${agent}`);
-            console.error("Valid types: uclaude, ucodex, uagy, ucode, claude, codex, agy");
+            console.error("Valid types: uclaude, ucodex, uagy, ukimi, ucode, claude, codex, agy, kimi");
             process.exitCode = 1;
             return;
           }