snow-ai 0.2.6 → 0.2.7

package/dist/app.js

@@ -51,8 +51,8 @@ export default function App({ version }) {
                 return (React.createElement(WelcomeScreen, { version: version, onMenuSelect: handleMenuSelect }));
         }
     };
-    return (React.createElement(Box, { flexDirection: "column" },
-        renderView(),
-        exitNotification.show && (React.createElement(Box, { paddingX: 1 },
+    return (React.createElement(Box, { flexDirection: "column", height: "100%" },
+        React.createElement(Box, { flexGrow: 1, flexShrink: 1, minHeight: 0 }, renderView()),
+        exitNotification.show && (React.createElement(Box, { paddingX: 1, flexShrink: 0 },
             React.createElement(Alert, { variant: "warning" }, exitNotification.message)))));
 }

package/dist/hooks/useConversation.d.ts

@@ -25,6 +25,7 @@ export type ConversationHandlerOptions = {
     useBasicModel?: boolean;
     getPendingMessages?: () => string[];
     clearPendingMessages?: () => void;
+    setIsStreaming?: React.Dispatch<React.SetStateAction<boolean>>;
 };
 /**
  * Handle conversation with streaming and tool calls

package/dist/hooks/useConversation.js

@@ -223,13 +223,18 @@ export async function handleConversationWithTools(options) {
                     // Use first tool for confirmation UI, but apply result to all
                     const confirmation = await requestToolConfirmation(firstTool, toolNames);
                     if (confirmation === 'reject') {
+                        // Remove pending tool messages
+                        setMessages(prev => prev.filter(msg => !msg.toolPending));
                         // User rejected - end conversation
                         setMessages(prev => [...prev, {
                                 role: 'assistant',
                                 content: 'Tool call rejected, session ended',
                                 streaming: false
                             }]);
-                        // End streaming
+                        // End streaming immediately
+                        if (options.setIsStreaming) {
+                            options.setIsStreaming(false);
+                        }
                         encoder.free();
                         return; // Exit the conversation loop
                     }
@@ -247,8 +252,8 @@ export async function handleConversationWithTools(options) {
                 // Execute approved tools
                 const toolResults = await executeToolCalls(approvedTools);
                 // Check if there are TODO related tool calls, if yes refresh TODO list
-                // Only show TODO panel for todo-get and todo-update, not for todo-create or todo-add
-                const shouldShowTodoPanel = approvedTools.some(t => t.function.name === 'todo-get' || t.function.name === 'todo-update');
+                // Only show TODO panel for todo-update, not for other todo operations
+                const shouldShowTodoPanel = approvedTools.some(t => t.function.name === 'todo-update');
                 const hasTodoTools = approvedTools.some(t => t.function.name.startsWith('todo-'));
                 if (hasTodoTools) {
                     const session = sessionManager.getCurrentSession();
@@ -256,7 +261,7 @@ export async function handleConversationWithTools(options) {
                         const updatedTodoList = await todoService.getTodoList(session.id);
                         if (updatedTodoList) {
                             setCurrentTodos(updatedTodoList.todos);
-                            // Only show TODO panel for get/update operations
+                            // Only show TODO panel for update operations
                             if (shouldShowTodoPanel) {
                                 // Remove any existing TODO tree messages and add a new one
                                 setMessages(prev => {

package/dist/mcp/bash.js

@@ -117,13 +117,13 @@ export const terminalService = new TerminalCommandService();
 export const mcpTools = [
     {
         name: 'terminal_execute',
-        description: 'Run terminal commands. Pass commands exactly as typed in terminal. Examples: "npm -v", "git status", "node index.js"',
+        description: 'Execute terminal commands like npm, git, build scripts, etc. BEST PRACTICE: For file modifications, prefer filesystem_edit/filesystem_create tools first - they are more reliable and provide better error handling. Terminal commands (sed, awk, echo >file, cat <<EOF) can be used for file editing, but only as a fallback option when filesystem tools are not suitable. Primary use cases: (1) Running build/test/lint scripts, (2) Version control operations, (3) Package management, (4) System utilities, (5) Fallback file editing when needed.',
         inputSchema: {
             type: 'object',
             properties: {
                 command: {
                     type: 'string',
-                    description: 'Terminal command to execute. Examples: "npm -v", "git status", "ls -la"'
+                    description: 'Terminal command to execute. For file editing, filesystem tools are generally preferred.'
                 },
                 timeout: {
                     type: 'number',

package/dist/mcp/filesystem.d.ts

@@ -76,21 +76,26 @@ export declare class FilesystemMCPService {
     }>;
     /**
      * Edit a file by replacing lines within a specified range
+     * IMPORTANT: This tool enforces small, precise edits (max 15 lines per edit) to ensure accuracy.
+     * For larger changes, make multiple sequential edits instead of one large edit.
+     *
      * @param filePath - Path to the file to edit
-     * @param startLine - Starting line number (1-indexed, inclusive)
-     * @param endLine - Ending line number (1-indexed, inclusive)
-     * @param newContent - New content to replace the specified lines
-     * @param contextLines - Number of context lines to return before and after the edit (default: 50)
-     * @returns Object containing success message, old content, new content, and context
-     * @throws Error if file editing fails
+     * @param startLine - Starting line number (1-indexed, inclusive) - get from filesystem_read output
+     * @param endLine - Ending line number (1-indexed, inclusive) - get from filesystem_read output
+     * @param newContent - New content to replace the specified lines (WITHOUT line numbers)
+     * @param contextLines - Number of context lines to return before and after the edit (default: 8)
+     * @returns Object containing success message, precise before/after comparison, and diagnostics
+     * @throws Error if file editing fails or if the edit range is too large
      */
     editFile(filePath: string, startLine: number, endLine: number, newContent: string, contextLines?: number): Promise<{
         message: string;
         oldContent: string;
         newContent: string;
+        replacedLines: string;
         contextStartLine: number;
         contextEndLine: number;
         totalLines: number;
+        linesModified: number;
         diagnostics?: Diagnostic[];
     }>;
     /**

package/dist/mcp/filesystem.js

@@ -1,6 +1,7 @@
 import { promises as fs } from 'fs';
 import * as path from 'path';
 import { vscodeConnection } from '../utils/vscodeConnection.js';
+import { incrementalSnapshotManager } from '../utils/incrementalSnapshot.js';
 const { resolve, dirname, isAbsolute } = path;
 /**
  * Filesystem MCP Service
@@ -104,6 +105,8 @@ export class FilesystemMCPService {
                     throw error;
                 }
             }
+            // Backup file before creation
+            await incrementalSnapshotManager.backupFile(fullPath);
             // Create parent directories if needed
             if (createDirectories) {
                 const dir = dirname(fullPath);
@@ -130,6 +133,8 @@ export class FilesystemMCPService {
             if (!stats.isFile()) {
                 throw new Error(`Path is not a file: ${filePath}`);
             }
+            // Backup file before deletion
+            await incrementalSnapshotManager.backupFile(fullPath);
             await fs.unlink(fullPath);
             return `File deleted successfully: ${filePath}`;
         }
@@ -201,15 +206,18 @@ export class FilesystemMCPService {
     }
     /**
      * Edit a file by replacing lines within a specified range
+     * IMPORTANT: This tool enforces small, precise edits (max 15 lines per edit) to ensure accuracy.
+     * For larger changes, make multiple sequential edits instead of one large edit.
+     *
      * @param filePath - Path to the file to edit
-     * @param startLine - Starting line number (1-indexed, inclusive)
-     * @param endLine - Ending line number (1-indexed, inclusive)
-     * @param newContent - New content to replace the specified lines
-     * @param contextLines - Number of context lines to return before and after the edit (default: 50)
-     * @returns Object containing success message, old content, new content, and context
-     * @throws Error if file editing fails
+     * @param startLine - Starting line number (1-indexed, inclusive) - get from filesystem_read output
+     * @param endLine - Ending line number (1-indexed, inclusive) - get from filesystem_read output
+     * @param newContent - New content to replace the specified lines (WITHOUT line numbers)
+     * @param contextLines - Number of context lines to return before and after the edit (default: 8)
+     * @returns Object containing success message, precise before/after comparison, and diagnostics
+     * @throws Error if file editing fails or if the edit range is too large
      */
-    async editFile(filePath, startLine, endLine, newContent, contextLines = 50) {
+    async editFile(filePath, startLine, endLine, newContent, contextLines = 8) {
         try {
             const fullPath = this.resolvePath(filePath);
             // For absolute paths, skip validation to allow access outside base path
@@ -232,12 +240,37 @@ export class FilesystemMCPService {
             }
             // Adjust endLine if it exceeds file length
             const adjustedEndLine = Math.min(endLine, totalLines);
-            // Calculate context range
+            // ENFORCE SMALL EDITS: Limit to max 15 lines per edit for precision
+            const linesToModify = adjustedEndLine - startLine + 1;
+            const MAX_LINES_PER_EDIT = 15;
+            if (linesToModify > MAX_LINES_PER_EDIT) {
+                throw new Error(`❌ Edit range too large (${linesToModify} lines). Maximum allowed: ${MAX_LINES_PER_EDIT} lines.\n\n` +
+                    `💡 Best Practice: Make SMALL, PRECISE edits instead of large changes.\n` +
+                    `   - Break your changes into multiple sequential edits\n` +
+                    `   - Each edit should modify at most ${MAX_LINES_PER_EDIT} lines\n` +
+                    `   - This ensures accuracy and prevents syntax errors\n\n` +
+                    `Current request: lines ${startLine}-${adjustedEndLine} (${linesToModify} lines)\n` +
+                    `Suggested approach: Split into ${Math.ceil(linesToModify / MAX_LINES_PER_EDIT)} smaller edits`);
+            }
+            // Backup file before editing
+            await incrementalSnapshotManager.backupFile(fullPath);
+            // Extract the lines that will be replaced (for comparison)
+            const replacedLines = lines.slice(startLine - 1, adjustedEndLine);
+            const replacedContent = replacedLines.map((line, idx) => {
+                const lineNum = startLine + idx;
+                const paddedNum = String(lineNum).padStart(String(adjustedEndLine).length, ' ');
+                return `${paddedNum}→${line}`;
+            }).join('\n');
+            // Calculate context range (smaller context for focused edits)
             const contextStart = Math.max(1, startLine - contextLines);
-            const contextEnd = Math.min(totalLines, endLine + contextLines);
+            const contextEnd = Math.min(totalLines, adjustedEndLine + contextLines);
             // Extract old content for context (including the lines to be replaced)
             const oldContextLines = lines.slice(contextStart - 1, contextEnd);
-            const oldContent = oldContextLines.join('\n');
+            const oldContent = oldContextLines.map((line, idx) => {
+                const lineNum = contextStart + idx;
+                const paddedNum = String(lineNum).padStart(String(contextEnd).length, ' ');
+                return `${paddedNum}→${line}`;
+            }).join('\n');
             // Replace the specified lines
             const newContentLines = newContent.split('\n');
             const beforeLines = lines.slice(0, startLine - 1);
@@ -247,9 +280,13 @@ export class FilesystemMCPService {
             const newTotalLines = modifiedLines.length;
             const lineDifference = newContentLines.length - (adjustedEndLine - startLine + 1);
             const newContextEnd = Math.min(newTotalLines, contextEnd + lineDifference);
-            // Extract new content for context
+            // Extract new content for context with line numbers
             const newContextLines = modifiedLines.slice(contextStart - 1, newContextEnd);
-            const newContextContent = newContextLines.join('\n');
+            const newContextContent = newContextLines.map((line, idx) => {
+                const lineNum = contextStart + idx;
+                const paddedNum = String(lineNum).padStart(String(newContextEnd).length, ' ');
+                return `${paddedNum}→${line}`;
+            }).join('\n');
             // Write the modified content back to file
             await fs.writeFile(fullPath, modifiedLines.join('\n'), 'utf-8');
             // Try to get diagnostics from VS Code after editing
@@ -263,12 +300,16 @@ export class FilesystemMCPService {
                 // Ignore diagnostics errors, they are optional
             }
             const result = {
-                message: `File edited successfully: ${filePath} (lines ${startLine}-${adjustedEndLine} replaced)`,
+                message: `✅ File edited successfully: ${filePath}\n` +
+                    `   Replaced: lines ${startLine}-${adjustedEndLine} (${linesToModify} lines)\n` +
+                    `   Result: ${newContentLines.length} new lines`,
                 oldContent,
                 newContent: newContextContent,
+                replacedLines: replacedContent,
                 contextStartLine: contextStart,
                 contextEndLine: newContextEnd,
-                totalLines: newTotalLines
+                totalLines: newTotalLines,
+                linesModified: linesToModify
             };
             // Add diagnostics if any were found
             if (diagnostics.length > 0) {
@@ -276,7 +317,8 @@ export class FilesystemMCPService {
                 const errorCount = diagnostics.filter(d => d.severity === 'error').length;
                 const warningCount = diagnostics.filter(d => d.severity === 'warning').length;
                 if (errorCount > 0 || warningCount > 0) {
-                    result.message += `\n\n⚠️  Diagnostics detected: ${errorCount} error(s), ${warningCount} warning(s)`;
+                    result.message += `\n\n⚠️  Diagnostics detected: ${errorCount} error(s), ${warningCount} warning(s)\n` +
+                        `   ⚡ TIP: Check the diagnostics and make another small edit to fix issues`;
                 }
             }
             return result;
@@ -421,7 +463,7 @@ export const mcpTools = [
     },
     {
         name: 'filesystem_create',
-        description: 'Create a new file with specified content',
+        description: 'PREFERRED tool for file creation: Create a new file with specified content. More reliable than terminal commands like echo/cat with redirects. Automatically creates parent directories if needed. Terminal commands can be used as a fallback if needed.',
         inputSchema: {
             type: 'object',
             properties: {
@@ -472,30 +514,30 @@ export const mcpTools = [
     },
     {
         name: 'filesystem_edit',
-        description: 'Edit a file by replacing lines within a specified range. CRITICAL: You MUST use filesystem_read first to see the exact line numbers and current content before editing. This ensures precise line-based editing without errors. Returns context around the edited region for verification.',
+        description: '🎯 PREFERRED tool for precise file editing. **CRITICAL CONSTRAINTS**: (1) Maximum 15 lines per edit - larger changes will be REJECTED, (2) Must use exact line numbers from filesystem_read output. **BEST PRACTICES**: Use SMALL, INCREMENTAL edits instead of large changes. Multiple small edits are SAFER and MORE ACCURATE than one large edit. This prevents syntax errors and bracket mismatches. **WORKFLOW**: (1) Read target section with filesystem_read to get exact line numbers, (2) Edit SMALL sections (≤15 lines), (3) Verify with diagnostics, (4) Make next small edit if needed. Returns precise before/after comparison with line numbers and VS Code diagnostics.',
         inputSchema: {
             type: 'object',
             properties: {
                 filePath: {
                     type: 'string',
-                    description: 'Path to the file to edit'
+                    description: 'Path to the file to edit (absolute or relative)'
                 },
                 startLine: {
                     type: 'number',
-                    description: 'Starting line number (1-indexed, inclusive). Get this from filesystem_read output.'
+                    description: '⚠️  CRITICAL: Starting line number (1-indexed, inclusive). MUST match exact line number from filesystem_read output. Double-check this value!'
                 },
                 endLine: {
                     type: 'number',
-                    description: 'Ending line number (1-indexed, inclusive). Get this from filesystem_read output.'
+                    description: '⚠️  CRITICAL: Ending line number (1-indexed, inclusive). MUST match exact line number from filesystem_read output. Range CANNOT exceed 15 lines (endLine - startLine + 1 ≤ 15).'
                 },
                 newContent: {
                     type: 'string',
-                    description: 'New content to replace the specified lines. Do NOT include line numbers in this content.'
+                    description: 'New content to replace specified lines. ⚠️  Do NOT include line numbers. ⚠️  Ensure proper indentation and bracket closure. Keep changes MINIMAL and FOCUSED.'
                 },
                 contextLines: {
                     type: 'number',
-                    description: 'Number of context lines to return before and after the edit (default: 50)',
-                    default: 50
+                    description: 'Number of context lines to show before/after edit for verification (default: 8)',
+                    default: 8
                 }
             },
             required: ['filePath', 'startLine', 'endLine', 'newContent']

package/dist/mcp/todo.js

@@ -117,7 +117,36 @@ export class TodoService {
         return [
             {
                 name: 'todo-create',
-                description: 'Create a TODO list for current session. CRITICAL FOR PROGRAMMING TASKS: You MUST use this tool at the start of ANY programming task (bug fixes, new features, refactoring, optimization, etc.) to break down the work into trackable steps. This ensures systematic execution and prevents missing critical steps. The TODO list helps maintain context and provides clear progress visibility to the user. WARNING: This tool creates/replaces the entire TODO list for the session - use it ONLY ONCE at the beginning. To add more tasks later, use "todo-add" instead.',
+                description: `Create a TODO list for complex multi-step tasks (optional planning tool).
+
+## 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.
+
+## 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
+
+## 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
+
+## 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).
+
+## 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
+
+## WARNING:
+This REPLACES the entire TODO list. Never use it to "add more tasks" - use "todo-add" instead.`,
                 inputSchema: {
                     type: 'object',
                     properties: {
@@ -128,16 +157,16 @@ export class TodoService {
                                 properties: {
                                     content: {
                                         type: 'string',
-                                        description: 'TODO item description (be specific and actionable)',
+                                        description: 'TODO item description - must be specific, actionable, and technically precise (e.g., "Modify handleSubmit function in ChatInput.tsx to validate user input before processing" NOT "fix input validation")',
                                     },
                                     parentId: {
                                         type: 'string',
-                                        description: 'Parent TODO ID (optional, for creating subtasks)',
+                                        description: 'Parent TODO ID (optional, for creating subtasks in hierarchical structure)',
                                     },
                                 },
                                 required: ['content'],
                             },
-                            description: 'List of TODO items to create. For programming tasks, include steps like: analyze requirements, implement changes, test functionality, verify build, etc. The list can contain multiple tasks that will be tracked and executed sequentially.',
+                            description: 'Complete list of TODO items. Each item must represent a discrete, verifiable unit of work. For programming tasks, typical structure: analyze code → implement changes → test functionality → verify build → commit (if requested).',
                         },
                     },
                     required: ['todos'],
@@ -145,7 +174,15 @@ export class TodoService {
             },
             {
                 name: 'todo-get',
-                description: 'Get the TODO list for current session. Use this to check existing tasks and their status before making updates.',
+                description: `Get the current TODO list for this session.
+
+## WHEN TO USE:
+- Before making any updates to check current task status and IDs
+- To verify what tasks exist before deciding to add/delete/update
+- To inspect the TODO structure before planning next steps
+
+## RETURNS:
+Complete TODO list with all task IDs, content, status, and hierarchy.`,
                 inputSchema: {
                     type: 'object',
                     properties: {},
@@ -153,22 +190,50 @@ export class TodoService {
             },
             {
                 name: 'todo-update',
-                description: 'Update TODO item status or content. IMPORTANT: Mark task as "in_progress" BEFORE starting work, and "completed" IMMEDIATELY after finishing. Keep exactly ONE task in "in_progress" status at any time. This provides real-time progress feedback to the user.',
+                description: `Update TODO status - USE SPARINGLY, focus on actual work instead.
+
+## CORE PRINCIPLE - WORK FIRST, UPDATES SECOND:
+Prioritize COMPLETING TASKS over updating TODO status. Update TODO only at natural breakpoints, not constantly. It's better to finish 3 tasks and update once than to update TODO 10 times while making slow progress.
+
+## WHEN TO UPDATE (Sparingly):
+1. **Starting a major task**: Mark "in_progress" when beginning significant work (not for every micro-step)
+2. **Completing a major task**: Mark "completed" ONLY when task is 100% done and verified
+3. **Natural breakpoints**: When you finish a logical chunk of work
+
+## WHEN NOT TO UPDATE:
+- ❌ Every few minutes during work (you're wasting time on bookkeeping)
+- ❌ Multiple updates for sub-steps of one task (just finish the task first)
+- ❌ Immediately after starting (start working first, update later if it's a long task)
+- ❌ Before verifying the work is actually complete
+
+## SIMPLE RULES:
+- Keep MAXIMUM one task as "in_progress" (don't over-track)
+- Mark "completed" only when 100% done (no partial credit)
+- If you're spending more time updating TODO than working, you're doing it wrong
+
+## HONEST COMPLETION CRITERIA:
+Only mark complete if:
+- Task is 100% finished (no partial work)
+- Tests/builds passed (if applicable)
+- No errors or blockers
+- You've actually verified it works
+
+If blocked, keep as "in_progress" and report the blocker (don't create elaborate sub-TODO structures).`,
                 inputSchema: {
                     type: 'object',
                     properties: {
                         todoId: {
                             type: 'string',
-                            description: 'TODO item ID to update',
+                            description: 'TODO item ID to update (get exact ID from todo-get)',
                         },
                         status: {
                             type: 'string',
                             enum: ['pending', 'in_progress', 'completed'],
-                            description: 'New status: "in_progress" when starting, "completed" when done, "pending" for not started',
+                            description: 'New status - follow strict rules: "in_progress" when starting, "completed" when 100% done and verified, "pending" if not started',
                         },
                         content: {
                             type: 'string',
-                            description: 'Updated TODO content (optional)',
+                            description: 'Updated TODO content (optional, only if task description needs refinement)',
                         },
                     },
                     required: ['todoId'],
@@ -176,17 +241,34 @@ export class TodoService {
             },
             {
                 name: 'todo-add',
-                description: 'Add a new TODO item to current session. Use this when you discover additional steps during execution, or when breaking down complex tasks into smaller subtasks.',
+                description: `Add tasks to existing TODO list (use sparingly).
+
+## CORE PRINCIPLE - AVOID TODO BLOAT:
+Don't constantly add TODO items while working. If you discover small steps during execution, JUST DO THEM instead of creating TODO items. Only add to TODO if it's genuinely complex or user-requested.
+
+## WHEN TO USE (Rare):
+1. **User Adds Requirements**: User explicitly requests additional tasks
+2. **Major Discovery**: You find a significant, complex step that wasn't initially planned
+3. **Blocking Issue**: You discover a prerequisite that requires substantial separate work
+
+## WHEN NOT TO USE (Common):
+- ❌ Discovered a small 5-minute task while working (just do it, don't track it)
+- ❌ Breaking down an existing task into micro-steps (over-planning)
+- ❌ "Organizing" or "clarifying" existing tasks (maintain original structure)
+- ❌ New unrelated requirement (use todo-delete + todo-create instead)
+
+## GUIDELINE:
+If a task takes less than 10 minutes, just do it instead of adding it to TODO. The goal is progress, not perfect tracking.`,
                 inputSchema: {
                     type: 'object',
                     properties: {
                         content: {
                             type: 'string',
-                            description: 'TODO item description (be specific and actionable)',
+                            description: 'TODO item description - must be specific, actionable, and technically precise',
                         },
                         parentId: {
                             type: 'string',
-                            description: 'Parent TODO ID (optional, for creating subtasks)',
+                            description: 'Parent TODO ID to create a subtask (optional). Get valid IDs from todo-get.',
                         },
                     },
                     required: ['content'],
@@ -194,13 +276,33 @@ export class TodoService {
             },
             {
                 name: 'todo-delete',
-                description: 'Delete a TODO item from current session. Use this to remove tasks that are no longer relevant or were created by mistake.',
+                description: `Delete TODO items from the current session.
+
+## WHEN TO USE:
+1. **Task No Longer Needed**: Requirement changed, task became irrelevant
+2. **Mistake Correction**: Task was added by error or duplicated
+3. **Clearing for New Requirement**: User provides COMPLETELY NEW requirement - delete all old todos first, then create new list
+4. **Cascade Deletion**: Delete parent task with subtasks (automatically removes children)
+
+## LIFECYCLE PATTERN FOR NEW REQUIREMENTS:
+When user asks for something completely different:
+1. Use todo-get to see current list
+2. Use todo-delete on root items (children auto-delete via parentId cascade)
+3. Use todo-create for the new requirement
+
+## WHEN NOT TO USE:
+- Do NOT delete completed tasks just for "cleanup" (keep as history)
+- Do NOT delete in-progress tasks unless requirement truly changed
+- Do NOT use for "reorganizing" (maintain original structure)
+
+## CASCADE BEHAVIOR:
+Deleting a parent task automatically deletes all its subtasks (parentId relationship).`,
                 inputSchema: {
                     type: 'object',
                     properties: {
                         todoId: {
                             type: 'string',
-                            description: 'TODO item ID to delete',
+                            description: 'TODO item ID to delete. Deleting a parent will cascade delete all its children. Get exact ID from todo-get.',
                         },
                     },
                     required: ['todoId'],

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

@@ -17,6 +17,7 @@ type Props = {
         inputTokens: number;
         maxContextTokens: number;
     };
+    snapshotFileCount?: Map<number, number>;
 };
-export default function ChatInput({ onSubmit, onCommand, placeholder, disabled, chatHistory, onHistorySelect, yoloMode, contextUsage }: Props): React.JSX.Element;
+export default function ChatInput({ onSubmit, onCommand, placeholder, disabled, chatHistory, onHistorySelect, yoloMode, contextUsage, snapshotFileCount }: Props): React.JSX.Element;
 export {};

package/dist/ui/components/ChatInput.js

@@ -16,7 +16,7 @@ const commands = [
     { name: 'ide', description: 'Connect to VSCode editor and sync context' },
     { name: 'compact', description: 'Compress conversation history using compact model' }
 ];
-export default function ChatInput({ onSubmit, onCommand, placeholder = 'Type your message...', disabled = false, chatHistory = [], onHistorySelect, yoloMode = false, contextUsage }) {
+export default function ChatInput({ onSubmit, onCommand, placeholder = 'Type your message...', disabled = false, chatHistory = [], onHistorySelect, yoloMode = false, contextUsage, snapshotFileCount }) {
     const { stdout } = useStdout();
     const terminalWidth = stdout?.columns || 80;
     const uiOverhead = 8;
@@ -557,10 +557,21 @@ export default function ChatInput({ onSubmit, onCommand, placeholder = 'Type you
                     const userMessages = getUserMessages();
                     const maxHeight = 8;
                     const visibleMessages = userMessages.slice(0, maxHeight);
-                    return visibleMessages.map((message, index) => (React.createElement(Box, { key: message.value },
-                        React.createElement(Text, { color: index === historySelectedIndex ? 'green' : 'white', bold: true },
-                            index === historySelectedIndex ? '➣  ' : '  ',
-                            message.label))));
+                    return visibleMessages.map((message, index) => {
+                        const messageIndex = parseInt(message.value, 10);
+                        const fileCount = snapshotFileCount?.get(messageIndex) || 0;
+                        return (React.createElement(Box, { key: message.value },
+                            React.createElement(Text, { color: index === historySelectedIndex ? 'green' : 'white', bold: true },
+                                index === historySelectedIndex ? '➣  ' : '  ',
+                                message.label),
+                            fileCount > 0 && (React.createElement(Text, { color: "yellow", dimColor: true },
+                                ' ',
+                                "(",
+                                fileCount,
+                                " file",
+                                fileCount > 1 ? 's' : '',
+                                ")"))));
+                    });
                 })(),
                 getUserMessages().length > 8 && (React.createElement(Box, null,
                     React.createElement(Text, { color: "gray", dimColor: true },

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

@@ -0,0 +1,7 @@
+import React from 'react';
+type Props = {
+    fileCount: number;
+    onConfirm: (rollbackFiles: boolean) => void;
+};
+export default function FileRollbackConfirmation({ fileCount, onConfirm }: Props): React.JSX.Element;
+export {};

package/dist/ui/components/FileRollbackConfirmation.js

@@ -0,0 +1,49 @@
+import React, { useState } from 'react';
+import { Box, Text, useInput } from 'ink';
+export default function FileRollbackConfirmation({ fileCount, onConfirm }) {
+    const [selectedIndex, setSelectedIndex] = useState(0);
+    const options = [
+        { label: 'Yes, rollback files and conversation', value: true },
+        { label: 'No, rollback conversation only', value: false }
+    ];
+    useInput((_, key) => {
+        // Up arrow
+        if (key.upArrow) {
+            setSelectedIndex(prev => Math.max(0, prev - 1));
+            return;
+        }
+        // Down arrow
+        if (key.downArrow) {
+            setSelectedIndex(prev => Math.min(options.length - 1, prev + 1));
+            return;
+        }
+        // Enter - confirm selection
+        if (key.return) {
+            onConfirm(options[selectedIndex]?.value ?? false);
+            return;
+        }
+        // ESC - cancel rollback (select "No")
+        if (key.escape) {
+            onConfirm(false);
+            return;
+        }
+    });
+    return (React.createElement(Box, { flexDirection: "column", marginX: 1, marginBottom: 1, borderStyle: "round", borderColor: "yellow", padding: 1 },
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { color: "yellow", bold: true }, "\u26A0  File Rollback Confirmation")),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { color: "white" },
+                "This checkpoint has ",
+                fileCount,
+                " file",
+                fileCount > 1 ? 's' : '',
+                " that will be rolled back.")),
+        React.createElement(Box, { marginBottom: 1 },
+            React.createElement(Text, { color: "gray", dimColor: true }, "Do you want to rollback the files as well?")),
+        React.createElement(Box, { flexDirection: "column" }, options.map((option, index) => (React.createElement(Box, { key: index },
+            React.createElement(Text, { color: index === selectedIndex ? 'green' : 'white', bold: index === selectedIndex },
+                index === selectedIndex ? '➣  ' : '  ',
+                option.label))))),
+        React.createElement(Box, { marginTop: 1 },
+            React.createElement(Text, { color: "gray", dimColor: true }, "Use \u2191\u2193 to select, Enter to confirm, ESC to cancel"))));
+}

package/dist/ui/components/MessageList.js

@@ -6,7 +6,7 @@ const MessageList = memo(({ messages, animationFrame, maxMessages = 6 }) => {
     if (messages.length === 0) {
         return null;
     }
-    return (React.createElement(Box, { marginBottom: 1, flexDirection: "column" }, messages.slice(-maxMessages).map((message, index) => {
+    return (React.createElement(Box, { marginBottom: 1, flexDirection: "column", overflow: "hidden" }, messages.slice(-maxMessages).map((message, index) => {
         const iconColor = message.role === 'user'
             ? 'green'
             : message.role === 'command'

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

@@ -0,0 +1,7 @@
+import React from 'react';
+type Props = {
+    onSelectSession: (sessionId: string) => void;
+    onClose: () => void;
+};
+export default function SessionListPanel({ onSelectSession, onClose }: Props): React.JSX.Element;
+export {};