snow-ai 0.3.29 → 0.3.31

package/dist/api/systemPrompt.js

@@ -72,6 +72,7 @@ const SYSTEM_PROMPT_TEMPLATE = `You are Snow AI CLI, an intelligent command-line
 2. **ACTION FIRST**: Write code immediately when task is clear - stop overthinking
 3. **Smart Context**: Read what's needed for correctness, skip excessive exploration
 4. **Quality Verification**: run build/test after changes
+5. **NO Documentation Files**: ❌ NEVER create summary .md files after tasks - use \`notebook-add\` for important notes instead
 
 ## 🚀 Execution Strategy - BALANCE ACTION & ANALYSIS
 
@@ -166,6 +167,28 @@ const SYSTEM_PROMPT_TEMPLATE = `You are Snow AI CLI, an intelligent command-line
   - Requires IDE plugin installed and running
   - Use AFTER code changes to verify quality
 
+**Notebook (Code Memory):**
+- \`notebook-add\` - Record fragile code that new features might break during iteration
+  - 🎯 Core purpose: Prevent new functionality from breaking old functionality
+  - 📝 Record: Bugs that recurred, fragile dependencies, critical constraints
+  - ⚠️ Examples: "validateInput() must run first - broke twice", "null return required by X"
+  - 📌 **IMPORTANT**: Use notebook for documentation, NOT separate .md files
+- \`notebook-query\` - Manual search (rarely needed, auto-shown when reading files)
+  - 🔍 Auto-attached: Last 10 notebooks appear when reading ANY file
+  - 💡 Use before: Adding features that might affect existing behavior
+- \`notebook-update\` - Update existing note to fix mistakes or refine information
+  - ✏️ Fix errors in previously recorded notes
+  - 📝 Clarify or improve wording after better understanding
+  - 🔄 Update note when code changes but constraint still applies
+- \`notebook-delete\` - Remove outdated or incorrect notes
+  - 🗑️ Delete when code is refactored and note is obsolete
+  - ❌ Remove notes recorded by mistake
+  - 🧹 Clean up after workarounds are properly fixed
+- \`notebook-list\` - View all notes for a specific file
+  - 📋 List all constraints for a file before making changes
+  - 🔍 Find note IDs for update/delete operations
+  - 🧐 Review all warnings before refactoring
+
 **Web Search:**
 - \`websearch-search\` - Search web for latest docs/solutions
 - \`websearch-fetch\` - Read web page content (always provide userQuery)
@@ -178,13 +201,103 @@ manipulation, workflow automation, and complex command chaining to solve sophist
 system administration and data processing challenges.
 
 **Sub-Agent:** 
-*If you don't have a sub-agent tool, ignore this feature*
-- A sub-agent is a separate session isolated from the main session, and a sub-agent may have some of the tools described above to focus on solving a specific problem.
-If you have a sub-agent tool, then you can leave some of the work to the sub-agent to solve.
-For example, if you have a sub-agent of a work plan, you can hand over the work plan to the sub-agent to solve when you receive user requirements. 
-This way, the master agent can focus on task fulfillment.
 
-- The user may set a sub-agent, and there will be the word \`#agent_*\` in the user's message. \`*\` Is a wildcard,is the tool name of the sub-agent, and you must use this sub-agent.
+### 🎯 CRITICAL: AGGRESSIVE DELEGATION TO SUB-AGENTS
+
+**⚡ Core Principle: MAXIMIZE context saving by delegating as much work as possible to sub-agents!**
+
+**🔥 WHY DELEGATE AGGRESSIVELY:**
+- 💾 **Save Main Context** - Each delegated task saves thousands of tokens in the main session
+- 🚀 **Parallel Processing** - Sub-agents work independently without cluttering main context
+- 🎯 **Focused Sessions** - Sub-agents have dedicated context for specific tasks
+- 🔄 **Scalability** - Main agent stays lean and efficient even for complex projects
+
+**📋 DELEGATION STRATEGY - DEFAULT TO SUB-AGENT:**
+
+**✅ ALWAYS DELEGATE (High Priority):**
+- 🔍 **Code Analysis & Planning** - File structure analysis, architecture review, impact analysis
+- 📊 **Research Tasks** - Investigating patterns, finding similar code, exploring codebase
+- 🗺️ **Work Planning** - Breaking down requirements, creating task plans, designing solutions
+- 📝 **Documentation Review** - Reading and summarizing large files, extracting key information
+- 🔎 **Dependency Mapping** - Finding all imports, exports, references across files
+- 🧪 **Test Planning** - Analyzing what needs testing, planning test cases
+- 🔧 **Refactoring Analysis** - Identifying refactoring opportunities, impact assessment
+
+**✅ STRONGLY CONSIDER DELEGATING:**
+- 🐛 **Bug Investigation** - Root cause analysis, reproduction steps, related code search
+- 🔄 **Migration Planning** - Planning API changes, version upgrades, dependency updates
+- 📐 **Design Reviews** - Evaluating architectural decisions, pattern consistency
+- 🔍 **Code Quality Checks** - Finding code smells, inconsistencies, potential issues
+
+**⚠️ KEEP IN MAIN AGENT (Low Volume):**
+- ✏️ **Direct Code Edits** - Simple, well-understood modifications
+- 🔨 **Quick Fixes** - Single-file changes with clear context
+- ⚡ **Immediate Actions** - Terminal commands, file operations
+
+**🎯 DELEGATION WORKFLOW:**
+
+1. **Receive User Request** → Immediately consider: "Can a sub-agent handle the analysis/planning?"
+2. **Complex Task** → Delegate research/planning to sub-agent, wait for result, then execute
+3. **Multi-Step Task** → Delegate planning to sub-agent, receive roadmap, execute in main
+4. **Unfamiliar Code** → Delegate exploration to sub-agent, get summary, then modify
+
+**💡 PRACTICAL EXAMPLES:**
+
+❌ **BAD - Doing everything in main agent:**
+- User: "Add user authentication"
+- Main: *reads 20 files, analyzes auth patterns, plans implementation, writes code*
+- Result: Main context bloated with analysis that won't be reused
+
+✅ **GOOD - Aggressive delegation:**
+- User: "Add user authentication"
+- Main: Delegate to sub-agent → "Analyze current auth patterns and create implementation plan"
+- Sub-agent: *analyzes, returns concise plan*
+- Main: Execute plan with focused context
+- Result: Main context stays lean, only contains execution context
+
+**🔧 USAGE RULES:**
+
+1. **When tool available**: Check if you have \`subagent-agent_*\` tools in your toolkit
+2. **Explicit user request**: User message contains \`#agent_*\` → MUST use that specific sub-agent
+3. **Implicit delegation**: Even without \`#agent_*\`, proactively delegate analysis/planning tasks
+4. **Return focus**: After sub-agent responds, main agent focuses purely on execution
+
+**📌 REMEMBER: If it's not direct code editing or immediate action, consider delegating to sub-agent first!**
+
+**🌲 DECISION TREE - When to Delegate to Sub-Agent:**
+
+\`\`\`
+📥 User Request
+   ↓
+❓ Can a sub-agent handle this task?
+   ├─ ✅ YES → 🚀 DELEGATE to sub-agent
+   │           ├─ Code search/exploration
+   │           ├─ Analysis & planning
+   │           ├─ Research & investigation
+   │           ├─ Architecture review
+   │           ├─ Impact assessment
+   │           ├─ Dependency mapping
+   │           ├─ Documentation review
+   │           ├─ Test planning
+   │           ├─ Bug investigation
+   │           ├─ Pattern finding
+   │           └─ ANY task sub-agent can do
+   │
+   └─ ❌ NO → Execute directly in main agent
+              ├─ Direct code editing (clear target)
+              ├─ File operations (create/delete)
+              ├─ Simple terminal commands
+              └─ Immediate actions (no research needed)
+\`\`\`
+
+**🎯 Golden Rule:**
+**"If sub-agent CAN do it → sub-agent SHOULD do it"**
+
+**Decision in 3 seconds:**
+1. ❓ Does this need research/exploration/planning? → **Delegate**
+2. ❓ Is this a straightforward code edit? → **Execute directly**
+3. ⚠️ **When in doubt** → **Delegate to sub-agent** (safer default)
+
 
 ## 🔍 Quality Assurance
 

package/dist/hooks/useCommandHandler.js

@@ -154,14 +154,9 @@ export function useCommandHandler(options) {
         // Handle /ide command
         if (commandName === 'ide') {
             if (result.success) {
-                // If already connected, set status to connected immediately
-                // Otherwise, set to connecting and wait for VSCode extension
-                if (result.alreadyConnected) {
-                    options.setVscodeConnectionStatus('connected');
-                }
-                else {
-                    options.setVscodeConnectionStatus('connecting');
-                }
+                // Connection successful, set status to connected immediately
+                // The轮询 mechanism will also update the status, but we do it here for immediate feedback
+                options.setVscodeConnectionStatus('connected');
                 // Don't add command message to keep UI clean
             }
             else {

package/dist/hooks/useConversation.js

@@ -692,6 +692,21 @@ export async function handleConversationWithTools(options) {
                 }, requestToolConfirmation, isToolAutoApproved, yoloMode, addToAlwaysApproved);
                 // Check if aborted during tool execution
                 if (controller.signal.aborted) {
+                    // Need to add tool results for all pending tool calls to complete conversation history
+                    // This is critical for sub-agents and any tools that were being executed
+                    if (receivedToolCalls && receivedToolCalls.length > 0) {
+                        for (const toolCall of receivedToolCalls) {
+                            const abortedResult = {
+                                role: 'tool',
+                                tool_call_id: toolCall.id,
+                                content: 'Error: Tool execution aborted by user',
+                            };
+                            conversationMessages.push(abortedResult);
+                            saveMessage(abortedResult).catch(error => {
+                                console.error('Failed to save aborted tool result:', error);
+                            });
+                        }
+                    }
                     freeEncoder();
                     break;
                 }

package/dist/hooks/useVSCodeState.js

@@ -23,7 +23,7 @@ export function useVSCodeState() {
                 lastStatusRef.current = 'disconnected';
                 setVscodeConnectionStatus('disconnected');
             }
-        }, 1000);
+        }, 1000); // Check every second
         const unsubscribe = vscodeConnection.onContextUpdate(context => {
             // Only update state if context has actually changed
             const hasChanged = context.activeFile !== lastEditorContextRef.current.activeFile ||
@@ -51,7 +51,7 @@ export function useVSCodeState() {
         if (vscodeConnectionStatus !== 'connecting') {
             return;
         }
-        // Set timeout for connecting state (30 seconds to allow for IDE plugin reconnection)
+        // Set timeout for connecting state (15 seconds to allow for port scanning and connection)
         const connectingTimeout = setTimeout(() => {
             const isConnected = vscodeConnection.isConnected();
             const isClientRunning = vscodeConnection.isClientRunning();
@@ -65,8 +65,9 @@ export function useVSCodeState() {
                     // Client not running - go back to disconnected
                     setVscodeConnectionStatus('disconnected');
                 }
+                lastStatusRef.current = isClientRunning ? 'error' : 'disconnected';
             }
-        }, 30000); // Increased to 30 seconds
+        }, 15000); // 15 seconds: 10s for connection timeout + 5s buffer
         return () => {
             clearTimeout(connectingTimeout);
         };

package/dist/mcp/filesystem.d.ts

@@ -20,6 +20,12 @@ export declare class FilesystemMCPService {
      * @returns Formatted string with relevant symbol information
      */
     private extractRelevantSymbols;
+    /**
+     * Get notebook entries for a file
+     * @param filePath - Path to the file
+     * @returns Formatted notebook entries string, or empty if none found
+     */
+    private getNotebookEntries;
     /**
      * Get the content of a file with optional line range
      * Enhanced with symbol information for better AI context

package/dist/mcp/filesystem.js

@@ -13,6 +13,8 @@ import { findClosestMatches, generateDiffMessage, } from './utils/filesystem/mat
 import { parseEditBySearchParams, parseEditByLineParams, executeBatchOperation, } from './utils/filesystem/batch-operations.utils.js';
 // ACE Code Search utilities for symbol parsing
 import { parseFileSymbols } from './utils/aceCodeSearch/symbol.utils.js';
+// Notebook utilities for automatic note retrieval
+import { queryNotebook } from '../utils/notebookManager.js';
 const { resolve, dirname, isAbsolute } = path;
 const execAsync = promisify(exec);
 /**
@@ -121,6 +123,37 @@ export class FilesystemMCPService {
             '\n' +
             parts.join('\n\n'));
     }
+    /**
+     * Get notebook entries for a file
+     * @param filePath - Path to the file
+     * @returns Formatted notebook entries string, or empty if none found
+     */
+    getNotebookEntries(filePath) {
+        try {
+            const entries = queryNotebook(filePath, 10);
+            if (entries.length === 0) {
+                return '';
+            }
+            const notesText = entries
+                .map((entry, index) => {
+                // createdAt 已经是本地时间格式: "YYYY-MM-DDTHH:mm:ss.SSS"
+                // 提取日期和时间部分: "YYYY-MM-DD HH:mm"
+                const dateStr = entry.createdAt.substring(0, 16).replace('T', ' ');
+                return `  ${index + 1}. [${dateStr}] ${entry.note}`;
+            })
+                .join('\n');
+            return ('\n\n' +
+                '='.repeat(60) +
+                '\n📝 CODE NOTEBOOKS (Latest 10):\n' +
+                '='.repeat(60) +
+                '\n' +
+                notesText);
+        }
+        catch {
+            // Silently fail notebook retrieval - don't block file reading
+            return '';
+        }
+    }
     /**
      * Get the content of a file with optional line range
      * Enhanced with symbol information for better AI context
@@ -209,6 +242,11 @@ export class FilesystemMCPService {
                         catch {
                             // Silently fail symbol parsing
                         }
+                        // Append notebook entries
+                        const notebookInfo = this.getNotebookEntries(file);
+                        if (notebookInfo) {
+                            fileContent += notebookInfo;
+                        }
                         allContents.push(fileContent);
                         filesData.push({
                             path: file,
@@ -291,6 +329,11 @@ export class FilesystemMCPService {
                 // Silently fail symbol parsing - don't block file reading
                 // This is optional context enhancement, not critical
             }
+            // Append notebook entries
+            const notebookInfo = this.getNotebookEntries(filePath);
+            if (notebookInfo) {
+                partialContent += notebookInfo;
+            }
             return {
                 content: partialContent,
                 startLine: start,

package/dist/mcp/notebook.d.ts

@@ -0,0 +1,10 @@
+import { Tool, type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+/**
+ * Notebook MCP 工具定义
+ * 用于代码备忘录管理，帮助AI记录重要的代码注意事项
+ */
+export declare const mcpTools: Tool[];
+/**
+ * 执行 Notebook 工具
+ */
+export declare function executeNotebookTool(toolName: string, args: any): Promise<CallToolResult>;

package/dist/mcp/notebook.js

@@ -0,0 +1,367 @@
+import { addNotebook, queryNotebook, updateNotebook, deleteNotebook, getNotebooksByFile, } from '../utils/notebookManager.js';
+/**
+ * Notebook MCP 工具定义
+ * 用于代码备忘录管理，帮助AI记录重要的代码注意事项
+ */
+export const mcpTools = [
+    {
+        name: 'notebook-add',
+        description: `📝 Record code parts that are fragile and easily broken during iteration.
+
+**Core Purpose:** Prevent new features from breaking existing functionality.
+
+**When to record:**
+- After fixing bugs that could easily reoccur
+- Fragile code that new features might break
+- Non-obvious dependencies between components
+- Workarounds that shouldn't be "optimized away"
+
+**Examples:**
+- "⚠️ validateInput() MUST be called first - new features broke this twice"
+- "Component X depends on null return - DO NOT change to empty array"
+- "setTimeout workaround for race condition - don't remove"
+- "Parser expects exact format - adding fields breaks backward compat"`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                filePath: {
+                    type: 'string',
+                    description: 'File path (relative or absolute). Example: "src/utils/parser.ts"',
+                },
+                note: {
+                    type: 'string',
+                    description: 'Brief, specific note. Focus on risks/constraints, NOT what code does.',
+                },
+            },
+            required: ['filePath', 'note'],
+        },
+    },
+    {
+        name: 'notebook-query',
+        description: `🔍 Search notebook entries by file path pattern.
+
+**Auto-triggered:** When reading files, last 10 notebooks are automatically shown.
+**Manual use:** Query specific patterns or see more entries.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                filePathPattern: {
+                    type: 'string',
+                    description: 'Fuzzy search pattern (e.g., "parser"). Empty = all entries.',
+                    default: '',
+                },
+                topN: {
+                    type: 'number',
+                    description: 'Max results to return (default: 10, max: 50)',
+                    default: 10,
+                    minimum: 1,
+                    maximum: 50,
+                },
+            },
+        },
+    },
+    {
+        name: 'notebook-update',
+        description: `✏️ Update an existing notebook entry to fix mistakes or refine notes.
+
+**Core Purpose:** Correct errors in previously recorded notes or update outdated information.
+
+**When to use:**
+- Found a mistake in a previously recorded note
+- Need to clarify or improve the wording
+- Update note after code changes
+- Refine warning messages for better clarity
+
+**Usage:**
+1. Use notebook-query or notebook-list to find the entry ID
+2. Call notebook-update with the ID and new note content
+
+**Example:**
+- Old: "⚠️ Don't change this"
+- New: "⚠️ validateInput() MUST be called first - parser depends on sanitized input"`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                notebookId: {
+                    type: 'string',
+                    description: 'Notebook entry ID to update (get from notebook-query or notebook-list)',
+                },
+                note: {
+                    type: 'string',
+                    description: 'New note content to replace the existing one',
+                },
+            },
+            required: ['notebookId', 'note'],
+        },
+    },
+    {
+        name: 'notebook-delete',
+        description: `🗑️ Delete an outdated or incorrect notebook entry.
+
+**Core Purpose:** Remove notes that are no longer relevant or were recorded by mistake.
+
+**When to use:**
+- Code has been refactored and note is obsolete
+- Note was recorded by mistake
+- Workaround has been properly fixed
+- Entry is duplicate or redundant
+
+**Usage:**
+1. Use notebook-query or notebook-list to find the entry ID
+2. Call notebook-delete with the ID to remove it
+
+**⚠️ Warning:** Deletion is permanent. Make sure the note is truly obsolete.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                notebookId: {
+                    type: 'string',
+                    description: 'Notebook entry ID to delete (get from notebook-query)',
+                },
+            },
+            required: ['notebookId'],
+        },
+    },
+    {
+        name: 'notebook-list',
+        description: `📋 List all notebook entries for a specific file.
+
+**Core Purpose:** View all notes associated with a particular file for management.
+
+**When to use:**
+- Need to see all notes for a file before editing
+- Want to clean up old notes for a specific file
+- Review constraints before making changes to a file
+
+**Returns:** All notebook entries for the specified file, ordered by creation time.`,
+        inputSchema: {
+            type: 'object',
+            properties: {
+                filePath: {
+                    type: 'string',
+                    description: 'File path (relative or absolute) to list notebooks for',
+                },
+            },
+            required: ['filePath'],
+        },
+    },
+];
+/**
+ * 执行 Notebook 工具
+ */
+export async function executeNotebookTool(toolName, args) {
+    try {
+        switch (toolName) {
+            case 'notebook-add': {
+                const { filePath, note } = args;
+                if (!filePath || !note) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'Error: Both filePath and note are required',
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const entry = addNotebook(filePath, note);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Notebook entry added for: ${entry.filePath}`,
+                                entry: {
+                                    id: entry.id,
+                                    filePath: entry.filePath,
+                                    note: entry.note,
+                                    createdAt: entry.createdAt,
+                                },
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'notebook-query': {
+                const { filePathPattern = '', topN = 10 } = args;
+                const results = queryNotebook(filePathPattern, topN);
+                if (results.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    message: 'No notebook entries found',
+                                    pattern: filePathPattern || '(all)',
+                                    totalResults: 0,
+                                }, null, 2),
+                            },
+                        ],
+                    };
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                message: `Found ${results.length} notebook entries`,
+                                pattern: filePathPattern || '(all)',
+                                totalResults: results.length,
+                                entries: results.map(entry => ({
+                                    id: entry.id,
+                                    filePath: entry.filePath,
+                                    note: entry.note,
+                                    createdAt: entry.createdAt,
+                                })),
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'notebook-update': {
+                const { notebookId, note } = args;
+                if (!notebookId || !note) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'Error: Both notebookId and note are required',
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const updatedEntry = updateNotebook(notebookId, note);
+                if (!updatedEntry) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: false,
+                                    message: `Notebook entry not found: ${notebookId}`,
+                                }, null, 2),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Notebook entry updated: ${notebookId}`,
+                                entry: {
+                                    id: updatedEntry.id,
+                                    filePath: updatedEntry.filePath,
+                                    note: updatedEntry.note,
+                                    updatedAt: updatedEntry.updatedAt,
+                                },
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'notebook-delete': {
+                const { notebookId } = args;
+                if (!notebookId) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'Error: notebookId is required',
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const deleted = deleteNotebook(notebookId);
+                if (!deleted) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: JSON.stringify({
+                                    success: false,
+                                    message: `Notebook entry not found: ${notebookId}`,
+                                }, null, 2),
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                success: true,
+                                message: `Notebook entry deleted: ${notebookId}`,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'notebook-list': {
+                const { filePath } = args;
+                if (!filePath) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: 'Error: filePath is required',
+                            },
+                        ],
+                        isError: true,
+                    };
+                }
+                const entries = getNotebooksByFile(filePath);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                message: entries.length > 0
+                                    ? `Found ${entries.length} notebook entries for: ${filePath}`
+                                    : `No notebook entries found for: ${filePath}`,
+                                filePath,
+                                totalEntries: entries.length,
+                                entries: entries.map(entry => ({
+                                    id: entry.id,
+                                    note: entry.note,
+                                    createdAt: entry.createdAt,
+                                    updatedAt: entry.updatedAt,
+                                })),
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            default:
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Unknown notebook tool: ${toolName}`,
+                        },
+                    ],
+                    isError: true,
+                };
+        }
+    }
+    catch (error) {
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `Error executing notebook tool: ${error instanceof Error ? error.message : String(error)}`,
+                },
+            ],
+            isError: true,
+        };
+    }
+}

package/dist/utils/commands/ide.js

@@ -7,6 +7,8 @@ registerCommand('ide', {
         if (vscodeConnection.isConnected()) {
             vscodeConnection.stop();
             vscodeConnection.resetReconnectAttempts();
+            // Wait a bit for cleanup to complete
+            await new Promise(resolve => setTimeout(resolve, 100));
         }
         // Try to connect to IDE plugin server
         try {

package/dist/utils/mcpToolsManager.js

@@ -9,6 +9,7 @@ import { mcpTools as aceCodeSearchTools } from '../mcp/aceCodeSearch.js';
 import { mcpTools as websearchTools } from '../mcp/websearch.js';
 import { mcpTools as ideDiagnosticsTools } from '../mcp/ideDiagnostics.js';
 import { TodoService } from '../mcp/todo.js';
+import { mcpTools as notebookTools, executeNotebookTool, } from '../mcp/notebook.js';
 import { getMCPTools as getSubAgentTools, subAgentService, } from '../mcp/subagent.js';
 import { sessionManager } from './sessionManager.js';
 import { logger } from './logger.js';
@@ -139,6 +140,28 @@ async function refreshToolsCache() {
             },
         });
     }
+    // Add built-in Notebook tools (always available)
+    const notebookServiceTools = notebookTools.map(tool => ({
+        name: tool.name.replace('notebook-', ''),
+        description: tool.description || '',
+        inputSchema: tool.inputSchema,
+    }));
+    servicesInfo.push({
+        serviceName: 'notebook',
+        tools: notebookServiceTools,
+        isBuiltIn: true,
+        connected: true,
+    });
+    for (const tool of notebookTools) {
+        allTools.push({
+            type: 'function',
+            function: {
+                name: tool.name,
+                description: tool.description || '',
+                parameters: tool.inputSchema,
+            },
+        });
+    }
     // Add built-in ACE Code Search tools (always available)
     const aceServiceTools = aceCodeSearchTools.map(tool => ({
         name: tool.name.replace('ace-', ''),
@@ -556,6 +579,10 @@ export async function executeMCPTool(toolName, args, abortSignal, onTokenUpdate)
         serviceName = 'todo';
         actualToolName = toolName.substring('todo-'.length);
     }
+    else if (toolName.startsWith('notebook-')) {
+        serviceName = 'notebook';
+        actualToolName = toolName.substring('notebook-'.length);
+    }
     else if (toolName.startsWith('filesystem-')) {
         serviceName = 'filesystem';
         actualToolName = toolName.substring('filesystem-'.length);
@@ -604,6 +631,10 @@ export async function executeMCPTool(toolName, args, abortSignal, onTokenUpdate)
         // Handle built-in TODO tools (no connection needed)
         return await todoService.executeTool(actualToolName, args);
     }
+    else if (serviceName === 'notebook') {
+        // Handle built-in Notebook tools (no connection needed)
+        return await executeNotebookTool(toolName, args);
+    }
     else if (serviceName === 'filesystem') {
         // Handle built-in filesystem tools (no connection needed)
         const { filesystemService } = await import('../mcp/filesystem.js');

package/dist/utils/notebookManager.d.ts

@@ -0,0 +1,59 @@
+/**
+ * 备忘录条目接口
+ */
+export interface NotebookEntry {
+    id: string;
+    filePath: string;
+    note: string;
+    createdAt: string;
+    updatedAt: string;
+}
+/**
+ * 添加备忘录
+ * @param filePath 文件路径
+ * @param note 备忘说明
+ * @returns 添加的备忘录条目
+ */
+export declare function addNotebook(filePath: string, note: string): NotebookEntry;
+/**
+ * 查询备忘录
+ * @param filePathPattern 文件路径（支持模糊匹配）
+ * @param topN 返回最新的N条记录（默认10）
+ * @returns 匹配的备忘录条目列表
+ */
+export declare function queryNotebook(filePathPattern?: string, topN?: number): NotebookEntry[];
+/**
+ * 获取指定文件的所有备忘录
+ * @param filePath 文件路径
+ * @returns 该文件的所有备忘录
+ */
+export declare function getNotebooksByFile(filePath: string): NotebookEntry[];
+/**
+ * 更新备忘录内容
+ * @param notebookId 备忘录ID
+ * @param newNote 新的备忘说明
+ * @returns 更新后的备忘录条目，如果未找到则返回null
+ */
+export declare function updateNotebook(notebookId: string, newNote: string): NotebookEntry | null;
+/**
+ * 删除备忘录
+ * @param notebookId 备忘录ID
+ * @returns 是否删除成功
+ */
+export declare function deleteNotebook(notebookId: string): boolean;
+/**
+ * 清空指定文件的所有备忘录
+ * @param filePath 文件路径
+ */
+export declare function clearNotebooksByFile(filePath: string): void;
+/**
+ * 获取所有备忘录统计信息
+ */
+export declare function getNotebookStats(): {
+    totalFiles: number;
+    totalEntries: number;
+    files: Array<{
+        path: string;
+        count: number;
+    }>;
+};

package/dist/utils/notebookManager.js

@@ -0,0 +1,206 @@
+import * as fs from 'fs';
+import * as path from 'path';
+const MAX_ENTRIES_PER_FILE = 50;
+/**
+ * 获取备忘录存储目录
+ */
+function getNotebookDir() {
+    const projectRoot = process.cwd();
+    const notebookDir = path.join(projectRoot, '.snow', 'notebook');
+    if (!fs.existsSync(notebookDir)) {
+        fs.mkdirSync(notebookDir, { recursive: true });
+    }
+    return notebookDir;
+}
+/**
+ * 获取当前项目的备忘录文件路径
+ */
+function getNotebookFilePath() {
+    const projectRoot = process.cwd();
+    const projectName = path.basename(projectRoot);
+    const notebookDir = getNotebookDir();
+    return path.join(notebookDir, `${projectName}.json`);
+}
+/**
+ * 读取备忘录数据
+ */
+function readNotebookData() {
+    const filePath = getNotebookFilePath();
+    if (!fs.existsSync(filePath)) {
+        return {};
+    }
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        console.error('Failed to read notebook data:', error);
+        return {};
+    }
+}
+/**
+ * 保存备忘录数据
+ */
+function saveNotebookData(data) {
+    const filePath = getNotebookFilePath();
+    try {
+        fs.writeFileSync(filePath, JSON.stringify(data, null, 2), 'utf-8');
+    }
+    catch (error) {
+        console.error('Failed to save notebook data:', error);
+        throw error;
+    }
+}
+/**
+ * 规范化文件路径（转换为相对于项目根目录的路径）
+ */
+function normalizePath(filePath) {
+    const projectRoot = process.cwd();
+    // 如果是绝对路径，转换为相对路径
+    if (path.isAbsolute(filePath)) {
+        return path.relative(projectRoot, filePath).replace(/\\/g, '/');
+    }
+    // 已经是相对路径，规范化斜杠
+    return filePath.replace(/\\/g, '/');
+}
+/**
+ * 添加备忘录
+ * @param filePath 文件路径
+ * @param note 备忘说明
+ * @returns 添加的备忘录条目
+ */
+export function addNotebook(filePath, note) {
+    const normalizedPath = normalizePath(filePath);
+    const data = readNotebookData();
+    if (!data[normalizedPath]) {
+        data[normalizedPath] = [];
+    }
+    // 创建新的备忘录条目（使用本地时间）
+    const now = new Date();
+    const localTimeStr = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}T${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}:${String(now.getSeconds()).padStart(2, '0')}.${String(now.getMilliseconds()).padStart(3, '0')}`;
+    const entry = {
+        id: `notebook-${Date.now()}_${Math.random().toString(36).substr(2, 9)}`,
+        filePath: normalizedPath,
+        note,
+        createdAt: localTimeStr,
+        updatedAt: localTimeStr,
+    };
+    // 添加到数组开头（最新的在前面）
+    data[normalizedPath].unshift(entry);
+    // 限制每个文件最多50条备忘录
+    if (data[normalizedPath].length > MAX_ENTRIES_PER_FILE) {
+        data[normalizedPath] = data[normalizedPath].slice(0, MAX_ENTRIES_PER_FILE);
+    }
+    saveNotebookData(data);
+    return entry;
+}
+/**
+ * 查询备忘录
+ * @param filePathPattern 文件路径（支持模糊匹配）
+ * @param topN 返回最新的N条记录（默认10）
+ * @returns 匹配的备忘录条目列表
+ */
+export function queryNotebook(filePathPattern = '', topN = 10) {
+    const data = readNotebookData();
+    const results = [];
+    // 规范化搜索模式
+    const normalizedPattern = filePathPattern.toLowerCase().replace(/\\/g, '/');
+    // 遍历所有文件路径
+    for (const [filePath, entries] of Object.entries(data)) {
+        // 如果没有指定模式，或者文件路径包含模式
+        if (!normalizedPattern ||
+            filePath.toLowerCase().includes(normalizedPattern)) {
+            results.push(...entries);
+        }
+    }
+    // 按创建时间倒序排序（最新的在前）
+    results.sort((a, b) => {
+        return new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime();
+    });
+    // 返回 TopN 条记录
+    return results.slice(0, topN);
+}
+/**
+ * 获取指定文件的所有备忘录
+ * @param filePath 文件路径
+ * @returns 该文件的所有备忘录
+ */
+export function getNotebooksByFile(filePath) {
+    const normalizedPath = normalizePath(filePath);
+    const data = readNotebookData();
+    return data[normalizedPath] || [];
+}
+/**
+ * 更新备忘录内容
+ * @param notebookId 备忘录ID
+ * @param newNote 新的备忘说明
+ * @returns 更新后的备忘录条目，如果未找到则返回null
+ */
+export function updateNotebook(notebookId, newNote) {
+    const data = readNotebookData();
+    let updatedEntry = null;
+    for (const [, entries] of Object.entries(data)) {
+        const entry = entries.find(e => e.id === notebookId);
+        if (entry) {
+            // 更新笔记内容和更新时间
+            entry.note = newNote;
+            const now = new Date();
+            entry.updatedAt = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}-${String(now.getDate()).padStart(2, '0')}T${String(now.getHours()).padStart(2, '0')}:${String(now.getMinutes()).padStart(2, '0')}:${String(now.getSeconds()).padStart(2, '0')}.${String(now.getMilliseconds()).padStart(3, '0')}`;
+            updatedEntry = entry;
+            break;
+        }
+    }
+    if (updatedEntry) {
+        saveNotebookData(data);
+    }
+    return updatedEntry;
+}
+/**
+ * 删除备忘录
+ * @param notebookId 备忘录ID
+ * @returns 是否删除成功
+ */
+export function deleteNotebook(notebookId) {
+    const data = readNotebookData();
+    let found = false;
+    for (const [, entries] of Object.entries(data)) {
+        const index = entries.findIndex(entry => entry.id === notebookId);
+        if (index !== -1) {
+            entries.splice(index, 1);
+            found = true;
+            break;
+        }
+    }
+    if (found) {
+        saveNotebookData(data);
+    }
+    return found;
+}
+/**
+ * 清空指定文件的所有备忘录
+ * @param filePath 文件路径
+ */
+export function clearNotebooksByFile(filePath) {
+    const normalizedPath = normalizePath(filePath);
+    const data = readNotebookData();
+    if (data[normalizedPath]) {
+        delete data[normalizedPath];
+        saveNotebookData(data);
+    }
+}
+/**
+ * 获取所有备忘录统计信息
+ */
+export function getNotebookStats() {
+    const data = readNotebookData();
+    const files = Object.entries(data).map(([path, entries]) => ({
+        path,
+        count: entries.length,
+    }));
+    const totalEntries = files.reduce((sum, file) => sum + file.count, 0);
+    return {
+        totalFiles: files.length,
+        totalEntries,
+        files: files.sort((a, b) => b.count - a.count),
+    };
+}

package/dist/utils/subAgentExecutor.js

@@ -70,8 +70,19 @@ export async function executeSubAgent(agentId, prompt, onMessage, abortSignal, r
         const sessionApprovedTools = new Set();
         // eslint-disable-next-line no-constant-condition
         while (true) {
-            // Check abort signal
+            // Check abort signal before streaming
             if (abortSignal?.aborted) {
+                // Send done message to mark completion (like normal tool abort)
+                if (onMessage) {
+                    onMessage({
+                        type: 'sub_agent_message',
+                        agentId: agent.id,
+                        agentName: agent.name,
+                        message: {
+                            type: 'done',
+                        },
+                    });
+                }
                 return {
                     success: false,
                     result: finalResponse,
@@ -200,6 +211,17 @@ export async function executeSubAgent(agentId, prompt, onMessage, abortSignal, r
             }
             // Handle rejected tools
             if (rejectedToolCalls.length > 0) {
+                // Send done message to mark completion when tools are rejected
+                if (onMessage) {
+                    onMessage({
+                        type: 'sub_agent_message',
+                        agentId: agent.id,
+                        agentName: agent.name,
+                        message: {
+                            type: 'done',
+                        },
+                    });
+                }
                 return {
                     success: false,
                     result: finalResponse,
@@ -211,6 +233,25 @@ export async function executeSubAgent(agentId, prompt, onMessage, abortSignal, r
             // Execute approved tool calls
             const toolResults = [];
             for (const toolCall of approvedToolCalls) {
+                // Check abort signal before executing each tool
+                if (abortSignal?.aborted) {
+                    // Send done message to mark completion
+                    if (onMessage) {
+                        onMessage({
+                            type: 'sub_agent_message',
+                            agentId: agent.id,
+                            agentName: agent.name,
+                            message: {
+                                type: 'done',
+                            },
+                        });
+                    }
+                    return {
+                        success: false,
+                        result: finalResponse,
+                        error: 'Sub-agent execution aborted during tool execution',
+                    };
+                }
                 try {
                     const args = JSON.parse(toolCall.function.arguments);
                     const result = await executeMCPTool(toolCall.function.name, args, abortSignal);

package/dist/utils/vscodeConnection.js

@@ -122,12 +122,20 @@ class VSCodeConnectionManager {
         const targetPort = this.findPortForWorkspace();
         // Create a new connection promise and store it
         this.connectingPromise = new Promise((resolve, reject) => {
+            let isSettled = false; // Prevent double resolve/reject
             // Set connection timeout
             this.connectionTimeout = setTimeout(() => {
-                this.cleanupConnection();
-                reject(new Error('Connection timeout after 10 seconds'));
+                if (!isSettled) {
+                    isSettled = true;
+                    this.cleanupConnection();
+                    reject(new Error('Connection timeout after 10 seconds'));
+                }
             }, this.CONNECTION_TIMEOUT);
             const tryConnect = (port) => {
+                // If already settled (resolved or rejected), stop trying
+                if (isSettled) {
+                    return;
+                }
                 // Check both VSCode and JetBrains port ranges
                 if (port > this.VSCODE_MAX_PORT && port < this.JETBRAINS_BASE_PORT) {
                     // Jump from VSCode range to JetBrains range
@@ -135,23 +143,29 @@ class VSCodeConnectionManager {
                     return;
                 }
                 if (port > this.JETBRAINS_MAX_PORT) {
-                    this.cleanupConnection();
-                    reject(new Error(`Failed to connect: no IDE server found on ports ${this.VSCODE_BASE_PORT}-${this.VSCODE_MAX_PORT} or ${this.JETBRAINS_BASE_PORT}-${this.JETBRAINS_MAX_PORT}`));
+                    if (!isSettled) {
+                        isSettled = true;
+                        this.cleanupConnection();
+                        reject(new Error(`Failed to connect: no IDE server found on ports ${this.VSCODE_BASE_PORT}-${this.VSCODE_MAX_PORT} or ${this.JETBRAINS_BASE_PORT}-${this.JETBRAINS_MAX_PORT}`));
+                    }
                     return;
                 }
                 try {
                     this.client = new WebSocket(`ws://localhost:${port}`);
                     this.client.on('open', () => {
-                        // Reset reconnect attempts on successful connection
-                        this.reconnectAttempts = 0;
-                        this.port = port;
-                        // Clear connection state
-                        if (this.connectionTimeout) {
-                            clearTimeout(this.connectionTimeout);
-                            this.connectionTimeout = null;
+                        if (!isSettled) {
+                            isSettled = true;
+                            // Reset reconnect attempts on successful connection
+                            this.reconnectAttempts = 0;
+                            this.port = port;
+                            // Clear connection state
+                            if (this.connectionTimeout) {
+                                clearTimeout(this.connectionTimeout);
+                                this.connectionTimeout = null;
+                            }
+                            this.connectingPromise = null;
+                            resolve();
                         }
-                        this.connectingPromise = null;
-                        resolve();
                     });
                     this.client.on('message', message => {
                         try {
@@ -167,19 +181,25 @@ class VSCodeConnectionManager {
                     });
                     this.client.on('close', () => {
                         this.client = null;
-                        this.scheduleReconnect();
+                        // Only schedule reconnect if this was an established connection (not initial scan)
+                        if (this.reconnectAttempts > 0 || isSettled) {
+                            this.scheduleReconnect();
+                        }
                     });
                     this.client.on('error', _error => {
                         // On initial connection, try next port
-                        if (this.reconnectAttempts === 0) {
+                        if (this.reconnectAttempts === 0 && !isSettled) {
                             this.client = null;
-                            tryConnect(port + 1);
+                            // Small delay before trying next port to avoid rapid fire
+                            setTimeout(() => tryConnect(port + 1), 50);
                         }
                         // For reconnections, silently handle and let close event trigger reconnect
                     });
                 }
                 catch (error) {
-                    tryConnect(port + 1);
+                    if (!isSettled) {
+                        setTimeout(() => tryConnect(port + 1), 50);
+                    }
                 }
             };
             tryConnect(targetPort);
@@ -297,7 +317,7 @@ class VSCodeConnectionManager {
             clearTimeout(this.connectionTimeout);
             this.connectionTimeout = null;
         }
-        // Clear connecting promise
+        // Clear connecting promise - this is critical for restart
         this.connectingPromise = null;
         if (this.client) {
             try {

package/package.json

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