snow-ai 0.5.10 → 0.5.11

package/README.md

@@ -1,73 +1,53 @@
-# Snow CLI
-
-[![Version](https://img.shields.io/npm/v/snow-ai)](https://www.npmjs.com/package/snow-ai)
-[![License](https://img.shields.io/github/license/MayDay-wpf/snow-cli)](https://github.com/MayDay-wpf/snow-cli/blob/main/LICENSE)
-
 <div align="center">
+
 <img src="docs/images/logo.png" alt="Snow AI CLI Logo" width="200"/>
 
-# Snow CLI 
+# snow-ai
 
 **English** | [中文](README_zh.md)
 
+**QQ Group**: 910298558
+
 _An intelligent AI-powered CLI tool for developers_
 
-**QQ群**: 910298558
 </div>
 
+⚠️ Notice: If you want to use Snow to access domestic Claude Code or Codex relays, please [click here](#access-domestic-claude-code--codex-relay-snow-configuration) to see the corresponding configuration methods.
 
+## Thanks 💖
 
-## 🚀 Why Snow CLI?
-
-- **🎯 Multi-Model Support**: Compatible with OpenAI, Anthropic, Gemini, and any OpenAI-compatible APIs
-- **🔧 Built-in Tools**: File operations, shell commands, web fetching, and search capabilities
-- **🔌 Extensible**: MCP (Model Context Protocol) support for custom integrations
-- **💻 Terminal-First**: Designed for developers who live in the command line
-- **🛡️ Open Source**: Fully open source and community-driven
-- **📦 IDE Integration**: VSCode and JetBrains plugins for seamless workflow
-
-
-## 📋 Key Features
-
-### Code Understanding & Generation
-
-- Query and edit large codebases with AI assistance
-- Generate new applications from natural language descriptions
-- Debug issues and troubleshoot with intelligent suggestions
-- Multi-file context awareness for better code understanding
-
-### Automation & Integration
+[@NyxJae](https://github.com/NyxJae)、[@Flutter233PM](https://github.com/Flutter233PM)、[@yy1588133](https://github.com/yy1588133)、[@zfb132](https://github.com/zfb132)、[@JillVernus](https://github.com/JillVernus)、[@zhu-jl18](https://github.com/zhu-jl18)、[@kingsword09](https://github.com/kingsword09)、[@zcg](https://github.com/zcg)
 
-- Automate operational tasks with AI-powered workflows
-- Use MCP servers to connect new capabilities and tools
-- Run non-interactively in scripts for workflow automation
-- IDE integration for seamless development experience
+## Table of Contents
 
-### Advanced Capabilities
-
-- **Multiple Configuration Profiles**: Switch between different API and model configurations
-- **Conversation Checkpointing**: Save and resume complex sessions with `/resume`
-- **Custom System Prompts**: Tailor AI behavior for your specific needs
-- **File Snapshots**: Automatic rollback capability for AI-made changes
-- **Yolo Mode**: Unattended execution for trusted operations
-- **Token Caching**: Optimize token usage with intelligent caching
+- [Detailed and complete documentation](docs/usage/en/0.Catalogue.md)
+- [System Requirements](#system-requirements)
+- [Installation](#installation)
+- [Access Domestic Claude Code & Codex Relay](#access-domestic-claude-code--codex-relay-snow-configuration)
+- [API & Model Settings](#api--model-settings)
+- [Proxy & Browser Settings](#proxy--browser-settings)
+- [System Prompt Settings](#system-prompt-settings)
+- [Custom Headers Settings](#custom-headers-settings)
+- [MCP Settings](#mcp-settings)
+- [Getting Started](#getting-started)
+- [Snow System Files](#snow-system-files)
 
+---
 
-## 📦 Installation
+# System Requirements
 
-### Pre-requisites
+Prerequisites for installing Snow:
 
-- Node.js version 16 or higher
+- **Node.js >= 16.x** (Requires ES2020 features support)
 - npm >= 8.3.0
-- macOS, Linux, or Windows
 
-### Check Your Node.js Version
+Check your Node.js version
 
 ```bash
 node --version
 ```
 
-If your version is below 16.x, please upgrade:
+If your version is below 16.x, please upgrade first:
 
 ```bash
 # Using nvm (recommended)
@@ -78,230 +58,258 @@ nvm use 16
 # https://nodejs.org/
 ```
 
-### Quick Install
+# Installation
+
+## Install Snow CLI
 
-#### Install globally with npm
+You can install directly using npm:
 
 ```bash
 npm install -g snow-ai
 ```
 
-#### Build from source
+Or visit: [Official Repository](https://github.com/MayDay-wpf/snow-cli) to build from source, quick clone command:
 
 ```bash
-git clone https://github.com/MayDay-wpf/snow-cli
+git clone https://github.com/MayDay-wpf/snow-cli.git
 cd snow-cli
 npm install
-npm run link   # builds and globally links `snow`
+npm run link   # builds and globally links snow
 # to remove the link later: npm run unlink
 ```
 
-### IDE Extensions
-
-#### VSCode Extension
+## Install VSCode Extension
 
 - Download [snow-cli-x.x.x.vsix](https://github.com/MayDay-wpf/snow-cli/releases/tag/vsix)
 - Open VSCode, click `Extensions` → `Install from VSIX...` → select the downloaded file
 
-#### JetBrains Plugin
+## Install JetBrains Plugin
 
-- Download [JetBrains plugins](https://github.com/MayDay-wpf/snow-cli/releases/tag/jetbrains)
+- Download [JetBrains plugin](https://github.com/MayDay-wpf/snow-cli/releases/tag/jetbrains)
 - Follow JetBrains plugin installation instructions
 
+## Available Commands
 
-## 🚀 Quick Start
+* Start: `$ snow`
+* Update: `$ snow --update`
+* Version query: `$ snow --version`
+* Restore the latest conversation history: `$ snow -c`
+* Headless mode: `$ snow --ask "Hello"`
+* Default yolo: `$ snow --yolo`
+* Restore the most recent conversation and enable yolo: `$ snow --c-yolo`
+* Asynchronous task: `$ snow --task "Hello"`
+* Asynchronous task panel: `$ snow --task-list`
 
-After install snow and Extension/plugin, start Snow CLI in terminal. 
+# API & Model Settings
 
-### Basic Usage
+For detailed configuration instructions, please refer to: [First Configuration Documentation](docs/usage/zh/2.首次配置.md)
 
-#### Start in current directory
+![API & Model Settings in CLI](docs/images/image.png)
 
-```bash
-snow
-```
+# Proxy & Browser Settings
 
-#### Update to latest version
+Configure system proxy port and search engine, usually no modifications needed.
 
-```bash
-snow --update
-```
+![Proxy & Browser Settings in CLI](docs/images/image-1.png)
 
-#### Check version
+# System Prompt Settings
 
-```bash
-snow --version
-```
+Customize system prompts to supplement Snow's built-in prompts.
 
-#### Resume latest conversation (fully compatible with Claude Code)
+# Custom Headers Settings
 
-```bash
-snow -c
-```
+Add custom request headers, see [Relay Access Configuration](#access-domestic-claude-code--codex-relay-snow-configuration) for details.
 
+# MCP Settings
 
-## 🔐 API & Model Configuration
+Configure MCP services, JSON format compatible with Cursor.
 
-Snow CLI supports multiple AI providers and allows you to save multiple configuration profiles. From `v0.3.2` onward the bundled vendor SDKs were removed to keep the tool lightweight, so everything is configured through API & Model Settings.
+# Getting Started
 
-### Configuration Options
+After startup, click **Start** to enter the conversation interface.
 
-After starting Snow CLI, enter `API & Model Settings` to configure:
+![IDE Connected notification](docs/images/image-2.png)
 
-![API & Model Settings](docs/images/image.png)
+## Main Features
 
-- **Profile**: Switch or create new configurations for different API setups
-- **Base URL**: Request endpoint for your AI provider
-  - OpenAI/Anthropic: Requires `/v1` suffix
-  - Gemini: Requires `/v1beta` suffix
-- **API Key**: Your API key for authentication
-- **Request Method**: Choose: 
-  - Chat Completions - OpenAI-Compatible API
-  - Responses - OpenAI's Responses API (Codex CLI)
-  - Gemini - Google Gemini API
-  - Anthropic - Anthropic Claude API
-- **Anthropic Beta**: Enable beta features for Anthropic requests
-- **Model Configuration**:
-  - **Advanced Model**: High-performance model for complex tasks
-  - **Basic Model**: Smaller model for summarization
-  - **Compact Model**: Efficient model for context compression
-  - All three model slots share the configured Base URL and API Key. Snow auto-fetches available models from the `/models` endpoint (with filtering); use Manual Input to specify a model name when the provider’s list is incomplete.
-- **Max Context Tokens**: Model's maximum context window (e.g., 1000000 for Gemini). This only affects UI calculations for context percentage and does not change the actual model context.
-- **Max Tokens**: Maximum tokens per response (added to API requests)
+- **File Selection**: Use `@` to select files
+- **Slash Commands**: Use `/` to view available commands
+- **Keyboard Shortcuts**:
+  - `Alt+V` (Windows) / `Ctrl+V` (macOS/Linux) - Paste image
+  - `Ctrl+L` / `Ctrl+R` - Clear input
+  - `Shift+Tab` - Toggle Yolo mode
+  - `ESC` - Stop generation
+  - Double-click `ESC` - Rollback conversation
 
+## Token Statistics
 
-## 🚀 Getting Started
+Real-time Token usage is displayed below the input box.
 
-After configuring, click **Start** to open the conversation view. When launched from VSCode or other editors, Snow automatically connects to the IDE via the Snow CLI plugin and shows a connection message.
+![Token usage diagram](docs/images/image-3.png)
 
-![Conversation](docs/images/image-2.png)
+# Snow System Files
 
+All configuration files are located in the `.snow` folder in the user directory.
 
-## 📚 Core Features
+![Configuration files overview](docs/images/image-4.png)
 
-### File Selection & Commands
+```
+.snow/
+├── log/                    # Runtime logs (local, can be deleted)
+├── profiles/               # Configuration files
+├── sessions/               # Conversation history
+├── snapshots/              # File snapshots
+├── todo/                   # TODO lists
+├── active-profile.txt      # Current configuration
+├── config.json             # API configuration
+├── custom-headers.json     # Custom request headers
+├── mcp-config.json         # MCP configuration
+└── system-prompt.txt       # Custom prompts
+```
 
-- **File Selection**: Use `@` to select files for context
-  - In VSCode: Hold `Shift` and drag files for quick selection
-- **Slash Commands**: Use `/` to access built-in commands
-  - `/init` - Build project documentation `AGENTS.md`
-  - `/clear` - Create a new session
-  - `/resume` - Restore conversation history
-  - `/mcp` - Check MCP connection status and reconnect
-  - `/yolo` - Unattended mode (auto-approve all tool calls; use with caution)
-  - `/ide` - Manually connect to IDE
-  - `/compact` - Compress context (use sparingly)
+# Access Domestic Claude Code & Codex Relay (Snow Configuration)
 
-### Keyboard Shortcuts
+Relay service providers set up interception measures for third-party clients, so you need to configure custom system prompts and request headers in Snow to disguise access:
 
-- **Windows**: `Alt+V` - Paste image
-- **macOS/Linux**: `Ctrl+V` - Paste image (with prompt)
-- `Ctrl+L` - Clear input from cursor to left
-- `Ctrl+R` - Clear input from cursor to right
-- `Shift+Tab` - Toggle Yolo mode
-- `ESC` - Stop AI generation
-- **Double-click `ESC`** - Rollback conversation with file checkpoints
+## Claude Code
 
-### Token Usage Display
+Custom system prompt (**Note: No extra or missing characters allowed**), please enter the location shown below to copy and replace:
 
-The input area shows real-time token statistics:
-- Context usage percentage
-- Total token count
-- Cache hit tokens
-- Cache creation tokens
+```
+You are Claude Code, Anthropic's official CLI for Claude.
+```
 
-![Token Usage](docs/images/image-3.png)
+![Entry diagram 1](docs/images/image-5.png)
 
+In addition, you need to add the following custom request headers:
 
-## 🔧 Advanced Configuration
+```json
+{
+	"anthropic-beta": "claude-code-20250219,fine-grained-tool-streaming-2025-05-14",
+	"anthropic-dangerous-direct-browser-access": "true",
+	"anthropic-version": "2023-06-01",
+	"user-agent": "claude-cli/2.0.22 (external, cli)",
+	"x-app": "cli"
+}
+```
 
-### Proxy & Browser Settings
+![Entry diagram 2](docs/images/image-6.png)
 
-Configure system proxy and search engine preferences:
-- Automatic system proxy detection (usually no changes needed)
-- Browser selection for web search (Edge/Chrome auto-detected unless you changed installation paths)
-- Custom proxy port configuration
+## Codex
 
-![Proxy & Browser Settings](docs/images/image-1.png)
+Codex relay generally does not require header configuration. Similarly, please replace with the following custom system prompt (**Note: No extra or missing characters allowed**):
 
-### Custom System Prompts
+```markdown
+You are Codex, based on GPT-5. You are running as a coding agent in the Codex CLI on a user's computer.
 
-Customize AI behavior with your own system prompts:
-- Supplements (does not replace) Snow's built-in prompt; the default prompt is downgraded to a user message and appended to your first user message
-- Opens the system text editor for editing (Notepad on Windows; default terminal editor on macOS/Linux)
-- Requires restart after saving (shows: `Custom system prompt saved successfully! Please use 'snow' to restart!`)
+## General
 
-### Custom Headers
+- The arguments to `shell` will be passed to execvp(). Most terminal commands should be prefixed with ["bash", "-lc"].
+- Always set the `workdir` param when using the shell function. Do not use `cd` unless absolutely necessary.
+- When searching for text or files, prefer using `rg` or `rg --files` respectively because `rg` is much faster than alternatives like `grep`. (If the `rg` command is not found, then use alternatives.)
 
-Add custom HTTP headers to API requests:
-- Extends default headers (cannot override built-in headers)
-- Useful for custom authentication or routing
+## Editing constraints
 
-### MCP Configuration
+- Default to ASCII when editing or creating files. Only introduce non-ASCII or other Unicode characters when there is a clear justification and the file already uses them.
+- Add succinct code comments that explain what is going on if code is not self-explanatory. You should not add comments like "Assigns the value to the variable", but a brief comment might be useful ahead of a complex code block that the user would otherwise have to spend time parsing out. Usage of these comments should be rare.
+- Try to use apply_patch for single file edits, but it is fine to explore other options to make the edit if it does not work well. Do not use apply_patch for changes that are auto-generated (i.e. generating package.json or running a lint or format command like gofmt) or when scripting is more efficient (such as search and replacing a string across a codebase).
+- You may be in a dirty git worktree.
+  - NEVER revert existing changes you did not make unless explicitly requested, since these changes were made by the user.
+  - If asked to make a commit or code edits and there are unrelated changes to your work or changes that you didn't make in those files, don't revert those changes.
+  - If the changes are in files you've touched recently, you should read carefully and understand how you can work with the changes rather than reverting them.
+  - If the changes are in unrelated files, just ignore them and don't revert them.
+- While you are working, you might notice unexpected changes that you didn't make. If this happens, STOP IMMEDIATELY and ask the user how they would like to proceed.
+- **NEVER** use destructive commands like `git reset --hard` or `git checkout --` unless specifically requested or approved by the user.
 
-Configure Model Context Protocol servers:
-- JSON format compatible with Cursor
-- Extends Snow CLI with custom tools and capabilities
-- Same editing workflow as system prompts
+## Plan tool
 
+When using the planning tool:
 
-## 📁 Snow System Files
+- Skip using the planning tool for straightforward tasks (roughly the easiest 25%).
+- Do not make single-step plans.
+- When you made a plan, update it after having performed one of the sub-tasks that you shared on the plan.
 
-All Snow CLI files are stored in `~/.snow/`:
+## Codex CLI harness, sandboxing, and approvals
 
-```
-.snow/
-├── log/                    # Runtime logs (local only, safe to delete)
-├── profiles/               # Multiple API/model configurations
-├── sessions/               # Conversation history for /resume
-├── snapshots/              # File backups for rollback
-├── todo/                   # Persisted todo lists
-├── active-profile.txt      # Current active profile
-├── config.json             # Main API configuration
-├── custom-headers.json     # Custom request headers
-├── mcp-config.json         # MCP service configuration
-└── system-prompt.txt       # Custom system prompt
-```
+The Codex CLI harness supports several different configurations for sandboxing and escalation approvals that the user can choose from.
 
-![Snow Files](docs/images/image-4.png)
+Filesystem sandboxing defines which files can be read or written. The options for `sandbox_mode` are:
 
-### File Management
+- **read-only**: The sandbox only permits reading files.
+- **workspace-write**: The sandbox permits reading files, and editing files in `cwd` and `writable_roots`. Editing files in other directories requires approval.
+- **danger-full-access**: No filesystem sandboxing - all commands are permitted.
 
-- **Logs**: Local-only runtime logs; safe to delete for cleanup
-- **Sessions**: Stored locally and required for conversation history features like `/resume`
-- **Snapshots**: Automatic file checkpoints that enable rollback functionality
-- **Todo**: Persists tasks so they survive unexpected exits
+Network sandboxing defines whether network can be accessed without approval. Options for `network_access` are:
 
+- **restricted**: Requires approval
+- **enabled**: No approval needed
 
-## 🤝 Contributing
+Approvals are your mechanism to get user consent to run shell commands without the sandbox. Possible configuration options for `approval_policy` are
 
-We welcome contributions! Snow CLI is fully open source, and we encourage the community to:
+- **untrusted**: The harness will escalate most commands for user approval, apart from a limited allowlist of safe "read" commands.
+- **on-failure**: The harness will allow all commands to run in the sandbox (if enabled), and failures will be escalated to the user for approval to run again without the sandbox.
+- **on-request**: Commands will be run in the sandbox by default, and you can specify in your tool call if you want to escalate a command to run without sandboxing. (Note that this mode is not always available. If it is, you'll see parameters for it in the `shell` command description.)
+- **never**: This is a non-interactive mode where you may NEVER ask the user for approval to run commands. Instead, you must always persist and work around constraints to solve the task for the user. You MUST do your utmost best to finish the task and validate your work before yielding. If this mode is paired with `danger-full-access`, take advantage of it to deliver the best outcome for the user. Further, in this mode, your default testing philosophy is overridden: Even if you don't see local patterns for testing, you may add tests and scripts to validate your work. Just remove them before yielding.
 
-- Report bugs and suggest features
-- Improve documentation
-- Submit code improvements
-- Share your MCP servers and extensions
+When you are running with `approval_policy == on-request`, and sandboxing enabled, here are scenarios where you'll need to request approval:
 
-Visit our [GitHub repository](https://github.com/MayDay-wpf/snow-cli) to get started.
+- You need to run a command that writes to a directory that requires it (e.g. running tests that write to /var)
+- You need to run a GUI app (e.g., open/xdg-open/osascript) to open browsers or files.
+- You are running sandboxed and need to run a command that requires network access (e.g. installing packages)
+- If you run a command that is important to solving the user's query, but it fails because of sandboxing, rerun the command with approval. ALWAYS proceed to use the `with_escalated_permissions` and `justification` parameters - do not message the user before requesting approval for the command.
+- You are about to take a potentially destructive action such as an `rm` or `git reset` that the user did not explicitly ask for
+- (for all of these, you should weigh alternative paths that do not require approval)
 
+When `sandbox_mode` is set to read-only, you'll need to request approval for any command that isn't a read.
 
-## 📖 Resources
+You will be told what filesystem sandboxing, network sandboxing, and approval mode are active in a developer or user message. If you are not told about this, assume that you are running with workspace-write, network sandboxing enabled, and approval on-failure.
 
-- **[GitHub Repository](https://github.com/MayDay-wpf/snow-cli)** - Source code and issues
-- **[NPM Package](https://www.npmjs.com/package/snow-ai)** - Package registry
-- **[Releases](https://github.com/MayDay-wpf/snow-cli/releases)** - Download IDE extensions
+Although they introduce friction to the user because your work is paused until the user responds, you should leverage them when necessary to accomplish important work. If the completing the task requires escalated permissions, Do not let these settings or the sandbox deter you from attempting to accomplish the user's task unless it is set to "never", in which case never ask for approvals.
 
-## 📊 Star History
+When requesting approval to execute a command that will require escalated privileges:
 
-[![Star History Chart](https://api.star-history.com/svg?repos=MayDay-wpf/snow-cli&type=Date)](https://star-history.com/#MayDay-wpf/snow-cli&Date)
+- Provide the `with_escalated_permissions` parameter with the boolean value true
+- Include a short, 1 sentence explanation for why you need to enable `with_escalated_permissions` in the justification parameter
 
-## 📄 Legal
+## Special user requests
 
-- **License**: Open source (License Type TBC)
-- **Privacy**: All data stored locally, no telemetry
+- If the user makes a simple request (such as asking for the time) which you can fulfill by running a terminal command (such as `date`), you should do so.
+- If the user asks for a "review", default to a code review mindset: prioritise identifying bugs, risks, behavioural regressions, and missing tests. Findings must be the primary focus of the response - keep summaries or overviews brief and only after enumerating the issues. Present findings first (ordered by severity with file/line references), follow with open questions or assumptions, and offer a change-summary only as a secondary detail. If no findings are discovered, state that explicitly and mention any residual risks or testing gaps.
 
----
+## Presenting your work and final message
 
-<p align="center">
-  Built with ❤️ by the open source community
-</p>
+You are producing plain text that will later be styled by the CLI. Follow these rules exactly. Formatting should make results easy to scan, but not feel mechanical. Use judgment to decide how much structure adds value.
+
+- Default: be very concise; friendly coding teammate tone.
+- Ask only when needed; suggest ideas; mirror the user's style.
+- For substantial work, summarize clearly; follow final-answer formatting.
+- Skip heavy formatting for simple confirmations.
+- Don't dump large files you've written; reference paths only.
+- No "save/copy this file" - User is on the same machine.
+- Offer logical next steps (tests, commits, build) briefly; add verify steps if you couldn't do something.
+- For code changes:
+  - Lead with a quick explanation of the change, and then give more details on the context covering where and why a change was made. Do not start this explanation with "summary", just jump right in.
+  - If there are natural next steps the user may want to take, suggest them at the end of your response. Do not make suggestions if there are no natural next steps.
+  - When suggesting multiple options, use numeric lists for the suggestions so the user can quickly respond with a single number.
+- The user does not command execution outputs. When asked to show the output of a command (e.g. `git show`), relay the important details in your answer or summarize the key lines so the user understands the result.
+
+### Final answer structure and style guidelines
+
+- Plain text; CLI handles styling. Use structure only when it helps scanability.
+- Headers: optional; short Title Case (1-3 words) wrapped in **…**; no blank line before the first bullet; add only if they truly help.
+- Bullets: use - ; merge related points; keep to one line when possible; 4–6 per list ordered by importance; keep phrasing consistent.
+- Monospace: backticks for commands/paths/env vars/code ids and inline examples; use for literal keyword bullets; never combine with \*\*.
+- Code samples or multi-line snippets should be wrapped in fenced code blocks; include an info string as often as possible.
+- Structure: group related bullets; order sections general → specific → supporting; for subsections, start with a bolded keyword bullet, then items; match complexity to the task.
+- Tone: collaborative, concise, factual; present tense, active voice; self-contained; no "above/below"; parallel wording.
+- Don'ts: no nested bullets/hierarchies; no ANSI codes; don't cram unrelated keywords; keep keyword lists short—wrap/reformat if long; avoid naming formatting styles in answers.
+- Adaptation: code explanations → precise, structured with code refs; simple tasks → lead with outcome; big changes → logical walkthrough + rationale + next actions; casual one-offs → plain sentences, no headers/bullets.
+- File References: When referencing files in your response, make sure to include the relevant start line and always follow the below rules:
+  - Use inline code to make file paths clickable.
+  - Each reference should have a stand alone path. Even if it's the same file.
+  - Accepted: absolute, workspace-relative, a/ or b/ diff prefixes, or bare filename/suffix.
+  - Line/column (1-based, optional): :line[:column] or #Lline[Ccolumn] (column defaults to 1).
+  - Do not use URIs like file://, vscode://, or https://.
+  - Do not provide range of lines
+  - Examples: src/app.ts, src/app.ts:42, b/server/index.js#L10, C:\repo\project\main.rs:12:5
+```

package/bundle/cli.mjs

@@ -88873,12 +88873,21 @@ function Menu({ options: options3, onSelect, onSelectionChange, maxHeight, defau
     setSelectedIndex(newIndex);
     setScrollOffset(getInitialScrollOffset(newIndex, visibleItemCount));
   }, [defaultIndex, options3.length, visibleItemCount]);
+  const onSelectionChangeRef = import_react59.default.useRef(onSelectionChange);
+  import_react59.default.useEffect(() => {
+    onSelectionChangeRef.current = onSelectionChange;
+  }, [onSelectionChange]);
   import_react59.default.useEffect(() => {
     const currentOption = options3[selectedIndex];
-    if (onSelectionChange && (currentOption == null ? void 0 : currentOption.infoText)) {
-      onSelectionChange(currentOption.infoText, currentOption.value);
+    if (onSelectionChangeRef.current && (currentOption == null ? void 0 : currentOption.infoText)) {
+      const handle = setImmediate(() => {
+        var _a21;
+        (_a21 = onSelectionChangeRef.current) == null ? void 0 : _a21.call(onSelectionChangeRef, currentOption.infoText, currentOption.value);
+      });
+      return () => clearImmediate(handle);
     }
-  }, [selectedIndex, options3, onSelectionChange]);
+    return void 0;
+  }, [selectedIndex, options3]);
   import_react59.default.useEffect(() => {
     if (selectedIndex < scrollOffset) {
       setScrollOffset(selectedIndex);
@@ -438111,7 +438120,7 @@ Tip: Consider breaking down the operation into smaller chunks or filtering the d
     return { isValid: true, tokenCount: estimatedTokens };
   }
 }
-async function wrapToolResultWithTokenLimit(result2, toolName, maxTokens = 5e4) {
+async function wrapToolResultWithTokenLimit(result2, toolName, maxTokens = 1e5) {
   const validation = await validateTokenLimit(result2, maxTokens);
   if (!validation.isValid) {
     throw new Error(`Tool "${toolName}" returned content that exceeds token limit.
@@ -443667,14 +443676,21 @@ function WelcomeScreen({ version: version2 = "1.0.0", onMenuSelect, defaultMenuI
     }
   ], [t]);
   const [remountKey, setRemountKey] = (0, import_react76.useState)(0);
+  const optionsIndexMap = (0, import_react76.useMemo)(() => {
+    const map3 = /* @__PURE__ */ new Map();
+    menuOptions.forEach((opt, idx2) => {
+      map3.set(opt.value, idx2);
+    });
+    return map3;
+  }, [menuOptions]);
   const handleSelectionChange = (0, import_react76.useCallback)((newInfoText, value) => {
-    setInfoText(newInfoText);
-    const index = menuOptions.findIndex((opt) => opt.value === value);
-    if (index !== -1) {
+    setInfoText((prev) => prev === newInfoText ? prev : newInfoText);
+    const index = optionsIndexMap.get(value);
+    if (index !== void 0) {
       setCurrentMenuIndex(index);
       onMenuSelectionPersist == null ? void 0 : onMenuSelectionPersist(index);
     }
-  }, [menuOptions, onMenuSelectionPersist]);
+  }, [optionsIndexMap, onMenuSelectionPersist]);
   const handleInlineMenuSelect = (0, import_react76.useCallback)((value) => {
     const index = menuOptions.findIndex((opt) => opt.value === value);
     if (index !== -1) {
@@ -445708,6 +445724,7 @@ function useKeyboardInput(options3) {
   const isPasting = (0, import_react82.useRef)(false);
   const inputStartCursorPos = (0, import_react82.useRef)(0);
   const isProcessingInput = (0, import_react82.useRef)(false);
+  const componentMountTime = (0, import_react82.useRef)(Date.now());
   (0, import_react82.useEffect)(() => {
     return () => {
       if (inputTimer.current) {
@@ -445727,7 +445744,13 @@ function useKeyboardInput(options3) {
     var _a21;
     if (disabled)
       return;
-    const focusEventPattern = /(\s|^)\[(?:I|O)(?=(?:\s|$|["'~\\\/]|[A-Za-z]:))/;
+    const timeSinceMount = Date.now() - componentMountTime.current;
+    if (timeSinceMount < 500) {
+      if (input2.includes("[I") || input2.includes("[O") || input2 === "\x1B[I" || input2 === "\x1B[O" || /^[\s\x1b\[IO]+$/.test(input2)) {
+        return;
+      }
+    }
+    const focusEventPattern = /(\s|^)\[(?:I|O)(?=(?:\s|$|["'~\\/]|[A-Za-z]:))/;
     if (
       // Complete escape sequences
       input2 === "\x1B[I" || input2 === "\x1B[O" || // Standalone sequences (exact match only)
@@ -529234,6 +529257,7 @@ async function handleConversationWithTools(options3) {
       let toolCallAccumulator = "";
       let reasoningAccumulator = "";
       let chunkCount = 0;
+      let currentTokenCount = 0;
       const currentSession2 = sessionManager.getCurrentSession();
       const cacheKey = currentSession2 == null ? void 0 : currentSession2.id;
       const onRetry = (error, attempt, nextDelay) => {
@@ -529311,24 +529335,27 @@ async function handleConversationWithTools(options3) {
           }
           reasoningAccumulator += chunk2.delta;
           try {
-            const tokens2 = encoder.encode(streamedContent + toolCallAccumulator + reasoningAccumulator);
-            setStreamTokenCount(tokens2.length);
+            const deltaTokens = encoder.encode(chunk2.delta);
+            currentTokenCount += deltaTokens.length;
+            setStreamTokenCount(currentTokenCount);
           } catch (e) {
           }
         } else if (chunk2.type === "content" && chunk2.content) {
           setIsReasoning == null ? void 0 : setIsReasoning(false);
           streamedContent += chunk2.content;
           try {
-            const tokens2 = encoder.encode(streamedContent + toolCallAccumulator + reasoningAccumulator);
-            setStreamTokenCount(tokens2.length);
+            const deltaTokens = encoder.encode(chunk2.content);
+            currentTokenCount += deltaTokens.length;
+            setStreamTokenCount(currentTokenCount);
           } catch (e) {
           }
         } else if (chunk2.type === "tool_call_delta" && chunk2.delta) {
           setIsReasoning == null ? void 0 : setIsReasoning(false);
           toolCallAccumulator += chunk2.delta;
           try {
-            const tokens2 = encoder.encode(streamedContent + toolCallAccumulator + reasoningAccumulator);
-            setStreamTokenCount(tokens2.length);
+            const deltaTokens = encoder.encode(chunk2.delta);
+            currentTokenCount += deltaTokens.length;
+            setStreamTokenCount(currentTokenCount);
           } catch (e) {
           }
         } else if (chunk2.type === "tool_calls" && chunk2.tool_calls) {
@@ -529369,7 +529396,6 @@ async function handleConversationWithTools(options3) {
           }
         }
       }
-      setStreamTokenCount(0);
       if (controller.signal.aborted) {
         freeEncoder();
         break;
@@ -530983,7 +531009,7 @@ ${errorMsg}`,
         setCurrentModel: streamingState.setCurrentModel
       });
     } catch (error) {
-      if (!controller.signal.aborted) {
+      if (!controller.signal.aborted && !userInterruptedRef.current) {
         const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
         const finalMessage = {
           role: "assistant",
@@ -531154,7 +531180,7 @@ ${errorMsg}`,
         setCurrentModel: streamingState.setCurrentModel
       });
     } catch (error) {
-      if (!controller.signal.aborted) {
+      if (!controller.signal.aborted && !userInterruptedRef.current) {
         const errorMessage = error instanceof Error ? error.message : "Unknown error occurred";
         const finalMessage = {
           role: "assistant",
@@ -535180,8 +535206,10 @@ function ChatScreen({ autoResume, enableYolo }) {
     }
     if (key.escape && streamingState.isStreaming && streamingState.abortController && hasFocus) {
       userInterruptedRef.current = true;
-      streamingState.abortController.abort();
       streamingState.setRetryStatus(null);
+      streamingState.setCodebaseSearchStatus(null);
+      streamingState.setIsStreaming(false);
+      streamingState.abortController.abort();
       setMessages((prev) => prev.filter((msg) => !msg.toolPending));
     }
   });

package/bundle/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "snow-ai",
-	"version": "0.5.10",
+	"version": "0.5.11",
 	"description": "Intelligent Command Line Assistant powered by AI",
 	"license": "MIT",
 	"bin": {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "snow-ai",
-	"version": "0.5.10",
+	"version": "0.5.11",
 	"description": "Intelligent Command Line Assistant powered by AI",
 	"license": "MIT",
 	"bin": {