@llmist/cli 15.5.0 → 15.6.0

package/dist/cli.js

@@ -98,7 +98,7 @@ import { Command, InvalidArgumentError as InvalidArgumentError2 } from "commande
 // package.json
 var package_default = {
   name: "@llmist/cli",
-  version: "15.5.0",
+  version: "15.6.0",
   description: "CLI for llmist - run LLM agents from the command line",
   type: "module",
   main: "dist/cli.js",
@@ -154,7 +154,7 @@ var package_default = {
     node: ">=22.0.0"
   },
   dependencies: {
-    llmist: "^15.5.0",
+    llmist: "^15.6.0",
     "@unblessed/node": "^1.0.0-alpha.23",
     chalk: "^5.6.2",
     commander: "^12.1.0",
@@ -168,7 +168,7 @@ var package_default = {
     zod: "^4.1.12"
   },
   devDependencies: {
-    "@llmist/testing": "^15.5.0",
+    "@llmist/testing": "^15.6.0",
     "@types/diff": "^8.0.0",
     "@types/js-yaml": "^4.0.9",
     "@types/marked-terminal": "^6.1.1",
@@ -4094,6 +4094,7 @@ function configToAgentOptions(config) {
     if (r["max-timeout"] !== void 0) result.retryMaxTimeout = r["max-timeout"];
     if (r.enabled === false) result.noRetry = true;
   }
+  if (config["show-hints"] !== void 0) result.showHints = config["show-hints"];
   return result;
 }
 
@@ -4671,6 +4672,10 @@ var BlockRenderer = class _BlockRenderer {
   currentSessionId = 0;
   /** Previous session ID (for deferred cleanup) */
   previousSessionId = null;
+  /** Callback for content state changes (empty to non-empty or vice versa) */
+  onHasContentChangeCallback = null;
+  /** Last reported hasContent state (to avoid duplicate callbacks) */
+  lastHasContentState = false;
   constructor(container, renderCallback, renderNowCallback) {
     this.container = container;
     this.renderCallback = renderCallback;
@@ -4971,6 +4976,16 @@ var BlockRenderer = class _BlockRenderer {
       child.detach();
     }
     this.renderCallback();
+    this.notifyHasContentChange();
+  }
+  /**
+   * Set callback for content state changes.
+   * Called when blocks transition from empty to non-empty or vice versa.
+   * Used by HintsBar to know when "^B browse" hint should be shown.
+   */
+  onHasContentChange(callback) {
+    this.onHasContentChangeCallback = callback;
+    callback(this.blocks.size > 0);
   }
   /**
    * Start a new session. Called at the start of each REPL turn.
@@ -5010,6 +5025,7 @@ var BlockRenderer = class _BlockRenderer {
     }
     this.previousSessionId = null;
     this.renderCallback();
+    this.notifyHasContentChange();
   }
   /**
    * Get the current session ID (for node creation).
@@ -5098,6 +5114,17 @@ var BlockRenderer = class _BlockRenderer {
   // ───────────────────────────────────────────────────────────────────────────
   // Private - Node & Block Management
   // ───────────────────────────────────────────────────────────────────────────
+  /**
+   * Notify callback if content state has changed.
+   * Only fires when transitioning from empty to non-empty or vice versa.
+   */
+  notifyHasContentChange() {
+    const hasContent = this.blocks.size > 0;
+    if (hasContent !== this.lastHasContentState) {
+      this.lastHasContentState = hasContent;
+      this.onHasContentChangeCallback?.(hasContent);
+    }
+  }
   generateId(prefix) {
     return `${prefix}_${++this.nodeIdCounter}`;
   }
@@ -5124,6 +5151,7 @@ var BlockRenderer = class _BlockRenderer {
     }
     this.applyBottomAlignmentAndScroll();
     this.renderCallback();
+    this.notifyHasContentChange();
   }
   /**
    * Render a node and its children recursively.
@@ -5269,8 +5297,8 @@ ${fullContent}
       case "system_message": {
         const icon = this.getSystemMessageIcon(node.category);
         const color = this.getSystemMessageColor(node.category);
-        const RESET2 = "\x1B[0m";
-        return `${indent}${color}${icon} ${node.message}${RESET2}`;
+        const RESET3 = "\x1B[0m";
+        return `${indent}${color}${icon} ${node.message}${RESET3}`;
       }
     }
   }
@@ -5297,7 +5325,7 @@ ${fullContent}
   getSystemMessageColor(category) {
     const YELLOW2 = "\x1B[33m";
     const BLUE = "\x1B[34m";
-    const GRAY = "\x1B[90m";
+    const GRAY2 = "\x1B[90m";
     const RED2 = "\x1B[31m";
     switch (category) {
       case "throttle":
@@ -5305,7 +5333,7 @@ ${fullContent}
       case "retry":
         return BLUE;
       case "info":
-        return GRAY;
+        return GRAY2;
       case "warning":
         return YELLOW2;
       case "error":
@@ -5579,6 +5607,7 @@ ${indicator}`;
     }
     this.applyBottomAlignmentAndScroll();
     this.renderNowCallback();
+    this.notifyHasContentChange();
   }
   /**
    * Get the current content filter mode.
@@ -6036,9 +6065,129 @@ var TUIController = class {
   }
 };
 
+// src/tui/hints-bar.ts
+var GRAY = "\x1B[90m";
+var RESET = "\x1B[0m";
+var HintsBar = class {
+  hintsBox;
+  renderCallback;
+  focusMode = "browse";
+  contentFilterMode = "full";
+  hasContent = false;
+  constructor(hintsBox, renderCallback) {
+    this.hintsBox = hintsBox;
+    this.renderCallback = renderCallback;
+    this.render();
+  }
+  /**
+   * Update focus mode and re-render hints.
+   */
+  setFocusMode(mode) {
+    if (this.focusMode !== mode) {
+      this.focusMode = mode;
+      this.render();
+    }
+  }
+  /**
+   * Update content filter mode and re-render hints.
+   */
+  setContentFilterMode(mode) {
+    if (this.contentFilterMode !== mode) {
+      this.contentFilterMode = mode;
+      this.render();
+    }
+  }
+  /**
+   * Update whether there's content to browse.
+   * Affects whether ^B browse hint is shown in input mode.
+   */
+  setHasContent(has) {
+    if (this.hasContent !== has) {
+      this.hasContent = has;
+      this.render();
+    }
+  }
+  /**
+   * Get current focus mode.
+   */
+  getFocusMode() {
+    return this.focusMode;
+  }
+  /**
+   * Get current content filter mode.
+   */
+  getContentFilterMode() {
+    return this.contentFilterMode;
+  }
+  /**
+   * Render hints based on current state.
+   */
+  render() {
+    const hints = [];
+    if (this.contentFilterMode === "focused") {
+      hints.push("^K exit focused mode");
+    } else if (this.focusMode === "input") {
+      hints.push("^S multiline");
+      if (this.hasContent) {
+        hints.push("^B browse");
+      }
+      hints.push("^K focused");
+    } else {
+      hints.push("j/k nav");
+      hints.push("Enter expand");
+      hints.push("^B input");
+      hints.push("^K focused");
+    }
+    this.hintsBox.setContent(`${GRAY}${hints.join("  ")}${RESET}`);
+    this.renderCallback();
+  }
+};
+
+// src/tui/editor.ts
+import { spawnSync as spawnSync2 } from "child_process";
+import { readFileSync as readFileSync4, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
+import { tmpdir } from "os";
+import { join as join3 } from "path";
+function openEditorSync(initialContent = "") {
+  const editor = process.env.VISUAL || process.env.EDITOR || "vi";
+  const tmpFile = join3(tmpdir(), `llmist-input-${Date.now()}.txt`);
+  writeFileSync2(tmpFile, initialContent, "utf-8");
+  try {
+    const parts = editor.split(/\s+/);
+    const cmd = parts[0];
+    const args = [...parts.slice(1), tmpFile];
+    const result = spawnSync2(cmd, args, {
+      stdio: "inherit",
+      // Connect to user's terminal
+      shell: false
+    });
+    if (result.error) {
+      try {
+        unlinkSync(tmpFile);
+      } catch {
+      }
+      return null;
+    }
+    if (result.status === 0) {
+      const content = readFileSync4(tmpFile, "utf-8");
+      unlinkSync(tmpFile);
+      const trimmed = content.trim();
+      return trimmed || null;
+    } else {
+      unlinkSync(tmpFile);
+      return null;
+    }
+  } catch {
+    try {
+      unlinkSync(tmpFile);
+    } catch {
+    }
+    return null;
+  }
+}
+
 // src/tui/input-handler.ts
-var IDLE_PROMPT = "> ";
-var ACTIVE_PROMPT = ">>> ";
+var PROMPT = "> ";
 var InputHandler = class {
   inputBar;
   promptLabel;
@@ -6050,6 +6199,14 @@ var InputHandler = class {
   pendingInput = null;
   /** Whether we're waiting for REPL prompt (vs AskUser which should auto-focus) */
   isPendingREPLPrompt = false;
+  /** Whether input mode is currently active (focused, capturing keystrokes) */
+  isActive = false;
+  /** Whether a bracketed paste is in progress */
+  isPasting = false;
+  /** Buffer for accumulating bracketed paste content */
+  pasteBuffer = "";
+  /** Flag to indicate content came from editor (skip paste detection on submit) */
+  fromEditor = false;
   /** Callback when Ctrl+C is pressed */
   ctrlCCallback = null;
   /** Callback when Ctrl+B is pressed (toggle focus mode) */
@@ -6066,16 +6223,23 @@ var InputHandler = class {
   midSessionHandler = null;
   /** Callback to check current focus mode (to avoid conflicts with browse mode) */
   getFocusModeCallback = null;
-  constructor(inputBar, promptLabel, body, screen, renderCallback, renderNowCallback) {
+  /** Body height when input bar is visible */
+  bodyHeightWithInput;
+  /** Body height when input bar is hidden (browse mode) */
+  bodyHeightWithoutInput;
+  constructor(inputBar, promptLabel, body, screen, renderCallback, renderNowCallback, hasHints = true) {
     this.inputBar = inputBar;
     this.promptLabel = promptLabel;
     this.body = body;
     this.screen = screen;
     this.renderCallback = renderCallback;
     this.renderNowCallback = renderNowCallback ?? renderCallback;
+    this.bodyHeightWithInput = hasHints ? "100%-3" : "100%-2";
+    this.bodyHeightWithoutInput = hasHints ? "100%-2" : "100%-1";
     this.inputBar.on("submit", (value) => {
       this.handleSubmit(value);
     });
+    this.setupBracketedPasteHandler();
     this.inputBar.on("cancel", () => {
       this.handleCancel();
     });
@@ -6109,6 +6273,10 @@ var InputHandler = class {
         this.ctrlPCallback();
       }
     });
+    this.inputBar.key(["C-s"], () => {
+      const currentValue = this.inputBar.getValue();
+      this.openEditorForInput(currentValue);
+    });
     this.screen.key(["enter"], () => {
       if (this.isPendingREPLPrompt) {
         if (this.getFocusModeCallback?.() === "browse") {
@@ -6246,37 +6414,54 @@ var InputHandler = class {
   // Focus Mode API (controlled by TUIApp)
   // ─────────────────────────────────────────────────────────────────────────────
   /**
-   * Activate input mode - show input bar and capture keyboard.
+   * Activate input mode - focus input bar and capture keyboard.
    * Called by TUIApp when switching to input mode.
-   * Preserves current prompt indicator and input text.
+   * Shows input bar with active prompt (">>>") and starts capturing keystrokes.
    */
   activate() {
     this.isPendingREPLPrompt = false;
+    this.isActive = true;
     this.promptLabel.show();
     this.inputBar.show();
+    this.body.height = this.bodyHeightWithInput;
+    this.setPrompt(PROMPT);
     this.renderNowCallback();
     this.inputBar.readInput();
   }
+  /** Flag to prevent handleCancel from re-entering during deactivation */
+  isDeactivating = false;
   /**
    * Deactivate input mode - hide input bar completely.
    * Called by TUIApp when switching to browse mode.
+   * Input bar is hidden to give more space to content.
    */
   deactivate() {
+    this.isPendingREPLPrompt = false;
+    this.isActive = false;
+    this.isDeactivating = true;
+    this.inputBar.cancel();
+    this.isDeactivating = false;
     this.promptLabel.hide();
     this.inputBar.hide();
-    this.isPendingREPLPrompt = false;
+    this.body.height = this.bodyHeightWithoutInput;
     this.renderNowCallback();
   }
   /**
-   * Check if input mode is active (input bar visible and focused).
+   * Check if input mode is active (focused, capturing keystrokes).
    */
   isInputActive() {
-    return this.inputBar.visible !== false;
+    return this.isActive;
   }
   /**
    * Handle input submission.
    */
   handleSubmit(rawValue) {
+    if (this.isPasting) {
+      return;
+    }
+    if (this.fromEditor) {
+      this.fromEditor = false;
+    }
     const value = rawValue.trim();
     if (!value) {
       this.inputBar.readInput();
@@ -6298,18 +6483,93 @@ var InputHandler = class {
    * Handle input cancellation (ESC key).
    */
   handleCancel() {
+    if (this.isDeactivating) {
+      return;
+    }
     if (this.pendingInput) {
       this.inputBar.readInput();
     } else {
       this.setIdle();
     }
   }
+  /**
+   * Set up bracketed paste mode detection.
+   *
+   * Terminal emulators that support bracketed paste send:
+   * - \x1b[200~ before pasted content
+   * - \x1b[201~ after pasted content
+   *
+   * This allows reliable detection of paste vs typed input.
+   */
+  setupBracketedPasteHandler() {
+    const PASTE_START = "\x1B[200~";
+    const PASTE_END = "\x1B[201~";
+    this.screen.program.input.on("data", (data) => {
+      const str = data.toString();
+      if (str.includes(PASTE_START)) {
+        this.isPasting = true;
+        this.pasteBuffer = "";
+        const startIdx = str.indexOf(PASTE_START) + PASTE_START.length;
+        const afterStart = str.slice(startIdx);
+        if (afterStart.includes(PASTE_END)) {
+          const endIdx = afterStart.indexOf(PASTE_END);
+          this.pasteBuffer = afterStart.slice(0, endIdx);
+          this.isPasting = false;
+          this.handlePaste(this.pasteBuffer);
+          this.pasteBuffer = "";
+        } else {
+          this.pasteBuffer = afterStart;
+        }
+        return;
+      }
+      if (this.isPasting && str.includes(PASTE_END)) {
+        const endIdx = str.indexOf(PASTE_END);
+        this.pasteBuffer += str.slice(0, endIdx);
+        this.isPasting = false;
+        this.handlePaste(this.pasteBuffer);
+        this.pasteBuffer = "";
+        return;
+      }
+      if (this.isPasting) {
+        this.pasteBuffer += str;
+      }
+    });
+  }
+  /**
+   * Handle completed paste content.
+   *
+   * If content contains newlines, opens $EDITOR for multiline editing.
+   * Otherwise, inserts directly into the input bar.
+   */
+  handlePaste(content) {
+    if (!content) return;
+    if (content.includes("\n")) {
+      const currentValue = this.inputBar.getValue();
+      this.openEditorForInput(currentValue + content);
+    } else {
+      const currentValue = this.inputBar.getValue();
+      this.inputBar.setValue(currentValue + content);
+      this.inputBar.readInput();
+    }
+  }
+  /**
+   * Set prompt text and dynamically adjust layout.
+   * Idle prompt "> " uses 2 chars, active prompt ">>> " uses 4 chars.
+   */
+  setPrompt(prompt) {
+    const width = prompt.length;
+    this.promptLabel.width = width;
+    this.promptLabel.setContent(prompt);
+    this.inputBar.left = width;
+    this.inputBar.width = `100%-${width}`;
+  }
   /**
    * Set input to idle state.
    */
   setIdle() {
     this.isPendingREPLPrompt = false;
-    this.promptLabel.setContent(IDLE_PROMPT);
+    this.isActive = false;
+    this.setPrompt(PROMPT);
     this.inputBar.setValue("");
     this.renderCallback();
   }
@@ -6327,7 +6587,7 @@ var InputHandler = class {
    */
   setPendingPrompt() {
     this.isPendingREPLPrompt = true;
-    this.promptLabel.setContent(IDLE_PROMPT);
+    this.setPrompt(PROMPT);
     this.inputBar.setValue("");
     this.renderCallback();
   }
@@ -6336,11 +6596,42 @@ var InputHandler = class {
    */
   setActive() {
     this.isPendingREPLPrompt = false;
-    this.promptLabel.setContent(ACTIVE_PROMPT);
+    this.isActive = true;
+    this.promptLabel.show();
+    this.inputBar.show();
+    this.body.height = this.bodyHeightWithInput;
+    this.setPrompt(PROMPT);
     this.inputBar.setValue("");
     this.renderNowCallback();
     this.inputBar.readInput();
   }
+  /**
+   * Open $EDITOR for multiline input.
+   * Called when user presses Ctrl+S or pastes multiline content.
+   */
+  openEditorForInput(initialContent) {
+    this.screen.program.clear();
+    this.screen.program.disableMouse();
+    this.screen.program.showCursor();
+    this.screen.program.normalBuffer();
+    const result = openEditorSync(initialContent);
+    this.screen.program.alternateBuffer();
+    this.screen.program.hideCursor();
+    this.screen.program.enableMouse();
+    this.screen.alloc();
+    this.screen.render();
+    this.isPasting = false;
+    this.pasteBuffer = "";
+    setImmediate(() => {
+      if (result) {
+        this.fromEditor = true;
+        this.handleSubmit(result);
+      } else {
+        this.inputBar.setValue(initialContent);
+        this.inputBar.readInput();
+      }
+    });
+  }
 };
 
 // src/tui/keymap.ts
@@ -6446,13 +6737,16 @@ var KeyboardManager = class {
 
 // src/tui/layout.ts
 import { Box as Box2, ScrollableBox, Text, Textbox } from "@unblessed/node";
-function createBlockLayout(screen) {
+function createBlockLayout(screen, showHints = true) {
+  const inputBottom = showHints ? 2 : 1;
+  const statusBottom = showHints ? 1 : 0;
+  const bodyHeight = showHints ? "100%-3" : "100%-2";
   const body = new ScrollableBox({
     parent: screen,
     top: 0,
     left: 0,
     width: "100%",
-    height: "100%-2",
+    height: bodyHeight,
     // Scrolling configuration
     scrollable: true,
     alwaysScroll: true,
@@ -6475,10 +6769,10 @@ function createBlockLayout(screen) {
   });
   const promptLabel = new Text({
     parent: screen,
-    bottom: 1,
+    bottom: inputBottom,
     left: 0,
-    width: 4,
-    // ">>> " = 4 chars (max prompt width)
+    width: 2,
+    // "> " = 2 chars
     height: 1,
     content: "> ",
     style: {
@@ -6488,10 +6782,10 @@ function createBlockLayout(screen) {
   });
   const inputBar = new Textbox({
     parent: screen,
-    bottom: 1,
-    left: 4,
-    // Position after prompt label
-    width: "100%-4",
+    bottom: inputBottom,
+    left: 2,
+    // Position after prompt label ("> " = 2 chars)
+    width: "100%-2",
     height: 1,
     keys: true,
     mouse: true,
@@ -6502,7 +6796,7 @@ function createBlockLayout(screen) {
   });
   const statusBar = new Box2({
     parent: screen,
-    bottom: 0,
+    bottom: statusBottom,
     left: 0,
     width: "100%",
     height: 1,
@@ -6512,7 +6806,19 @@ function createBlockLayout(screen) {
       bg: "black"
     }
   });
-  return { body, promptLabel, inputBar, statusBar };
+  const hintsBar = showHints ? new Box2({
+    parent: screen,
+    bottom: 0,
+    left: 0,
+    width: "100%",
+    height: 1,
+    tags: false,
+    style: {
+      fg: "white",
+      bg: "black"
+    }
+  }) : null;
+  return { body, promptLabel, inputBar, statusBar, hintsBar };
 }
 
 // src/tui/approval-dialog.ts
@@ -6633,7 +6939,7 @@ function escapeContent(str) {
 
 // src/tui/raw-viewer.ts
 import { Box as Box4 } from "@unblessed/node";
-var RESET = "\x1B[0m";
+var RESET2 = "\x1B[0m";
 var BOLD = "\x1B[1m";
 var DIM = "\x1B[2m";
 var RED = "\x1B[31m";
@@ -6665,17 +6971,17 @@ function showRawViewer(options) {
       if (mode === "request") {
         title = ` Raw Parameters - ${gadgetName} `;
         if (!parameters || Object.keys(parameters).length === 0) {
-          content = `${DIM}No parameters${RESET}`;
+          content = `${DIM}No parameters${RESET2}`;
         } else {
           content = formatGadgetParameters(parameters);
         }
       } else {
         title = ` Raw Result - ${gadgetName} `;
         if (error) {
-          content = `${RED}${BOLD}Error:${RESET}
+          content = `${RED}${BOLD}Error:${RESET2}
 ${error}`;
         } else if (!result) {
-          content = `${DIM}No result data available${RESET}`;
+          content = `${DIM}No result data available${RESET2}`;
         } else {
           content = formatGadgetResult(result);
         }
@@ -6684,14 +6990,14 @@ ${error}`;
       if (mode === "request") {
         title = ` Raw Request - #${iteration} ${model} `;
         if (!request || request.length === 0) {
-          content = `${DIM}No request data available${RESET}`;
+          content = `${DIM}No request data available${RESET2}`;
         } else {
           content = formatMessages(request);
         }
       } else {
         title = ` Raw Response - #${iteration} ${model} `;
         if (!response) {
-          content = `${DIM}No response data available${RESET}`;
+          content = `${DIM}No response data available${RESET2}`;
         } else {
           content = response;
         }
@@ -6732,7 +7038,7 @@ ${error}`;
       left: 0,
       width: "100%",
       height: 1,
-      content: `${DIM} [${WHITE}\u2191/\u2193/PgUp/PgDn${DIM}] Scroll  [${WHITE}Home/End${DIM}] Jump  [${WHITE}Escape/q${DIM}] Close${RESET}`,
+      content: `${DIM} [${WHITE}\u2191/\u2193/PgUp/PgDn${DIM}] Scroll  [${WHITE}Home/End${DIM}] Jump  [${WHITE}Escape/q${DIM}] Close${RESET2}`,
       tags: false,
       style: { fg: "white", bg: "black" }
     });
@@ -6764,11 +7070,11 @@ function formatMessages(messages) {
     const msg = messages[i];
     const roleColor = getRoleColor(msg.role);
     const roleName = msg.role.toUpperCase();
-    lines.push(`${DIM}${separator}${RESET}`);
+    lines.push(`${DIM}${separator}${RESET2}`);
     lines.push(
-      `${roleColor}${BOLD}[${roleName}]${RESET} ${DIM}Message ${i + 1} of ${messages.length}${RESET}`
+      `${roleColor}${BOLD}[${roleName}]${RESET2} ${DIM}Message ${i + 1} of ${messages.length}${RESET2}`
     );
-    lines.push(`${DIM}${separator}${RESET}`);
+    lines.push(`${DIM}${separator}${RESET2}`);
     lines.push("");
     const contentLines = formatMessageContent(msg.content);
     lines.push(...contentLines);
@@ -6791,19 +7097,19 @@ function formatMessageContent(content) {
       lines.push(...part.text.split("\n"));
     } else if (isImagePart(part)) {
       const mediaType = part.source?.media_type || "unknown";
-      lines.push(`${DIM}[Image: ${mediaType}]${RESET}`);
+      lines.push(`${DIM}[Image: ${mediaType}]${RESET2}`);
     } else if (isAudioPart(part)) {
       const mediaType = part.source?.media_type || "unknown";
-      lines.push(`${DIM}[Audio: ${mediaType}]${RESET}`);
+      lines.push(`${DIM}[Audio: ${mediaType}]${RESET2}`);
     } else if (isToolUsePart(part)) {
-      lines.push(`${YELLOW}${BOLD}[Tool Use: ${part.name}]${RESET}`);
-      lines.push(`${DIM}ID: ${part.id}${RESET}`);
-      lines.push(`${DIM}Input:${RESET}`);
+      lines.push(`${YELLOW}${BOLD}[Tool Use: ${part.name}]${RESET2}`);
+      lines.push(`${DIM}ID: ${part.id}${RESET2}`);
+      lines.push(`${DIM}Input:${RESET2}`);
       const inputStr = JSON.stringify(part.input, null, 2);
       lines.push(...inputStr.split("\n").map((l) => `  ${l}`));
     } else if (isToolResultPart(part)) {
-      lines.push(`${CYAN}${BOLD}[Tool Result]${RESET}`);
-      lines.push(`${DIM}Tool Use ID: ${part.tool_use_id}${RESET}`);
+      lines.push(`${CYAN}${BOLD}[Tool Result]${RESET2}`);
+      lines.push(`${DIM}Tool Use ID: ${part.tool_use_id}${RESET2}`);
       if (typeof part.content === "string") {
         lines.push(...part.content.split("\n"));
       } else {
@@ -6811,7 +7117,7 @@ function formatMessageContent(content) {
       }
     } else {
       const partType = part.type || "unknown";
-      lines.push(`${DIM}[${partType}]${RESET}`);
+      lines.push(`${DIM}[${partType}]${RESET2}`);
       lines.push(JSON.stringify(part, null, 2));
     }
   }
@@ -6847,9 +7153,9 @@ function isToolResultPart(part) {
 function formatGadgetParameters(params) {
   const lines = [];
   const separator = "\u2500".repeat(78);
-  lines.push(`${DIM}${separator}${RESET}`);
-  lines.push(`${CYAN}${BOLD}Parameters${RESET}`);
-  lines.push(`${DIM}${separator}${RESET}`);
+  lines.push(`${DIM}${separator}${RESET2}`);
+  lines.push(`${CYAN}${BOLD}Parameters${RESET2}`);
+  lines.push(`${DIM}${separator}${RESET2}`);
   lines.push("");
   const json = JSON.stringify(params, null, 2);
   const highlighted = highlightJson(json);
@@ -6859,9 +7165,9 @@ function formatGadgetParameters(params) {
 function formatGadgetResult(result) {
   const lines = [];
   const separator = "\u2500".repeat(78);
-  lines.push(`${DIM}${separator}${RESET}`);
-  lines.push(`${GREEN}${BOLD}Result${RESET}`);
-  lines.push(`${DIM}${separator}${RESET}`);
+  lines.push(`${DIM}${separator}${RESET2}`);
+  lines.push(`${GREEN}${BOLD}Result${RESET2}`);
+  lines.push(`${DIM}${separator}${RESET2}`);
   lines.push("");
   const trimmed = result.trim();
   if (trimmed.startsWith("{") && trimmed.endsWith("}") || trimmed.startsWith("[") && trimmed.endsWith("]")) {
@@ -6877,10 +7183,10 @@ function formatGadgetResult(result) {
   return lines.join("\n");
 }
 function highlightJson(json) {
-  let result = json.replace(/"([^"]+)":/g, `${CYAN}"$1"${RESET}:`);
-  result = result.replace(/: "([^"]*)"/g, `: ${GREEN}"$1"${RESET}`);
-  result = result.replace(/: (-?\d+\.?\d*)/g, `: ${YELLOW}$1${RESET}`);
-  result = result.replace(/: (true|false|null)/g, `: ${MAGENTA}$1${RESET}`);
+  let result = json.replace(/"([^"]+)":/g, `${CYAN}"$1"${RESET2}:`);
+  result = result.replace(/: "([^"]*)"/g, `: ${GREEN}"$1"${RESET2}`);
+  result = result.replace(/: (-?\d+\.?\d*)/g, `: ${YELLOW}$1${RESET2}`);
+  result = result.replace(/: (true|false|null)/g, `: ${MAGENTA}$1${RESET2}`);
   return result;
 }
 
@@ -6959,6 +7265,7 @@ function createScreen(options) {
     // Use alternate screen buffer (restores on exit)
     useBCE: true
   });
+  screen.program.write("\x1B[?2004h");
   let isDestroyed = false;
   let renderPending = false;
   let renderTimeout = null;
@@ -6989,6 +7296,7 @@ function createScreen(options) {
       clearTimeout(renderTimeout);
       renderTimeout = null;
     }
+    screen.program.write("\x1B[?2004l");
     screen.destroy();
     process.stdout.write("\x1B[?25h");
   };
@@ -7030,7 +7338,7 @@ var StatusBar = class {
   streamingOutputTokens = 0;
   /** Whether we're currently streaming */
   isStreaming = false;
-  /** Active LLM calls: Map from label ("#1") to model name */
+  /** Active LLM calls: Map from label ("#1") to model name and start time */
   activeLLMCalls = /* @__PURE__ */ new Map();
   /** Active gadgets (by name) */
   activeGadgets = /* @__PURE__ */ new Set();
@@ -7127,7 +7435,7 @@ var StatusBar = class {
    * @param model - Full model name like "gemini:gemini-2.5-flash"
    */
   startLLMCall(label, model) {
-    this.activeLLMCalls.set(label, model);
+    this.activeLLMCalls.set(label, { model, startTime: Date.now() });
     this.startSpinner();
     this.render();
   }
@@ -7140,6 +7448,19 @@ var StatusBar = class {
     this.maybeStopSpinner();
     this.render();
   }
+  /**
+   * Get the start time of the earliest running LLM call.
+   * Used to show elapsed time since the first call started (for concurrent subagents).
+   * @returns Start time in ms, or null if no LLM calls are active
+   */
+  getEarliestLLMCallStartTime() {
+    if (this.activeLLMCalls.size === 0) return null;
+    let earliest = Infinity;
+    for (const { startTime } of this.activeLLMCalls.values()) {
+      if (startTime < earliest) earliest = startTime;
+    }
+    return earliest;
+  }
   /**
    * Track a gadget as active.
    * @param name - Gadget name like "ReadFile" or "BrowseWeb"
@@ -7271,6 +7592,15 @@ var StatusBar = class {
         this.startLLMCall(label, event.model);
         break;
       }
+      case "llm_response_end": {
+        const label = this.nodeIdToLabel.get(event.nodeId);
+        if (label) {
+          this.activeLLMCalls.delete(label);
+          this.maybeStopSpinner();
+          this.render();
+        }
+        break;
+      }
       case "llm_call_complete": {
         const label = this.nodeIdToLabel.get(event.nodeId);
         if (label) {
@@ -7414,68 +7744,72 @@ var StatusBar = class {
    * @param immediate - If true, render immediately without debouncing
    */
   render(immediate = false) {
-    const elapsed = this.getElapsedSeconds().toFixed(1);
     const YELLOW2 = "\x1B[33m";
     const GREEN2 = "\x1B[32m";
     const BLUE = "\x1B[34m";
     const CYAN2 = "\x1B[36m";
     const MAGENTA2 = "\x1B[35m";
-    const GRAY = "\x1B[90m";
-    const RESET2 = "\x1B[0m";
+    const GRAY2 = "\x1B[90m";
+    const RESET3 = "\x1B[0m";
     const BG_BLUE = "\x1B[44m";
-    const BG_GREEN = "\x1B[42m";
     const WHITE2 = "\x1B[37m";
-    const BLACK = "\x1B[30m";
     const displayInputTokens = this.metrics.inputTokens + this.streamingInputTokens;
     const displayOutputTokens = this.metrics.outputTokens + this.streamingOutputTokens;
     const parts = [];
-    if (this.contentFilterMode === "focused") {
-      parts.push(`${BG_BLUE}${WHITE2} FOCUSED ${RESET2}`);
-    } else if (this.focusMode === "browse") {
-      parts.push(`${BG_BLUE}${WHITE2} BROWSE ${RESET2}`);
-    } else {
-      parts.push(`${BG_GREEN}${BLACK} INPUT ${RESET2}`);
+    if (this.focusMode === "browse" && this.contentFilterMode !== "focused") {
+      parts.push(`${BG_BLUE}${WHITE2} BROWSE ${RESET3}`);
     }
     if (this.profiles.length > 0) {
       const profile = this.profiles[this.currentProfileIndex];
       const display = profile.length > 12 ? `${profile.slice(0, 11)}\u2026` : profile;
-      parts.push(`${YELLOW2}${display}${RESET2}`);
+      parts.push(`${YELLOW2}${display}${RESET3}`);
+    }
+    if (displayInputTokens > 0) {
+      const inputPrefix = this.isStreaming && this.streamingInputTokens > 0 ? "~" : "";
+      parts.push(`${YELLOW2}\u2191${inputPrefix}${formatTokens(displayInputTokens)}${RESET3}`);
     }
-    const inputPrefix = this.isStreaming && this.streamingInputTokens > 0 ? "~" : "";
-    parts.push(`${YELLOW2}\u2191 ${inputPrefix}${formatTokens(displayInputTokens)}${RESET2}`);
     if (this.metrics.cachedTokens > 0) {
-      parts.push(`${BLUE}\u293F ${formatTokens(this.metrics.cachedTokens)}${RESET2}`);
+      parts.push(`${BLUE}\u293F${formatTokens(this.metrics.cachedTokens)}${RESET3}`);
+    }
+    if (displayOutputTokens > 0) {
+      const outputPrefix = this.isStreaming ? "~" : "";
+      parts.push(`${GREEN2}\u2193${outputPrefix}${formatTokens(displayOutputTokens)}${RESET3}`);
+    }
+    const earliestStart = this.getEarliestLLMCallStartTime();
+    if (earliestStart !== null) {
+      const elapsedSeconds = (Date.now() - earliestStart) / 1e3;
+      const timeStr = elapsedSeconds % 1 === 0 ? `${elapsedSeconds}s` : `${elapsedSeconds.toFixed(1)}s`;
+      parts.push(`${GRAY2}${timeStr}${RESET3}`);
+    }
+    if (this.metrics.cost > 0) {
+      parts.push(`${CYAN2}$${formatCost(this.metrics.cost)}${RESET3}`);
     }
-    const outputPrefix = this.isStreaming ? "~" : "";
-    parts.push(`${GREEN2}\u2193 ${outputPrefix}${formatTokens(displayOutputTokens)}${RESET2}`);
-    parts.push(`${GRAY}${elapsed}s${RESET2}`);
-    parts.push(`${CYAN2}$${formatCost(this.metrics.cost)}${RESET2}`);
     if (this.selectionDebugCallback) {
       const debug = this.selectionDebugCallback();
       const debugStr = `sel:${debug.index}/${debug.total}`;
       const typeStr = debug.nodeType ? ` [${debug.nodeType}]` : "";
-      parts.push(`${GRAY}${debugStr}${typeStr}${RESET2}`);
+      parts.push(`${GRAY2}${debugStr}${typeStr}${RESET3}`);
     }
     if (this.rateLimitState?.isThrottling) {
       const { triggeredBy } = this.rateLimitState;
       if (triggeredBy?.daily) {
-        parts.push(`${YELLOW2}\u23F8 Daily limit, resets midnight UTC${RESET2}`);
+        parts.push(`${YELLOW2}\u23F8 Daily limit, resets midnight UTC${RESET3}`);
       } else {
         const seconds = Math.ceil(this.rateLimitState.delayMs / 1e3);
         const reason = triggeredBy?.rpm ? " (RPM)" : triggeredBy?.tpm ? " (TPM)" : "";
-        parts.push(`${YELLOW2}\u23F8 Throttled ${seconds}s${reason}${RESET2}`);
+        parts.push(`${YELLOW2}\u23F8 Throttled ${seconds}s${reason}${RESET3}`);
       }
     }
     if (this.retryState) {
       const { attemptNumber, retriesLeft } = this.retryState;
       const totalAttempts = attemptNumber + retriesLeft;
-      parts.push(`${BLUE}\u{1F504} Retry ${attemptNumber}/${totalAttempts}${RESET2}`);
+      parts.push(`${BLUE}\u{1F504} Retry ${attemptNumber}/${totalAttempts}${RESET3}`);
     }
     if (this.activeLLMCalls.size > 0 || this.activeGadgets.size > 0) {
       const spinner = SPINNER_FRAMES2[this.spinnerFrame];
       if (this.activeLLMCalls.size > 0) {
         const byModel = /* @__PURE__ */ new Map();
-        for (const [label, model] of this.activeLLMCalls) {
+        for (const [label, { model }] of this.activeLLMCalls) {
           const shortModel = this.shortenModelName(model);
           if (!byModel.has(shortModel)) byModel.set(shortModel, []);
           byModel.get(shortModel)?.push(label);
@@ -7484,15 +7818,15 @@ var StatusBar = class {
         for (const [model, labels] of byModel) {
           llmParts.push(`${model} ${labels.join(", ")}`);
         }
-        parts.push(`${spinner} ${MAGENTA2}${llmParts.join(" | ")}${RESET2}`);
+        parts.push(`${spinner} ${MAGENTA2}${llmParts.join(" | ")}${RESET3}`);
       }
       if (this.activeGadgets.size > 0) {
         const gadgetList = [...this.activeGadgets].slice(0, 3).join(", ");
         const more = this.activeGadgets.size > 3 ? ` +${this.activeGadgets.size - 3}` : "";
-        parts.push(`${CYAN2}\u23F5 ${gadgetList}${more}${RESET2}`);
+        parts.push(`${CYAN2}\u23F5 ${gadgetList}${more}${RESET3}`);
       }
     }
-    this.statusBox.setContent(parts.join(` ${GRAY}|${RESET2} `));
+    this.statusBox.setContent(parts.join(" "));
     if (immediate) {
       this.renderNowCallback();
     } else {
@@ -7538,7 +7872,12 @@ var TUIApp = class _TUIApp {
       title: "llmist"
     });
     const { screen } = screenCtx;
-    const layout = createBlockLayout(screen);
+    const showHints = options.showHints ?? true;
+    const layout = createBlockLayout(screen, showHints);
+    let hintsBar = null;
+    if (layout.hintsBar) {
+      hintsBar = new HintsBar(layout.hintsBar, () => screenCtx.requestRender());
+    }
     const statusBar = new StatusBar(
       layout.statusBar,
       options.model,
@@ -7551,19 +7890,27 @@ var TUIApp = class _TUIApp {
       layout.body,
       screen,
       () => screenCtx.requestRender(),
-      () => screenCtx.renderNow()
+      () => screenCtx.renderNow(),
+      showHints
     );
     const blockRenderer = new BlockRenderer(
       layout.body,
       () => screenCtx.requestRender(),
       () => screenCtx.renderNow()
     );
+    if (hintsBar) {
+      blockRenderer.onHasContentChange((hasContent) => {
+        hintsBar.setHasContent(hasContent);
+      });
+    }
     const controller = new TUIController({
       onFocusModeChange: (mode) => {
         applyFocusMode(mode, layout, statusBar, inputHandler, screenCtx);
+        hintsBar?.setFocusMode(mode);
       },
       onContentFilterModeChange: (mode) => {
         applyContentFilterMode(mode, blockRenderer, statusBar, screenCtx);
+        hintsBar?.setContentFilterMode(mode);
       }
     });
     const modalManager = new ModalManager();
@@ -7717,13 +8064,11 @@ var TUIApp = class _TUIApp {
   }
   /**
    * Wait for user to enter a new prompt (REPL mode).
-   * Stays in current mode (browse) - user can Tab to input or Enter to start typing.
-   * After the prompt is submitted, focus mode switches to BROWSE.
+   * Stays in input mode after submission - user can watch output and type next message.
+   * User can Ctrl+B to browse if they want to navigate blocks.
    */
   async waitForPrompt() {
-    const result = await this.inputHandler.waitForPrompt();
-    this.controller.setFocusMode("browse");
-    return result;
+    return this.inputHandler.waitForPrompt();
   }
   /**
    * Enter the pending REPL prompt state without blocking.
@@ -7942,17 +8287,13 @@ var TUIApp = class _TUIApp {
 };
 function applyFocusMode(mode, layout, statusBar, inputHandler, screenCtx) {
   statusBar.setFocusMode(mode);
-  if (mode === "input") {
-    layout.body.height = "100%-2";
-  } else {
-    layout.body.height = "100%-1";
-  }
-  screenCtx.renderNow();
   if (mode === "input") {
     inputHandler.activate();
   } else {
     inputHandler.deactivate();
+    layout.body.focus();
   }
+  screenCtx.renderNow();
 }
 function applyContentFilterMode(mode, blockRenderer, statusBar, screenCtx) {
   blockRenderer.setContentFilterMode(mode);
@@ -8082,7 +8423,8 @@ async function executeAgent(promptArg, options, env, commandName) {
     tui = await TUIApp.create({
       model: options.model,
       stdin: env.stdin,
-      stdout: env.stdout
+      stdout: env.stdout,
+      showHints: options.showHints
     });
     try {
       const fullConfig = loadConfig();
@@ -8471,7 +8813,8 @@ function registerAgentCommand(program, env, config, globalSubagents, globalRateL
         globalRateLimits,
         globalRetry,
         profileRateLimits: config?.["rate-limits"],
-        profileRetry: config?.retry
+        profileRetry: config?.retry,
+        showHints: config?.["show-hints"]
       };
       return executeAgent(prompt, mergedOptions, env, "agent");
     }, env)
@@ -8696,7 +9039,7 @@ System Prompt (${chars.toLocaleString()} chars, ${lines} lines):
 }
 
 // src/environment.ts
-import { join as join3 } from "path";
+import { join as join4 } from "path";
 import readline from "readline";
 import chalk4 from "chalk";
 import { createLogger, LLMist } from "llmist";
@@ -8719,7 +9062,7 @@ function createLoggerFactory(config, sessionLogDir) {
       }
     }
     if (sessionLogDir) {
-      const logFile = join3(sessionLogDir, "session.log.jsonl");
+      const logFile = join4(sessionLogDir, "session.log.jsonl");
       const originalLogFile = process.env.LLMIST_LOG_FILE;
       process.env.LLMIST_LOG_FILE = logFile;
       const logger = createLogger(options);
@@ -9265,7 +9608,7 @@ function registerGadgetCommand(program, env) {
 }
 
 // src/image-command.ts
-import { writeFileSync as writeFileSync2 } from "fs";
+import { writeFileSync as writeFileSync3 } from "fs";
 var DEFAULT_IMAGE_MODEL = "dall-e-3";
 async function executeImage(promptArg, options, env) {
   const prompt = await resolvePrompt(promptArg, env);
@@ -9289,7 +9632,7 @@ async function executeImage(promptArg, options, env) {
     const imageData = result.images[0];
     if (imageData.b64Json) {
       const buffer = Buffer.from(imageData.b64Json, "base64");
-      writeFileSync2(options.output, buffer);
+      writeFileSync3(options.output, buffer);
       if (!options.quiet) {
         env.stderr.write(`${SUMMARY_PREFIX} Image saved to ${options.output}
 `);
@@ -9328,7 +9671,7 @@ function registerImageCommand(program, env, config) {
 }
 
 // src/init-command.ts
-import { existsSync as existsSync3, mkdirSync, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync3, mkdirSync, writeFileSync as writeFileSync4 } from "fs";
 import { dirname as dirname2 } from "path";
 var STARTER_CONFIG = `# ~/.llmist/cli.toml
 # llmist CLI configuration file
@@ -9399,7 +9742,7 @@ async function executeInit(_options, env) {
   if (!existsSync3(configDir)) {
     mkdirSync(configDir, { recursive: true });
   }
-  writeFileSync3(configPath, STARTER_CONFIG, "utf-8");
+  writeFileSync4(configPath, STARTER_CONFIG, "utf-8");
   env.stderr.write(`Created ${configPath}
 `);
   env.stderr.write("\n");
@@ -9831,7 +10174,7 @@ function registerModelsCommand(program, env) {
 import { existsSync as existsSync4 } from "fs";
 import { mkdir as mkdir2 } from "fs/promises";
 import { homedir as homedir3 } from "os";
-import { join as join4 } from "path";
+import { join as join5 } from "path";
 
 // src/session-names.ts
 var ADJECTIVES = [
@@ -9966,16 +10309,16 @@ function generateSessionName() {
 
 // src/session.ts
 var currentSession;
-var SESSION_LOGS_BASE = join4(homedir3(), ".llmist", "logs");
+var SESSION_LOGS_BASE = join5(homedir3(), ".llmist", "logs");
 function findUniqueName(baseName) {
-  const baseDir = join4(SESSION_LOGS_BASE, baseName);
+  const baseDir = join5(SESSION_LOGS_BASE, baseName);
   if (!existsSync4(baseDir)) {
     return baseName;
   }
   let suffix = 2;
   while (suffix < 1e3) {
     const name = `${baseName}-${suffix}`;
-    const dir = join4(SESSION_LOGS_BASE, name);
+    const dir = join5(SESSION_LOGS_BASE, name);
     if (!existsSync4(dir)) {
       return name;
     }
@@ -9989,14 +10332,14 @@ async function initSession() {
   }
   const baseName = generateSessionName();
   const name = findUniqueName(baseName);
-  const logDir = join4(SESSION_LOGS_BASE, name);
+  const logDir = join5(SESSION_LOGS_BASE, name);
   await mkdir2(logDir, { recursive: true });
   currentSession = { name, logDir };
   return currentSession;
 }
 
 // src/speech-command.ts
-import { writeFileSync as writeFileSync4 } from "fs";
+import { writeFileSync as writeFileSync5 } from "fs";
 var DEFAULT_SPEECH_MODEL = "tts-1";
 var DEFAULT_VOICE = "nova";
 async function executeSpeech(textArg, options, env) {
@@ -10019,7 +10362,7 @@ async function executeSpeech(textArg, options, env) {
   });
   const audioBuffer = Buffer.from(result.audio);
   if (options.output) {
-    writeFileSync4(options.output, audioBuffer);
+    writeFileSync5(options.output, audioBuffer);
     if (!options.quiet) {
       env.stderr.write(`${SUMMARY_PREFIX} Audio saved to ${options.output}
 `);