snow-ai 0.3.26 → 0.3.28

package/dist/api/systemPrompt.js

@@ -101,30 +101,50 @@ const SYSTEM_PROMPT_TEMPLATE = `You are Snow AI CLI, an intelligent command-line
 
 **Golden Rule: Read what you need to write correct code, nothing more.**
 
-### 📋 TODO Management - For Complex Programming Tasks
-
-**🚫 CRITICAL: TODO tools MUST be called in parallel with other tools - NEVER call TODO tools alone!**
-
-**When to use TODO:**
-- Complex tasks with 5+ steps requiring tracking
-- Multi-file implementations needing coordination
-- User explicitly requests TODO
-
-**When to skip TODO:**
-- Simple 1-3 step tasks (just do them)
-- Single file edits or quick fixes
-
-**Usage rules:**
-1. **Parallel calls only**: Always combine TODO with action tools (filesystem-edit, etc.)
-2. **Action-focused**: "Fix parser.ts timeout" ✅, "Read parser.ts" ❌
-3. **Update immediately**: Mark completed right after task is done
-4. **Keep minimal**: 3-7 tasks max, avoid over-planning
-
-**Example workflow:**
-- ✅ CORRECT: Call todo-create with filesystem-edit in parallel
-- ✅ CORRECT: Call todo-update with filesystem-edit in parallel
-- ❌ WRONG: Call todo-create alone, then wait, then call filesystem-edit
-- ❌ WRONG: Call todo-update alone, then wait, then proceed
+### 📋 TODO Management - STRONGLY RECOMMENDED for Better Results!
+
+**🎯 DEFAULT BEHAVIOR: Use TODO for ALL multi-step tasks (3+ steps)**
+
+**✨ WHY TODO IS ESSENTIAL:**
+- 📊 **Track progress** - Never lose your place in complex work
+- ✅ **Ensure completeness** - Verify all steps are done
+- 🎯 **Stay focused** - Clear roadmap prevents confusion
+- 💪 **Build confidence** - Users see structured progress
+- 🚀 **Better quality** - Systematic approach reduces errors
+
+**⚡ WHEN TO USE TODO (Default for most tasks):**
+- ✅ **ANY multi-file modification** (always use)
+- ✅ **ANY feature implementation** (always use)
+- ✅ **ANY refactoring task** (always use)
+- ✅ **Bug fixes touching 2+ files** (recommended)
+- ✅ **User requests with multiple requirements** (always use)
+- ✅ **Unfamiliar codebase changes** (recommended)
+- ⚠️ **SKIP ONLY for**: Single-file trivial edits (1-2 lines)
+
+**🔧 USAGE RULES (Critical):**
+1. **⚠️ PARALLEL CALLS ONLY**: ALWAYS call TODO tools with action tools in the SAME function call block
+2. **Immediate updates**: Mark completed while performing work (not after)
+3. **Right sizing**: 3-7 main tasks, add subtasks if needed
+4. **Lifecycle Management**:
+   - New task = Create TODO at start
+   - Major requirement change = Delete old + create new
+   - Minor adjustment = Use todo-add or todo-update
+   - **CRITICAL**: Keep using TODO throughout the entire conversation!
+
+**✅ CORRECT PATTERNS (Do this):**
+- ✅ todo-create + filesystem-read → Plan while gathering info
+- ✅ todo-update(completed) + filesystem-edit → Update as you work
+- ✅ todo-get + filesystem-read → Check status while reading
+- ✅ todo-add + filesystem-edit → Add new task while working
+
+**❌ FORBIDDEN PATTERNS (NEVER do this - WILL FAIL):**
+- ❌ todo-create alone, wait for result, then work → VIOLATION! Call together!
+- ❌ todo-update alone, wait, then continue → VIOLATION! Update while working!
+- ❌ todo-get alone just to check → VIOLATION! Call with other tools!
+- ❌ Skipping TODO for multi-file tasks → VIOLATION! Always use TODO!
+- ❌ **Abandoning TODO mid-conversation** → VIOLATION! Keep using throughout dialogue!
+
+**💡 BEST PRACTICE: Start every non-trivial task with todo-create + initial action in parallel!**
 
 ## 🛠️ Available Tools
 
@@ -175,9 +195,10 @@ Guidance and recommendations:
 
 ## 📚 Project Context (SNOW.md)
 
-- Read ONLY when implementing large features or unfamiliar architecture
-- Skip for simple tasks where you understand the structure
-- Contains: project overview, architecture, tech stack
+- Contains: project overview, architecture, tech stack.
+- Generally located in the project root directory.
+- You can read this file at any time to understand the project and recommend reading.
+- This file may not exist. If you can't find it, please ignore it.
 
 Remember: **ACTION > ANALYSIS**. Write code first, investigate only when blocked.`;
 // Export SYSTEM_PROMPT as a getter function for real-time ROLE.md updates

package/dist/hooks/useCommandHandler.js

@@ -27,6 +27,7 @@ export async function executeContextCompression() {
             tool_calls: msg.tool_calls,
             images: msg.images,
             reasoning: msg.reasoning,
+            thinking: msg.thinking, // 保留 thinking 字段（Anthropic Extended Thinking）
             subAgentInternal: msg.subAgentInternal,
         }));
         // Compress the context (全量压缩，保留最后一轮完整对话)
@@ -38,10 +39,10 @@ export async function executeContextCompression() {
         }
         // 构建新的会话消息列表
         const newSessionMessages = [];
-        // 添加压缩摘要到会话
+        // 添加压缩摘要到会话（使用 user 角色，因为 Extended Thinking 模式下所有 assistant 消息都需要 thinking 块）
         newSessionMessages.push({
-            role: 'assistant',
-            content: compressionResult.summary,
+            role: 'user',
+            content: `[Context Summary from Previous Conversation]\n\n${compressionResult.summary}`,
             timestamp: Date.now(),
         });
         // 添加保留的最后一轮完整对话（保留完整的消息结构）
@@ -57,6 +58,7 @@ export async function executeContextCompression() {
                     ...(msg.tool_calls && { tool_calls: msg.tool_calls }),
                     ...(msg.images && { images: msg.images }),
                     ...(msg.reasoning && { reasoning: msg.reasoning }),
+                    ...(msg.thinking && { thinking: msg.thinking }), // 保留 thinking 字段（Anthropic Extended Thinking）
                     ...(msg.subAgentInternal !== undefined && {
                         subAgentInternal: msg.subAgentInternal,
                     }),

package/dist/hooks/useCommandPanel.js

@@ -53,8 +53,40 @@ export function useCommandPanel(buffer, isProcessing = false) {
         if (!text.startsWith('/'))
             return [];
         const query = text.slice(1).toLowerCase();
-        return commands.filter(command => command.name.toLowerCase().includes(query) ||
-            command.description.toLowerCase().includes(query));
+        // Filter and sort commands by priority
+        // Priority order:
+        // 1. Command starts with query (highest)
+        // 2. Command contains query
+        // 3. Description starts with query
+        // 4. Description contains query (lowest)
+        const filtered = commands
+            .filter(command => command.name.toLowerCase().includes(query) ||
+            command.description.toLowerCase().includes(query))
+            .map(command => {
+            const nameLower = command.name.toLowerCase();
+            const descLower = command.description.toLowerCase();
+            let priority = 4; // Default: description contains query
+            if (nameLower.startsWith(query)) {
+                priority = 1; // Command starts with query
+            }
+            else if (nameLower.includes(query)) {
+                priority = 2; // Command contains query
+            }
+            else if (descLower.startsWith(query)) {
+                priority = 3; // Description starts with query
+            }
+            return { command, priority };
+        })
+            .sort((a, b) => {
+            // Sort by priority (lower number = higher priority)
+            if (a.priority !== b.priority) {
+                return a.priority - b.priority;
+            }
+            // If same priority, sort alphabetically by name
+            return a.command.name.localeCompare(b.command.name);
+        })
+            .map(item => item.command);
+        return filtered;
     }, [buffer]);
     // Update command panel state
     const updateCommandPanelState = useCallback((text) => {

package/dist/hooks/useConversation.js

@@ -327,6 +327,10 @@ export async function handleConversationWithTools(options) {
                     ]);
                 }
                 // Display tool calls in UI - 只有耗时工具才显示进行中状态
+                // Generate parallel group ID when there are multiple tools
+                const parallelGroupId = receivedToolCalls.length > 1
+                    ? `parallel-${Date.now()}-${Math.random()}`
+                    : undefined;
                 for (const toolCall of receivedToolCalls) {
                     const toolDisplay = formatToolCallMessage(toolCall);
                     let toolArgs;
@@ -351,6 +355,8 @@ export async function handleConversationWithTools(options) {
                                 toolDisplay,
                                 toolCallId: toolCall.id, // Store tool call ID for later update
                                 toolPending: true, // Mark as pending execution
+                                // Mark parallel group for ALL tools (time-consuming or not)
+                                parallelGroup: parallelGroupId,
                             },
                         ]);
                     }
@@ -724,6 +730,8 @@ export async function handleConversationWithTools(options) {
                     m.toolResult !== undefined ||
                     m.subAgentInternal === true));
                 // Update existing tool call messages with results
+                // Collect all result messages first, then add them in batch
+                const resultMessages = [];
                 for (const result of toolResults) {
                     const toolCall = receivedToolCalls.find(tc => tc.id === result.tool_call_id);
                     if (toolCall) {
@@ -733,17 +741,13 @@ export async function handleConversationWithTools(options) {
                             const isError = result.content.startsWith('Error:');
                             const statusIcon = isError ? '✗' : '✓';
                             const statusText = isError ? `\n  └─ ${result.content}` : '';
-                            // Display subagent completion message in main flow
-                            setMessages(prev => [
-                                ...prev,
-                                {
-                                    role: 'assistant',
-                                    content: `${statusIcon} ${toolCall.function.name}${statusText}`,
-                                    streaming: false,
-                                    // Pass the full result.content for ToolResultPreview to parse
-                                    toolResult: !isError ? result.content : undefined,
-                                },
-                            ]);
+                            resultMessages.push({
+                                role: 'assistant',
+                                content: `${statusIcon} ${toolCall.function.name}${statusText}`,
+                                streaming: false,
+                                // Pass the full result.content for ToolResultPreview to parse
+                                toolResult: !isError ? result.content : undefined,
+                            });
                             // Save the tool result to conversation history
                             conversationMessages.push(result);
                             saveMessage(result).catch(error => {
@@ -790,27 +794,24 @@ export async function handleConversationWithTools(options) {
                         // - 普通工具(单步显示):完成消息需要包含参数和结果，使用 toolDisplay
                         // 获取工具参数的格式化信息
                         const toolDisplay = formatToolCallMessage(toolCall);
-                        setMessages(prev => [
-                            ...prev,
-                            // Add new completed message
-                            {
-                                role: 'assistant',
-                                content: `${statusIcon} ${toolCall.function.name}${statusText}`,
-                                streaming: false,
-                                toolCall: editDiffData
-                                    ? {
-                                        name: toolCall.function.name,
-                                        arguments: editDiffData,
-                                    }
-                                    : undefined,
-                                // 为普通工具添加参数显示（耗时工具在进行中状态已经显示过参数）
-                                toolDisplay: !isToolNeedTwoStepDisplay(toolCall.function.name)
-                                    ? toolDisplay
-                                    : undefined,
-                                // Store tool result for preview rendering
-                                toolResult: !isError ? result.content : undefined,
-                            },
-                        ]);
+                        const isNonTimeConsuming = !isToolNeedTwoStepDisplay(toolCall.function.name);
+                        resultMessages.push({
+                            role: 'assistant',
+                            content: `${statusIcon} ${toolCall.function.name}${statusText}`,
+                            streaming: false,
+                            toolCall: editDiffData
+                                ? {
+                                    name: toolCall.function.name,
+                                    arguments: editDiffData,
+                                }
+                                : undefined,
+                            // 为普通工具添加参数显示（耗时工具在进行中状态已经显示过参数）
+                            toolDisplay: isNonTimeConsuming ? toolDisplay : undefined,
+                            // Store tool result for preview rendering
+                            toolResult: !isError ? result.content : undefined,
+                            // Mark parallel group for ALL tools (time-consuming or not)
+                            parallelGroup: parallelGroupId,
+                        });
                     }
                     // Add tool result to conversation history and save (skip if already saved above)
                     if (toolCall && !toolCall.function.name.startsWith('subagent-')) {
@@ -820,6 +821,10 @@ export async function handleConversationWithTools(options) {
                         });
                     }
                 }
+                // Add all result messages in batch to avoid intermediate renders
+                if (resultMessages.length > 0) {
+                    setMessages(prev => [...prev, ...resultMessages]);
+                }
                 // Check if there are pending user messages to insert
                 if (options.getPendingMessages && options.clearPendingMessages) {
                     const pendingMessages = options.getPendingMessages();

package/dist/mcp/todo.js

@@ -213,36 +213,43 @@ export class TodoService {
         return [
             {
                 name: 'todo-create',
-                description: `Create a TODO list for complex multi-step tasks (optional planning tool).
+                description: `✅ RECOMMENDED: Create TODO list for structured task execution. Use this for ALL multi-step tasks!
 
-## CORE PRINCIPLE - FOCUS ON EXECUTION:
-TODO lists are OPTIONAL helpers for complex tasks. Your PRIMARY goal is COMPLETING THE WORK, not maintaining perfect TODO lists. Use this tool only when it genuinely helps organize complex work - don't let TODO management slow you down.
+⚠️ MANDATORY RULE - PARALLEL CALLS ONLY:
+🚫 NEVER call todo-create alone! MUST call with other tools in the SAME function call block.
+✅ ALWAYS: todo-create + filesystem-read (or other action tool) in parallel
+❌ FORBIDDEN: Call todo-create, wait for result, then call other tools
 
-## WHEN TO USE (Optional):
-- Complex tasks with 5+ distinct steps that benefit from tracking
-- Long-running tasks where progress visibility helps the user
-- Tasks with multiple dependencies that need careful ordering
-- User explicitly requests a TODO list
+## 🎯 DEFAULT USAGE - Use TODO by default for:
+✅ ANY multi-file changes (always create TODO first)
+✅ ANY feature implementation (plan with TODO)
+✅ ANY refactoring work (track with TODO)
+✅ Bug fixes involving 2+ files (use TODO)
+✅ Tasks with 3+ distinct steps (create TODO)
+⚠️ SKIP ONLY: Single-file trivial edits (1-2 lines)
 
-## WHEN TO SKIP:
-- Simple 1-3 step tasks (just do the work directly)
-- Straightforward file edits or single-function changes
-- Quick fixes or minor modifications
-- When TODO creation takes longer than just doing the task
+## 🚀 WHY CREATE TODO:
+- Ensures all requirements are addressed
+- Prevents missing critical steps
+- Provides clear progress tracking
+- Improves code quality through systematic approach
+- Builds user confidence with visible structure
 
-## LIFECYCLE MANAGEMENT:
-1. **NEW REQUEST = NEW TODO LIST**: Completely new requirement? Delete old todos first, then create new list.
-2. **INCREMENTAL REQUEST = USE TODO-ADD**: Adding to existing requirement? Use "todo-add" instead.
-3. Use this tool ONLY when starting fresh (new session or new requirement after cleanup).
+## 📋 WHEN TO CALL:
+1. **NEW TASK**: Create TODO immediately when starting work (with parallel action)
+2. **NEW REQUIREMENT**: Delete old todos, create fresh list (with parallel action)
+3. **BEST PRACTICE**: Call todo-create + filesystem-read in parallel
 
-## CREATION GUIDELINES:
-- Keep it simple and actionable
-- 3-7 main tasks is usually sufficient (don't over-plan)
-- Include verification steps only if critical
-- Order by dependencies
+## ⚡ CREATION GUIDELINES:
+- Break work into 3-7 clear, actionable tasks
+- Order by logical dependencies
+- Be specific (e.g., "Modify validateInput in form.ts" not "fix validation")
+- Include verification step if critical
 
-## WARNING:
-This REPLACES the entire TODO list. Never use it to "add more tasks" - use "todo-add" instead.`,
+## ⚠️ LIFECYCLE:
+This REPLACES the entire TODO list. For adding tasks to existing list, use "todo-add" instead.
+
+## 💡 REMEMBER: MUST call with other tools - never alone!`,
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -270,7 +277,19 @@ This REPLACES the entire TODO list. Never use it to "add more tasks" - use "todo
             },
             {
                 name: 'todo-get',
-                description: `Get current TODO list with task IDs, status, and hierarchy. Call with other tools in parallel when needed.`,
+                description: `Get current TODO list with task IDs, status, and hierarchy.
+
+⚠️ MANDATORY RULE - PARALLEL CALLS ONLY:
+🚫 NEVER call todo-get alone! MUST call with other tools in the SAME function call block.
+✅ ALWAYS: todo-get + filesystem-read/terminal-execute/etc in parallel
+❌ FORBIDDEN: Call todo-get alone to check status
+
+## 🔄 WHEN TO USE IN DIALOGUE:
+- **User provides additional info**: Use todo-get + filesystem-read to check what's done
+- **User requests modifications**: Check current progress before adding/updating tasks
+- **Continuing work**: Always check status first to avoid redoing completed tasks
+
+USAGE: Combine with filesystem-read, terminal-execute, or other actions to check progress while working.`,
                 inputSchema: {
                     type: 'object',
                     properties: {},
@@ -278,7 +297,17 @@ This REPLACES the entire TODO list. Never use it to "add more tasks" - use "todo
             },
             {
                 name: 'todo-update',
-                description: `Update TODO status/content. MUST call with other tools - mark "completed" ONLY after task is verified and done.`,
+                description: `Update TODO status/content - USE THIS FREQUENTLY to track progress!
+
+⚠️ MANDATORY RULE - PARALLEL CALLS ONLY:
+🚫 NEVER call todo-update alone! MUST call with other tools in the SAME function call block.
+✅ ALWAYS: todo-update + filesystem-edit/terminal-execute/etc in parallel
+❌ FORBIDDEN: Call todo-update, wait for result, then proceed
+
+BEST PRACTICE: Mark "completed" ONLY after task is verified.
+Example: todo-update(task1, completed) + filesystem-edit(task2) → Update while working!
+
+💡 This ensures efficient workflow and prevents unnecessary wait times.`,
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -301,7 +330,19 @@ This REPLACES the entire TODO list. Never use it to "add more tasks" - use "todo
             },
             {
                 name: 'todo-add',
-                description: `Add task to existing TODO (rare use). MUST call with other tools. Only for user-requested or complex tasks, not small steps.`,
+                description: `Add new task to existing TODO list when requirements expand.
+
+⚠️ MANDATORY RULE - PARALLEL CALLS ONLY:
+🚫 NEVER call todo-add alone! MUST call with other tools in the SAME function call block.
+✅ ALWAYS: todo-add + filesystem-edit/filesystem-read/etc in parallel
+❌ FORBIDDEN: Call todo-add alone to add task
+
+USE WHEN:
+- User adds new requirements during work
+- You discover additional necessary steps
+- Breaking down a complex task into subtasks
+
+DO NOT use for initial planning - use todo-create instead.`,
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -319,7 +360,14 @@ This REPLACES the entire TODO list. Never use it to "add more tasks" - use "todo
             },
             {
                 name: 'todo-delete',
-                description: `Delete TODO item. MUST call with other tools. Deleting parent auto-deletes children (cascade).`,
+                description: `Delete TODO item from the list.
+
+⚠️ MANDATORY RULE - PARALLEL CALLS ONLY:
+🚫 NEVER call todo-delete alone! MUST call with other tools in the SAME function call block.
+✅ ALWAYS: todo-delete + filesystem-edit/todo-get/etc in parallel
+❌ FORBIDDEN: Call todo-delete alone
+
+NOTE: Deleting a parent task will cascade delete all its children automatically.`,
                 inputSchema: {
                     type: 'object',
                     properties: {

package/dist/ui/components/MessageList.d.ts

@@ -39,6 +39,7 @@ export interface Message {
         isComplete?: boolean;
     };
     subAgentInternal?: boolean;
+    parallelGroup?: string;
 }
 interface Props {
     messages: Message[];

package/dist/ui/components/TodoTree.js

@@ -23,6 +23,8 @@ export default function TodoTree({ todos }) {
                 return '[✓]';
             case 'pending':
                 return '[ ]';
+            default:
+                return '[ ]';
         }
     };
     const getStatusColor = (status) => {

package/dist/ui/pages/ChatScreen.js

@@ -913,6 +913,35 @@ export default function ChatScreen({ skipWelcome }) {
                     let toolStatusColor = 'cyan';
                     let isToolMessage = false;
                     const isLastMessage = index === filteredMessages.length - 1;
+                    // Check if this message is part of a parallel group
+                    const isInParallelGroup = message.parallelGroup !== undefined &&
+                        message.parallelGroup !== null;
+                    // Check if this is a time-consuming tool (has toolPending or starts with ⚡)
+                    // Time-consuming tools should not show parallel group indicators
+                    const isTimeConsumingTool = message.toolPending ||
+                        (message.role === 'assistant' &&
+                            (message.content.startsWith('⚡') ||
+                                message.content.includes('⚇⚡')));
+                    // Only show parallel group indicators for non-time-consuming tools
+                    const shouldShowParallelIndicator = isInParallelGroup && !isTimeConsumingTool;
+                    const isFirstInGroup = shouldShowParallelIndicator &&
+                        (index === 0 ||
+                            filteredMessages[index - 1]?.parallelGroup !==
+                                message.parallelGroup ||
+                            // Previous message is time-consuming tool, so this is the first non-time-consuming one
+                            filteredMessages[index - 1]?.toolPending ||
+                            filteredMessages[index - 1]?.content.startsWith('⚡'));
+                    // Check if this is the last message in the parallel group
+                    // Only show end indicator if:
+                    // 1. This is truly the last message, OR
+                    // 2. Next message has a DIFFERENT non-null parallelGroup (not just undefined)
+                    const nextMessage = filteredMessages[index + 1];
+                    const nextHasDifferentGroup = nextMessage &&
+                        nextMessage.parallelGroup !== undefined &&
+                        nextMessage.parallelGroup !== null &&
+                        nextMessage.parallelGroup !== message.parallelGroup;
+                    const isLastInGroup = shouldShowParallelIndicator &&
+                        (!nextMessage || nextHasDifferentGroup);
                     if (message.role === 'assistant' || message.role === 'subagent') {
                         if (message.content.startsWith('⚡') ||
                             message.content.includes('⚇⚡')) {
@@ -934,17 +963,23 @@ export default function ChatScreen({ skipWelcome }) {
                                 message.role === 'subagent' ? 'magenta' : 'blue';
                         }
                     }
-                    return (React.createElement(Box, { key: `msg-${index}`, marginTop: index > 0 ? 1 : 0, marginBottom: isLastMessage ? 1 : 0, paddingX: 1, flexDirection: "column", width: terminalWidth },
+                    return (React.createElement(Box, { key: `msg-${index}`, marginTop: index > 0 && !shouldShowParallelIndicator ? 1 : 0, marginBottom: isLastMessage ? 1 : 0, paddingX: 1, flexDirection: "column", width: terminalWidth },
+                        isFirstInGroup && (React.createElement(Box, { marginBottom: 0 },
+                            React.createElement(Text, { color: "#FF6EBF", dimColor: true }, "\u250C\u2500 Parallel execution"))),
                         React.createElement(Box, null,
                             React.createElement(Text, { color: message.role === 'user'
                                     ? 'green'
                                     : message.role === 'command'
                                         ? 'gray'
-                                        : toolStatusColor, bold: true }, message.role === 'user'
-                                ? '⛇'
-                                : message.role === 'command'
-                                    ? '⌘'
-                                    : '❆'),
+                                        : toolStatusColor, bold: true },
+                                shouldShowParallelIndicator && !isFirstInGroup
+                                    ? '│'
+                                    : '',
+                                message.role === 'user'
+                                    ? '⛇'
+                                    : message.role === 'command'
+                                        ? '⌘'
+                                        : '❆'),
                             React.createElement(Box, { marginLeft: 1, flexDirection: "column" }, message.role === 'command' ? (React.createElement(React.Fragment, null,
                                 React.createElement(Text, { color: "gray", dimColor: true },
                                     "\u2514\u2500 ",
@@ -1022,7 +1057,9 @@ export default function ChatScreen({ skipWelcome }) {
                                     "\u2514\u2500 [image #",
                                     imageIndex + 1,
                                     "]"))))),
-                                message.discontinued && (React.createElement(Text, { color: "red", bold: true }, "\u2514\u2500 user discontinue"))))))));
+                                message.discontinued && (React.createElement(Text, { color: "red", bold: true }, "\u2514\u2500 user discontinue")))))),
+                        isLastInGroup && (React.createElement(Box, { marginTop: 0 },
+                            React.createElement(Text, { color: "#FF6EBF", dimColor: true }, "\u2514\u2500 End parallel execution")))));
                 }),
             ] }, item => item),
         (streamingState.isStreaming || isSaving) && !pendingToolConfirmation && (React.createElement(Box, { marginBottom: 1, paddingX: 1, width: terminalWidth },

package/dist/utils/sessionConverter.js

@@ -103,6 +103,12 @@ export function convertSessionMessagesToUI(sessionMessages) {
             msg.tool_calls &&
             msg.tool_calls.length > 0 &&
             !msg.subAgentInternal) {
+            // Generate parallel group ID for non-time-consuming tools
+            const hasMultipleTools = msg.tool_calls.length > 1;
+            const hasNonTimeConsumingTool = msg.tool_calls.some(tc => !isToolNeedTwoStepDisplay(tc.function.name));
+            const parallelGroupId = hasMultipleTools && hasNonTimeConsumingTool
+                ? `parallel-${i}-${Math.random()}`
+                : undefined;
             for (const toolCall of msg.tool_calls) {
                 // Skip if already processed
                 if (processedToolCalls.has(toolCall.id))
@@ -130,7 +136,15 @@ export function convertSessionMessagesToUI(sessionMessages) {
                         toolDisplay,
                     });
                 }
-                processedToolCalls.add(toolCall.id);
+                // Store parallel group info for this tool call
+                if (parallelGroupId && !needTwoSteps) {
+                    processedToolCalls.add(toolCall.id);
+                    // Mark this tool call with parallel group (will be used when processing tool results)
+                    toolCall.parallelGroupId = parallelGroupId;
+                }
+                else {
+                    processedToolCalls.add(toolCall.id);
+                }
             }
             continue;
         }
@@ -219,6 +233,23 @@ export function convertSessionMessagesToUI(sessionMessages) {
                     }
                 }
             }
+            // Check if this tool result is part of a parallel group
+            let parallelGroupId;
+            for (let j = i - 1; j >= 0; j--) {
+                const prevMsg = sessionMessages[j];
+                if (!prevMsg)
+                    continue;
+                if (prevMsg.role === 'assistant' &&
+                    prevMsg.tool_calls &&
+                    !prevMsg.subAgentInternal) {
+                    const tc = prevMsg.tool_calls.find(t => t.id === msg.tool_call_id);
+                    if (tc) {
+                        parallelGroupId = tc.parallelGroupId;
+                        break;
+                    }
+                }
+            }
+            const isNonTimeConsuming = !isToolNeedTwoStepDisplay(toolName);
             uiMessages.push({
                 role: 'assistant',
                 content: `${statusIcon} ${toolName}${statusText}`,
@@ -231,6 +262,19 @@ export function convertSessionMessagesToUI(sessionMessages) {
                     }
                     : undefined,
                 terminalResult: terminalResultData,
+                // Add toolDisplay for non-time-consuming tools
+                toolDisplay: isNonTimeConsuming && !editDiffData
+                    ? formatToolCallMessage({
+                        id: msg.tool_call_id || '',
+                        type: 'function',
+                        function: {
+                            name: toolName,
+                            arguments: JSON.stringify(toolArgs),
+                        },
+                    })
+                    : undefined,
+                // Mark parallel group for non-time-consuming tools
+                parallelGroup: isNonTimeConsuming && parallelGroupId ? parallelGroupId : undefined,
             });
             continue;
         }

package/dist/utils/toolExecutor.d.ts

@@ -27,6 +27,8 @@ export interface AddToAlwaysApprovedCallback {
  */
 export declare function executeToolCall(toolCall: ToolCall, abortSignal?: AbortSignal, onTokenUpdate?: (tokenCount: number) => void, onSubAgentMessage?: SubAgentMessageCallback, requestToolConfirmation?: ToolConfirmationCallback, isToolAutoApproved?: ToolApprovalChecker, yoloMode?: boolean, addToAlwaysApproved?: AddToAlwaysApprovedCallback): Promise<ToolResult>;
 /**
- * Execute multiple tool calls in parallel
+ * Execute multiple tool calls with intelligent sequencing
+ * - Tools modifying the same resource execute sequentially
+ * - Independent tools execute in parallel
  */
 export declare function executeToolCalls(toolCalls: ToolCall[], abortSignal?: AbortSignal, onTokenUpdate?: (tokenCount: number) => void, onSubAgentMessage?: SubAgentMessageCallback, requestToolConfirmation?: ToolConfirmationCallback, isToolAutoApproved?: ToolApprovalChecker, yoloMode?: boolean, addToAlwaysApproved?: AddToAlwaysApprovedCallback): Promise<ToolResult[]>;

package/dist/utils/toolExecutor.js

@@ -63,8 +63,96 @@ export async function executeToolCall(toolCall, abortSignal, onTokenUpdate, onSu
     }
 }
 /**
- * Execute multiple tool calls in parallel
+ * Categorize tools by their resource type for proper execution sequencing
+ */
+function getToolResourceType(toolName) {
+    // TODO tools all modify the same TODO file - must be sequential
+    if (toolName === 'todo-create' ||
+        toolName === 'todo-update' ||
+        toolName === 'todo-add' ||
+        toolName === 'todo-delete') {
+        return 'todo-state';
+    }
+    // Terminal commands must be sequential to avoid race conditions
+    // (e.g., npm install -> npm build, port conflicts, file locks)
+    if (toolName === 'terminal-execute') {
+        return 'terminal-execution';
+    }
+    // Each file is a separate resource
+    if (toolName === 'filesystem-edit' ||
+        toolName === 'filesystem-edit_search' ||
+        toolName === 'filesystem-create' ||
+        toolName === 'filesystem-delete') {
+        return 'filesystem'; // Will be further refined by file path
+    }
+    // Other tools are independent
+    return 'independent';
+}
+/**
+ * Get resource identifier for a tool call
+ * Tools modifying the same resource will have the same identifier
+ */
+function getResourceIdentifier(toolCall) {
+    const toolName = toolCall.function.name;
+    const resourceType = getToolResourceType(toolName);
+    if (resourceType === 'todo-state') {
+        return 'todo-state'; // All TODO operations share same resource
+    }
+    if (resourceType === 'terminal-execution') {
+        return 'terminal-execution'; // All terminal commands share same execution context
+    }
+    if (resourceType === 'filesystem') {
+        try {
+            const args = JSON.parse(toolCall.function.arguments);
+            // Support both single file and array of files
+            const filePath = args.filePath;
+            if (typeof filePath === 'string') {
+                return `filesystem:${filePath}`;
+            }
+            else if (Array.isArray(filePath)) {
+                // For batch operations, treat as independent (already handling multiple files)
+                return `filesystem-batch:${toolCall.id}`;
+            }
+        }
+        catch {
+            // Parsing error, treat as independent
+        }
+    }
+    // Each independent tool gets its own unique identifier
+    return `independent:${toolCall.id}`;
+}
+/**
+ * Execute multiple tool calls with intelligent sequencing
+ * - Tools modifying the same resource execute sequentially
+ * - Independent tools execute in parallel
  */
 export async function executeToolCalls(toolCalls, abortSignal, onTokenUpdate, onSubAgentMessage, requestToolConfirmation, isToolAutoApproved, yoloMode, addToAlwaysApproved) {
-    return Promise.all(toolCalls.map(tc => executeToolCall(tc, abortSignal, onTokenUpdate, onSubAgentMessage, requestToolConfirmation, isToolAutoApproved, yoloMode, addToAlwaysApproved)));
+    // Group tool calls by their resource identifier
+    const resourceGroups = new Map();
+    for (const toolCall of toolCalls) {
+        const resourceId = getResourceIdentifier(toolCall);
+        const group = resourceGroups.get(resourceId) || [];
+        group.push(toolCall);
+        resourceGroups.set(resourceId, group);
+    }
+    // Execute each resource group sequentially, but execute different groups in parallel
+    const results = await Promise.all(Array.from(resourceGroups.values()).map(async (group) => {
+        // Within the same resource group, execute sequentially
+        const groupResults = [];
+        for (const toolCall of group) {
+            const result = await executeToolCall(toolCall, abortSignal, onTokenUpdate, onSubAgentMessage, requestToolConfirmation, isToolAutoApproved, yoloMode, addToAlwaysApproved);
+            groupResults.push(result);
+        }
+        return groupResults;
+    }));
+    // Flatten results and restore original order
+    const flatResults = results.flat();
+    const resultMap = new Map(flatResults.map(r => [r.tool_call_id, r]));
+    return toolCalls.map(tc => {
+        const result = resultMap.get(tc.id);
+        if (!result) {
+            throw new Error(`Result not found for tool call ${tc.id}`);
+        }
+        return result;
+    });
 }

package/package.json

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