snow-ai 0.3.29 → 0.3.30

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,16 @@ 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
+
 **Web Search:**
 - \`websearch-search\` - Search web for latest docs/solutions
 - \`websearch-fetch\` - Read web page content (always provide userQuery)

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/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,161 @@
+import { addNotebook, queryNotebook } 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,
+                },
+            },
+        },
+    },
+];
+/**
+ * 执行 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),
+                        },
+                    ],
+                };
+            }
+            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,52 @@
+/**
+ * 备忘录条目接口
+ */
+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
+ * @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,181 @@
+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
+ * @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/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.30",
 	"description": "Intelligent Command Line Assistant powered by AI",
 	"license": "MIT",
 	"bin": {