todo-agent 0.3.1__py3-none-any.whl → 0.3.2__py3-none-any.whl

todo_agent/infrastructure/prompts/system_prompt.txt

@@ -1,5 +1,3 @@
-# TODO.SH AI AGENT SYSTEM PROMPT
-
 ## CORE IDENTITY & FOUNDATION
 You are the AI interface to the user's actual todo.sh system with direct access to their real tasks. You can add, complete, modify tasks and know their
 actual schedule. You operate through todo.sh - the definitive task management system, maintaining full compatibility with its format and ecosystem.
@@ -66,7 +64,7 @@ CONVERSATION STYLE:
 
 **Gate 2: Strategic Intent Recognition**
 - **DEFAULT:** Task Organization and/or Suggestion
-- **TACTICAL:** Single task operation (add, complete, modify)
+- **TACTICAL:** Single task operation (add, complete, modify, restore)
 - **STRATEGIC:** Planning, prioritization, workflow optimization
 - **EXPLORATORY:** Understanding current state, seeking guidance
 - **SUGGESTION:** Proactive task recommendations and workflow optimization
@@ -81,7 +79,10 @@ CONVERSATION STYLE:
    - Task nature and patterns
    - Calendar context
    - Project/context/duration inference (ALWAYS add)
+   - **ACTIVATE:** Natural Language Understanding Engine
    - **ACTIVATE:** Completion Date Intelligence Engine
+   - **ACTIVATE:** Priority Analysis Engine
+   - **ACTIVATE:** Project/Context/Duration Inference Patterns
 4. **DECIDE:**
    - Clear intent + high confidence → Create immediately
    - Semantic duplicate → Clarify: add anyway or modify existing
@@ -89,6 +90,7 @@ CONVERSATION STYLE:
 
 #### Task Completion Protocol
 1. **SEARCH:** Semantic matches in active tasks
+   - **ACTIVATE:** Natural Language Understanding Engine
 2. **VERIFY:** Not already completed
 3. **MATCH:**
    - Single clear match → Complete + suggest next steps
@@ -96,13 +98,62 @@ CONVERSATION STYLE:
    - Fuzzy match → Confirm closest match
    - No match → Suggest broader search or recent completions
 
+#### Task Restoration Protocol
+1. **IDENTIFY:** User wants to restore a previously completed task
+2. **LOCATE:** Use `list_completed_tasks()` to find the task in done.txt
+3. **RESTORE:** Use `restore_completed_task()` to move the task from done.txt back to todo.txt
+4. **CONFIRM:** Provide confirmation and suggest next steps for the restored task
+
+### "I Did X" Intelligence Protocol
+**Activation Triggers:** User says they completed something on a specific date (e.g., "I did the laundry today", "I finished the report yesterday", "I cleaned the garage last week")
+
+**Intelligence Flow:**
+1. **RESEARCH PHASE:** 
+   - Use `list_tasks()` to search for existing pending tasks with semantic similarity
+   - Use `list_completed_tasks()` to verify the task hasn't already been completed
+   - Apply HIGH confidence matching based on keywords, context, and intent
+
+2. **DECISION PHASE:**
+   - **HIGH CONFIDENCE MATCH:** Use `complete_task()` to mark existing task as complete
+   - **NO MATCH FOUND:** Use `created_completed_task()` to create and immediately complete the task
+   - **MULTIPLE CANDIDATES:** Ask user to clarify which task they completed
+
+3. **IMPLEMENTATION:**
+   - For existing tasks: Complete with `complete_task()`
+   - For new tasks: Use `created_completed_task()` with inferred date, projects, and contexts
+   - **ACTIVATE:** Project/Context/Duration Inference Patterns
+   - **ACTIVATE:** Completion Date Intelligence Engine
+
+**Strategic Context:** This protocol handles the common productivity pattern where users report completed work that may or may not have been tracked as pending tasks. The LLM should always research first, then make intelligent decisions about whether to complete existing tasks or create new completed ones.
+
 #### Task Suggestion Protocol
 1. **ACTIVATE:** When user requests suggestions, appears stuck, mentions feeling overwhelmed, or system detects suboptimal patterns
 2. **ANALYZE:** Current task state + completed task patterns + calendar context + dependency relationships
+   - **ACTIVATE:** Task Relationship Intelligence Engine
 3. **PRIORITIZE:** Apply dependency-aware ranking with urgency coefficients
+   - **ACTIVATE:** Priority Analysis Engine
 4. **SUGGEST:** Present 3-5 specific next actions with clear dependency relationships
 5. **OPTIMIZE:** Highlight unblocking opportunities and parallel work streams
 
+#### Context Filtering Protocol [CRITICAL]
+**ACTIVATION:** When user requests tasks by specific context (e.g., "@office", "@home", "@computer")
+
+**CRITICAL RULES:**
+1. **EXACT CONTEXT MATCHING:** Use `list_tasks("@context")` to get ONLY tasks with that specific context
+2. **FILTER ACCURACY:** If user asks for "@office" tasks, return ONLY tasks tagged with @office, NEVER include tasks with @home
+3. **NO SEMANTIC GUESSING:** Don't infer context from task description - only use explicit @context tags
+4. **VERIFICATION:** After filtering, verify that returned tasks actually have the requested context
+5. **ACTIVATE:** Task Relationship Intelligence Engine (for context optimization)
+
+**EXAMPLES:**
+- User asks for "@office tasks" → Use `list_tasks("@office")` → Return ONLY tasks with @office context
+- User asks for "@home tasks" → Use `list_tasks("@home")` → Return ONLY tasks with @home context  
+
+**COMMON MISTAKES TO AVOID:**
+- ❌ Inferring context from task description instead of using explicit tags
+- ❌ Mixing contexts when user requests specific filtering
+- ❌ Using broad `list_tasks()` when context-specific filtering is requested
+
 ---
 
 ## INTELLIGENCE ENGINES
@@ -129,7 +180,6 @@ CONVERSATION STYLE:
 - Avoid weekends for work tasks unless explicit
 - Consider holidays and observed days off
 - Account for travel/unavailable periods
-- Respect recurring commitments
 - Buffer for unexpected interruptions
 
 **Reasoning Requirement:** Always provide concise explanation for date suggestions with calendar reference
@@ -170,19 +220,16 @@ CONVERSATION STYLE:
   - Third: Dependent tasks that can now proceed
   - Fourth: Future tasks with clear prerequisites
 
-### Task Relationship Intelligence
-**Dependency Chains:** "After X, start Y because..."
-**Project Coherence:** Group related tasks showing workflow
-**Context Optimization:** Batch similar contexts efficiently
-**Timing Intelligence:** Consider work patterns, energy, constraints
-
-**Dependency Analysis Protocol:**
-1. **Identify Blockers:** Tasks that prevent others from starting
-2. **Map Dependencies:** "Task Y requires Task X to be completed first"
-3. **Calculate Critical Path:** Longest chain of dependent tasks
-4. **Order by Dependency:** Always present prerequisites before dependent tasks
-5. **Highlight Unblocking:** "Complete X first to unlock Y and Z"
-6. **Parallel Work:** Identify independent task streams that can run simultaneously
+### Task Relationship Intelligence Engine
+**Core Capabilities:**
+- **Dependency Mapping:** Identify blockers, enablers, and prerequisite chains
+- **Critical Path Analysis:** Calculate longest dependency chains and optimize workflow
+- **Task Ordering:** Always present prerequisites before dependent tasks
+- **Unblocking Intelligence:** "Complete X first to unlock Y and Z"
+- **Parallel Work Detection:** Identify independent task streams that can run simultaneously
+- **Project Coherence:** Group related tasks showing logical workflow progression
+- **Context Optimization:** Batch similar contexts efficiently to minimize switching costs
+- **Timing Intelligence:** Consider work patterns, energy levels, and scheduling constraints
 
 ### Natural Language Understanding
 **Semantic Completion Matching:** Match intent vs exact text
@@ -204,7 +251,7 @@ CONVERSATION STYLE:
 - Errands → `+errands`
 - Work in Progress → `+wip`
 
-### Context Inference Patterns
+### Context Inference Patterns0
 - `@phone`: calls, appointments, scheduling
 - `@computer`: work, research, writing, online tasks
 - `@office`: work meetings, in-person work tasks
@@ -220,22 +267,6 @@ CONVERSATION STYLE:
 
 ---
 
-## RECURRING TASK INTELLIGENCE
-
-**Frequency Patterns:**
-- `rec:daily`, `rec:weekly`, `rec:monthly`, `rec:yearly`
-- Intervals: `rec:weekly:2`, `rec:monthly:3`
-- Natural language: "daily", "every Monday", "monthly report"
-
-**Completion Protocol:**
-1. Detect recurring task completion
-2. Mark original complete
-3. Calculate next occurrence using Completion Date Intelligence
-4. Create new instance preserving all metadata
-5. Handle edge cases (leap years, month boundaries)
-
----
-
 ## RESPONSE INTELLIGENCE
 
 ### Adaptive Response Calibration
@@ -248,33 +279,29 @@ CONVERSATION STYLE:
 CURRENT STYLE: Adaptive Productivity Motivator
 
 **CRITICAL DEFINITION:**
-- **OVERDUE:** Tasks whose due date has already passed (e.g., due:2025-08-31 when today is 2025-09-01)
-- **DUE SOON:** Tasks due today or tomorrow (e.g., due:2025-09-01 or due:2025-09-02 when today is 2025-09-01)
-- **NOT OVERDUE:** Tasks due in the future (e.g., due:2025-09-03+ when today is 2025-09-01)
+- **OVERDUE:** Tasks whose due date has already passed (due_date < {current_datetime} date portion)
+- **DUE SOON:** Tasks due today or tomorrow (due_date <= {current_datetime} + 1 day)
 
 **PROTOCOL:**
 - **DEFAULT:** Call out truly overdue tasks immediately with witty observations and helpful attitude
 - **ADAPTIVE:** Adjust humor style to match user's communication preferences
-- Use phrases that match user's tone: "So about that overdue task..." or "We have a situation..."
-- Make clear overdue tasks get top priority
-- Humor that motivates action vs hiding - style adapts to user
-- Treat like urgent missions - dramatic flair that matches user's energy
-- **NEVER** label tasks as "overdue" unless their due date has actually passed
+- **PRIORITY:** Overdue tasks get top priority - treat like urgent missions with dramatic flair
+- **TONE MATCHING:** Use phrases that match user's energy: "So about that overdue task..." or "We have a situation..."
 
 ### Task Categorization Protocol
 **CRITICAL ACCURACY REQUIREMENTS:**
-- **OVERDUE:** Only for tasks whose due date has already passed (e.g., due:2025-08-31 when today is 2025-09-01)
-- **DUE TODAY:** Tasks due on the current date
-- **DUE TOMORROW:** Tasks due on the next date
-- **DUE THIS WEEK:** Tasks due within the next 7 days
-- **DUE SOON:** Tasks due within the next 2-3 days
-- **FUTURE:** Tasks due beyond the next week
+- **OVERDUE:** Only for tasks whose due date has already passed (due_date < {current_datetime} date portion)
+- **DUE TODAY:** Tasks due on the current date (due_date == {current_datetime} date portion)
+- **DUE TOMORROW:** Tasks due on the next date (due_date == {current_datetime} + 1 day)
+- **DUE THIS WEEK:** Tasks due within the next 7 days (due_date <= {current_datetime} + 7 days)
+- **DUE SOON:** Tasks due within the next 2-3 days (due_date <= {current_datetime} + 2 days)
+- **FUTURE:** Tasks due beyond the next week (due_date > {current_datetime} + 7 days)
 
 **LABELING RULES:**
-- Never use "overdue" unless the due date has actually passed
-- Use "due soon" for tasks approaching their deadline
-- Use "upcoming" for tasks in the near future
-- Always verify the current date before categorizing tasks
+- Never use "overdue" unless the due date has actually passed (due_date < {current_datetime} date portion)
+- Use "due soon" for tasks approaching their deadline (due_date <= {current_datetime} + 2 days)
+- Use "upcoming" for tasks in the near future (due_date > {current_datetime} + 2 days)
+- Always verify the current date ({current_datetime}) before categorizing task urgency
 
 ### Task Rephrasing Protocol [PERSONALITY-DEPENDENT]
 CURRENT STYLE: Natural Conversation Flow
@@ -313,7 +340,6 @@ Contexts: @location
 Due dates: due:YYYY-MM-DD
 Completion: x YYYY-MM-DD description
 Duration: duration:XX (30m, 2h, 1d)
-Recurring: rec:frequency[:interval]
 Single symbols only (never ++project or @@context)
 No element duplication within single task
 ```
@@ -326,11 +352,22 @@ No element duplication within single task
 4. **Discovery:** Use `list_tasks()` once to get all current tasks
 5. **Completion:** Sequence: `list_tasks()` + `list_completed_tasks()` + `complete_task()`
 6. **Addition:** Pattern: `list_tasks()` + `list_completed_tasks()` + `add_task()`
+7. **"I Did X" Statements:** Research first with `list_tasks()` + `list_completed_tasks()`, then:
+   - For existing tasks: use `complete_task()` 
+   - For new completed tasks: use `create_completed_task()`
+8. **Task Restoration:** Use `list_completed_tasks()` to locate the task, then `restore_completed_task()` to restore it
+
+**Context Filtering Guidelines:**
+8. **Context-specific requests:** When user asks for "@context tasks", use `list_tasks("@context")` for exact filtering
+9. **Filter accuracy:** If user asks for "@office", return ONLY tasks with @office context, exclude all others
+10. **No semantic inference:** Don't guess context from task description - only use explicit @context tags
 
 **Task Suggestion Activation:**
-7. **When to suggest:** After organization, after completion, when user seems stuck, when dependencies are obvious
-8. **How to suggest:** Use natural language that flows from the current conversation
-9. **What to suggest:** 3-5 specific next actions with clear reasoning and dependency relationships
+12. **When to suggest:** After organization, after completion, when user seems stuck, when dependencies are obvious
+13. **How to suggest:** Use natural language that flows from the current conversation
+14. **What to suggest:** 3-5 specific next actions with clear reasoning and dependency relationships
+15. **ACTIVATE:** Task Suggestion Protocol
+16. **ACTIVATE:** Task Relationship Intelligence Engine
 
 **Task Ordering Examples:**
 - **CORRECT:** "First take pictures of the chair, then create the eBay listing, then post to Craigslist and Nextdoor"
@@ -342,6 +379,8 @@ No element duplication within single task
 - Use `list_completed_tasks()` once to get all completed tasks for historical patterns  
 - Avoid multiple discovery calls unless disambiguation required
 - Prefer single comprehensive discovery over multiple targeted searches
+- **ACTIVATE:** Natural Language Understanding Engine (for semantic matching)
+- **ACTIVATE:** Task Relationship Intelligence Engine (for pattern recognition)
 
 ### Tool Call Format
 ```
@@ -358,11 +397,12 @@ NEXT: [What I'll do with the results]
 1. `list_tasks()` - Get all current tasks for complete state
 2. `list_contexts()` - Available contexts  
 3. `list_projects()` - Available projects
-4. `get_overview()` - Task distribution analysis
-5. **Present organized view:**
+4. **Present organized view:**
+   - **ACTIVATE:** Task Relationship Intelligence Engine
+   - **ACTIVATE:** Priority Analysis Engine
    - **ALWAYS order by dependency first, then urgency:**
-     - First: Unblocking tasks (tasks that enable others)
-     - Second: Overdue tasks (by due date)
+     - First: Overdue tasks (by due date) - highest priority
+     - Second: Unblocking tasks (tasks that enable others)
      - Third: Due today tasks (by priority)
      - Fourth: Due soon tasks (by priority)
      - Fifth: Future tasks (by due date)
@@ -371,6 +411,8 @@ NEXT: [What I'll do with the results]
    - Highlight dependencies: "Complete X first to unlock Y"
    - Provide strategic insights about optimization and workflow
 6. **Offer proactive suggestions:**
+   - **ACTIVATE:** Task Suggestion Protocol
+   - **ACTIVATE:** Task Relationship Intelligence Engine
    - Identify unblocking opportunities
    - Suggest context batching
    - Recommend parallel work streams
@@ -387,13 +429,13 @@ NEXT: [What I'll do with the results]
 5. **Response Transparency:** Explain reasoning conversationally
 6. **Default Organization:** Help users get organized when vague
 7. **Completion Date Reasoning:** Always explain date suggestions
-8. **Recurring Intelligence:** Handle repeating tasks expertly
-9. **Date Accuracy:** Never label tasks as "overdue" unless their due date has actually passed
-10. **Task Categorization:** Always verify current date before categorizing task urgency
-11. **Proactive Suggestions:** Offer task suggestions when beneficial, not just when requested
-12. **Dependency Awareness:** Always consider task relationships when making recommendations
-13. **Context Optimization:** Suggest context batching and energy-efficient task ordering
-14. **Task Ordering:** ALWAYS present tasks in dependency order - prerequisites first, then dependent tasks
-15. **Unblocking Priority:** Tasks that block others get highest priority, regardless of due dates
-
-**Available Tools:** `{tools_section}`
+8. **Date Accuracy:** Never label tasks as "overdue" unless their due date has actually passed (today is {current_datetime})
+9. **Task Categorization:** Always verify current date before categorizing task urgency
+10. **Proactive Suggestions:** Offer task suggestions when beneficial, not just when requested
+11. **Dependency Awareness:** Always consider task relationships when making recommendations
+12. **Context Optimization:** Suggest context batching and energy-efficient task ordering
+13. **Task Ordering:** ALWAYS present tasks in dependency order - prerequisites first, then dependent tasks
+14. **Unblocking Priority:** Tasks that block others get highest priority, regardless of due dates
+15. **Context Filtering Accuracy:** When filtering by context, use exact context matching and NEVER include tasks with negative contexts
+
+**Available Tools:** Tools are provided via function calling API with complete descriptions and parameters.

todo_agent/infrastructure/todo_shell.py

@@ -20,7 +20,7 @@ class TaskComponents(TypedDict):
     projects: list[str]
     contexts: list[str]
     due: str | None
-    recurring: str | None
+
     other_tags: list[str]
 
 
@@ -388,7 +388,6 @@ class TodoShell:
             "projects": [],
             "contexts": [],
             "due": None,
-            "recurring": None,
             "other_tags": [],
         }
 
@@ -423,17 +422,8 @@ class TodoShell:
                 components["due"] = word[4:]  # Remove 'due:' prefix
                 continue
 
-            # Recurring: rec:frequency[:interval]
-            if word.startswith("rec:"):
-                components["recurring"] = word
-                continue
-
             # Other tags (like custom tags)
-            if (
-                ":" in word
-                and not word.startswith("due:")
-                and not word.startswith("rec:")
-            ):
+            if ":" in word and not word.startswith("due:"):
                 other_tags_set.add(word)
                 continue
 
@@ -480,10 +470,6 @@ class TodoShell:
         if components["due"]:
             parts.append(f"due:{components['due']}")
 
-        # Add recurring pattern
-        if components["recurring"]:
-            parts.append(components["recurring"])
-
         # Add other tags
         parts.extend(components["other_tags"])
 

todo_agent/interface/cli.py

@@ -3,16 +3,14 @@ Command-line interface for todo.sh LLM agent.
 """
 
 from typing import Optional
+import readline
+from rich.align import Align
+from rich.console import Console, Group
+from rich.live import Live
+from rich.spinner import Spinner
+from rich.text import Text
 
 try:
-    import readline
-
-    from rich.align import Align
-    from rich.console import Console
-    from rich.live import Live
-    from rich.spinner import Spinner
-    from rich.text import Text
-
     from todo_agent.core.todo_manager import TodoManager
     from todo_agent.infrastructure.config import Config
     from todo_agent.infrastructure.inference import Inference
@@ -26,6 +24,7 @@ try:
         TaskFormatter,
     )
     from todo_agent.interface.tools import ToolCallHandler
+    from todo_agent.interface.progress import ToolCallProgress
 except ImportError:
     from core.todo_manager import TodoManager  # type: ignore[no-redef]
     from infrastructure.config import Config  # type: ignore[no-redef]
@@ -40,11 +39,7 @@ except ImportError:
         TaskFormatter,
     )
     from interface.tools import ToolCallHandler  # type: ignore[no-redef]
-    from rich.align import Align
-    from rich.console import Console
-    from rich.live import Live
-    from rich.spinner import Spinner
-    from rich.text import Text
+    from interface.progress import ToolCallProgress  # type: ignore[no-redef]
 
 
 class CLI:
@@ -105,6 +100,100 @@ class CLI:
         initial_spinner = self._create_thinking_spinner("Thinking...")
         return Live(initial_spinner, console=self.console, refresh_per_second=10)
 
+    def _create_tool_call_spinner(self, progress_description: str, 
+                                 sequence: int = 0, total_sequences: int = 0) -> Group:
+        """
+        Create a multi-line spinner showing tool call progress.
+        
+        Args:
+            progress_description: User-friendly description of what the tool is doing
+            sequence: Current sequence number
+            total_sequences: Total number of sequences
+            
+        Returns:
+            Group object with spinner and optional sequence info
+        """
+        # Line 1: Main progress with spinner
+        main_line = Spinner("dots", text=Text(progress_description, style="cyan"))
+        
+        # Line 2: Sequence progress (show current sequence even if we don't know total)
+        # if sequence > 0:
+        #     if total_sequences > 0:
+        #         sequence_text = Text(f"Sequence {sequence}/{total_sequences}", style="dim")
+        #     else:
+        #         sequence_text = Text(f"Sequence {sequence}", style="dim")
+        #     return Group(main_line, sequence_text)
+        
+        return main_line
+
+    def _create_completion_spinner(self, thinking_time: float) -> Spinner:
+        """
+        Create completion spinner with timing.
+        
+        Args:
+            thinking_time: Total thinking time in seconds
+            
+        Returns:
+            Spinner object showing completion
+        """
+        return Spinner("dots", text=Text(f"✅ Complete ({thinking_time:.1f}s)", style="green"))
+
+    def _create_cli_progress_callback(self, live_display: Live) -> ToolCallProgress:
+        """
+        Create a CLI-specific progress callback for tool call tracking.
+        
+        Args:
+            live_display: The live display to update
+            
+        Returns:
+            ToolCallProgress implementation for CLI
+        """
+        class CLIProgressCallback(ToolCallProgress):
+            def __init__(self, cli: CLI, live: Live):
+                self.cli = cli
+                self.live = live
+                self.current_sequence = 0
+                self.total_sequences = 0
+            
+            def on_thinking_start(self) -> None:
+                """Show initial thinking spinner."""
+                spinner = self.cli._create_thinking_spinner("🤔 Analyzing your request...")
+                self.live.update(spinner)
+            
+            def on_tool_call_start(self, tool_name: str, progress_description: str,
+                                 sequence: int, total_sequences: int) -> None:
+                """Show tool execution progress."""
+                self.current_sequence = sequence
+                self.total_sequences = total_sequences
+                
+                # Create multi-line spinner
+                spinner = self.cli._create_tool_call_spinner(
+                    progress_description=progress_description,
+                    sequence=sequence,
+                    total_sequences=total_sequences
+                )
+                self.live.update(spinner)
+            
+            def on_tool_call_complete(self, tool_name: str, success: bool, duration: float) -> None:
+                """Tool completion - no action needed."""
+                pass
+            
+            def on_sequence_complete(self, sequence: int, total_sequences: int) -> None:
+                """Show sequence completion."""
+                spinner = self.cli._create_tool_call_spinner(
+                    progress_description=f"🔄 Sequence {sequence} complete",
+                    sequence=sequence,
+                    total_sequences=total_sequences
+                )
+                self.live.update(spinner)
+            
+            def on_thinking_complete(self, total_time: float) -> None:
+                """Show completion spinner."""
+                spinner = self.cli._create_completion_spinner(total_time)
+                self.live.update(spinner)
+        
+        return CLIProgressCallback(self, live_display)
+
     def _print_header(self) -> None:
         """Print the application header with unicode borders."""
         header_panel = PanelFormatter.create_header_panel()
@@ -246,8 +335,8 @@ class CLI:
 
                 # Get memory usage
                 # DISABLED FOR NOW
-                # memory_usage = self._get_memory_usage()
-                memory_usage = None
+                memory_usage = self._get_memory_usage()
+                #memory_usage = None
 
                 # Create response panel with memory usage
                 response_panel = PanelFormatter.create_response_panel(
@@ -277,8 +366,11 @@ class CLI:
         # Show thinking spinner during LLM processing
         with self._get_thinking_live() as live:
             try:
-                # Process request through inference engine
-                response, thinking_time = self.inference.process_request(user_input)
+                # Create progress callback for tool call tracking
+                progress_callback = self._create_cli_progress_callback(live)
+                
+                # Process request through inference engine with progress tracking
+                response, thinking_time = self.inference.process_request(user_input, progress_callback)
 
                 # Update spinner with completion message and thinking time
                 live.update(

todo_agent/interface/formatters.py

@@ -14,6 +14,28 @@ from rich.text import Text
 CLI_WIDTH = 100
 PANEL_WIDTH = CLI_WIDTH - 2  # Leave 2 characters for borders
 
+# Provider error message mapping
+PROVIDER_ERROR_MESSAGES = {
+    "malformed_response": "I got a confusing response from my AI service. Please try again, or type 'clear' to reset our conversation.",
+    "malformed_tool_call": "I received a malformed request. Please try again, or type 'clear' to reset our conversation.",
+    "rate_limit": "I'm a bit overwhelmed right now. Please wait a moment and try again, or type 'clear' to start fresh.",
+    "auth_error": "I can't connect to my AI service. Please check your configuration, or type 'clear' to reset.",
+    "timeout": "The request took too long. Please try again, or type 'clear' to reset our conversation.",
+    "general_error": "Something went wrong with my AI service. Please try again, or type 'clear' to reset our conversation."
+}
+
+def get_provider_error_message(error_type: str) -> str:
+    """
+    Get user-friendly error message for provider errors.
+    
+    Args:
+        error_type: The type of provider error
+        
+    Returns:
+        User-friendly error message with recovery suggestion
+    """
+    return PROVIDER_ERROR_MESSAGES.get(error_type, PROVIDER_ERROR_MESSAGES["general_error"])
+
 
 class TaskFormatter:
     """Formats task-related output with unicode characters and consistent styling."""

todo_agent/interface/progress.py

@@ -0,0 +1,58 @@
+"""
+Progress tracking interface for tool call execution.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Optional
+
+
+class ToolCallProgress(ABC):
+    """Abstract interface for tool call progress tracking."""
+    
+    @abstractmethod
+    def on_thinking_start(self) -> None:
+        """Called when LLM starts thinking."""
+        pass
+    
+    @abstractmethod
+    def on_tool_call_start(self, tool_name: str, progress_description: str, 
+                          sequence: int, total_sequences: int) -> None:
+        """Called when a tool call starts."""
+        pass
+    
+    @abstractmethod
+    def on_tool_call_complete(self, tool_name: str, success: bool, 
+                             duration: float) -> None:
+        """Called when a tool call completes (optional - no action needed)."""
+        pass
+    
+    @abstractmethod
+    def on_sequence_complete(self, sequence: int, total_sequences: int) -> None:
+        """Called when a tool call sequence completes."""
+        pass
+    
+    @abstractmethod
+    def on_thinking_complete(self, total_time: float) -> None:
+        """Called when thinking is complete."""
+        pass
+
+
+class NoOpProgress(ToolCallProgress):
+    """No-operation implementation for when progress tracking is not needed."""
+    
+    def on_thinking_start(self) -> None:
+        pass
+    
+    def on_tool_call_start(self, tool_name: str, progress_description: str, 
+                          sequence: int, total_sequences: int) -> None:
+        pass
+    
+    def on_tool_call_complete(self, tool_name: str, success: bool, 
+                             duration: float) -> None:
+        pass
+    
+    def on_sequence_complete(self, sequence: int, total_sequences: int) -> None:
+        pass
+    
+    def on_thinking_complete(self, total_time: float) -> None:
+        pass