todo-agent 0.2.3__tar.gz → 0.2.5__tar.gz

{todo_agent-0.2.3 → todo_agent-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: todo-agent
-Version: 0.2.3
+Version: 0.2.5
 Summary: A natural language interface for todo.sh task management
 Author: codeprimate
 Maintainer: codeprimate

{todo_agent-0.2.3 → todo_agent-0.2.5}/tests/test_core/test_conversation_manager.py

@@ -14,7 +14,7 @@ class TestConversationManager:
         """Test ConversationManager initialization."""
         manager = ConversationManager()
         assert len(manager.history) == 0
-        assert manager.max_tokens == 4000
+        assert manager.max_tokens == 16000
         assert manager.max_messages == 50
         assert manager.system_prompt is None
 

{todo_agent-0.2.3 → todo_agent-0.2.5}/tests/test_core/test_todo_manager.py

@@ -32,6 +32,63 @@ class TestTodoManager(unittest.TestCase):
         self.assertEqual(result, "Added task: Test task")
         self.todo_shell.add.assert_called_once_with("Test task")
 
+    def test_add_task_with_invalid_priority(self):
+        """Test adding a task with invalid priority raises ValueError."""
+        with self.assertRaises(ValueError) as context:
+            self.todo_manager.add_task("Test task", priority="invalid")
+        self.assertIn("Invalid priority", str(context.exception))
+
+    def test_add_task_with_invalid_priority_lowercase(self):
+        """Test adding a task with lowercase priority raises ValueError."""
+        with self.assertRaises(ValueError) as context:
+            self.todo_manager.add_task("Test task", priority="a")
+        self.assertIn("Invalid priority", str(context.exception))
+
+    def test_add_task_with_invalid_priority_multiple_chars(self):
+        """Test adding a task with multiple character priority raises ValueError."""
+        with self.assertRaises(ValueError) as context:
+            self.todo_manager.add_task("Test task", priority="AB")
+        self.assertIn("Invalid priority", str(context.exception))
+
+    def test_add_task_sanitizes_project_with_plus(self):
+        """Test that project with existing + symbol is properly sanitized."""
+        self.todo_shell.add.return_value = "Test task"
+        result = self.todo_manager.add_task("Test task", project="+work")
+        self.assertEqual(result, "Added task: Test task +work")
+        self.todo_shell.add.assert_called_once_with("Test task +work")
+
+    def test_add_task_sanitizes_context_with_at(self):
+        """Test that context with existing @ symbol is properly sanitized."""
+        self.todo_shell.add.return_value = "Test task"
+        result = self.todo_manager.add_task("Test task", context="@office")
+        self.assertEqual(result, "Added task: Test task @office")
+        self.todo_shell.add.assert_called_once_with("Test task @office")
+
+    def test_add_task_with_empty_project_after_sanitization(self):
+        """Test adding a task with empty project after removing + raises ValueError."""
+        with self.assertRaises(ValueError) as context:
+            self.todo_manager.add_task("Test task", project="+")
+        self.assertIn("Project name cannot be empty", str(context.exception))
+
+    def test_add_task_with_empty_context_after_sanitization(self):
+        """Test adding a task with empty context after removing @ raises ValueError."""
+        with self.assertRaises(ValueError) as context:
+            self.todo_manager.add_task("Test task", context="@")
+        self.assertIn("Context name cannot be empty", str(context.exception))
+
+    def test_add_task_with_invalid_due_date(self):
+        """Test adding a task with invalid due date format raises ValueError."""
+        with self.assertRaises(ValueError) as context:
+            self.todo_manager.add_task("Test task", due="invalid-date")
+        self.assertIn("Invalid due date format", str(context.exception))
+
+    def test_add_task_with_valid_due_date(self):
+        """Test adding a task with valid due date format."""
+        self.todo_shell.add.return_value = "Test task"
+        result = self.todo_manager.add_task("Test task", due="2024-01-15")
+        self.assertEqual(result, "Added task: Test task due:2024-01-15")
+        self.todo_shell.add.assert_called_once_with("Test task due:2024-01-15")
+
     def test_list_tasks(self):
         """Test listing tasks."""
         self.todo_shell.list_tasks.return_value = "1. Task 1\n2. Task 2"

todo_agent-0.2.5/tests/test_infrastructure/test_calendar_utils.py

@@ -0,0 +1,81 @@
+"""
+Tests for calendar utilities.
+"""
+
+from unittest.mock import Mock, patch
+
+import pytest
+
+from todo_agent.infrastructure.calendar_utils import (
+    get_calendar_output,
+    get_current_month_calendar,
+)
+
+
+class TestCalendarUtils:
+    """Test calendar utility functions."""
+
+    def test_get_calendar_output_success(self):
+        """Test successful calendar output generation."""
+        mock_output = "Calendar output from cal -3"
+
+        with patch("subprocess.run") as mock_run:
+            mock_result = Mock()
+            mock_result.stdout = mock_output
+            mock_run.return_value = mock_result
+
+            result = get_calendar_output()
+
+            assert result == mock_output
+            assert len(result) > 0
+            mock_run.assert_called_once_with(
+                ["cal", "-3"], capture_output=True, text=True, check=True
+            )
+
+    def test_get_calendar_output_fallback(self):
+        """Test calendar output fallback to Python calendar."""
+        with patch("subprocess.run", side_effect=FileNotFoundError("cal not found")):
+            result = get_calendar_output()
+
+            # Should return a string with calendar data
+            assert isinstance(result, str)
+            assert len(result) > 0
+
+    def test_get_current_month_calendar_success(self):
+        """Test successful current month calendar generation."""
+        mock_output = "Current month calendar"
+
+        with patch("subprocess.run") as mock_run:
+            mock_result = Mock()
+            mock_result.stdout = mock_output
+            mock_run.return_value = mock_result
+
+            result = get_current_month_calendar()
+
+            assert result == mock_output
+            assert len(result) > 0
+            mock_run.assert_called_once_with(
+                ["cal"], capture_output=True, text=True, check=True
+            )
+
+    def test_get_current_month_calendar_fallback(self):
+        """Test current month calendar fallback to Python calendar."""
+        with patch("subprocess.run", side_effect=FileNotFoundError("cal not found")):
+            result = get_current_month_calendar()
+
+            # Should return a string with calendar data
+            assert isinstance(result, str)
+            assert len(result) > 0
+
+    def test_calendar_output_contains_expected_content(self):
+        """Test that calendar output contains expected content."""
+        with patch("subprocess.run") as mock_run:
+            mock_result = Mock()
+            mock_result.stdout = "Calendar with July August September 2025"
+            mock_run.return_value = mock_result
+
+            result = get_calendar_output()
+
+            # Should contain some calendar content
+            assert len(result) > 0
+            assert isinstance(result, str)

{todo_agent-0.2.3 → todo_agent-0.2.5}/tests/test_interface/test_cli.py

@@ -295,6 +295,49 @@ class TestCLI:
                 f"Error: Failed to list tasks: {error_message}"
             )
 
+    def test_done_command_success(self):
+        """Test successful done command execution."""
+        expected_output = (
+            "x 2025-08-29 2025-08-28 Buy groceries\nx 2025-08-28 2025-08-27 Call mom"
+        )
+
+        # Mock the todo_shell.list_completed method
+        self.cli.todo_shell.list_completed.return_value = expected_output
+
+        with patch("builtins.print") as mock_print:
+            # Simulate the done command logic
+            try:
+                output = self.cli.todo_shell.list_completed()
+                print(output)
+            except Exception as e:
+                print(f"Error: Failed to list completed tasks: {e!s}")
+
+            # Verify todo_shell.list_completed was called
+            self.cli.todo_shell.list_completed.assert_called_once()
+
+            # Verify print was called with the expected output
+            mock_print.assert_called_once_with(expected_output)
+
+    def test_done_command_exception_handling(self):
+        """Test done command handles exceptions properly."""
+        error_message = "Database connection failed"
+
+        # Mock exception in todo_shell.list_completed
+        self.cli.todo_shell.list_completed.side_effect = Exception(error_message)
+
+        with patch("builtins.print") as mock_print:
+            # Simulate the done command logic with error
+            try:
+                output = self.cli.todo_shell.list_completed()
+                print(output)
+            except Exception as e:
+                print(f"Error: Failed to list completed tasks: {e!s}")
+
+            # Verify error was handled and formatted correctly
+            mock_print.assert_called_once_with(
+                f"Error: Failed to list completed tasks: {error_message}"
+            )
+
     def test_help_command_displays_available_commands(self):
         """Test that help command displays all available commands."""
         with patch("builtins.print") as mock_print:
@@ -304,6 +347,7 @@ class TestCLI:
             print("  history  - Show conversation statistics")
             print("  help     - Show this help message")
             print("  list     - List all tasks (no LLM interaction)")
+            print("  done     - List completed tasks (no LLM interaction)")
             print("  quit     - Exit the application")
             print("  Or just type your request naturally!")
 
@@ -314,6 +358,7 @@ class TestCLI:
                 "  history  - Show conversation statistics",
                 "  help     - Show this help message",
                 "  list     - List all tasks (no LLM interaction)",
+                "  done     - List completed tasks (no LLM interaction)",
                 "  quit     - Exit the application",
                 "  Or just type your request naturally!",
             ]

todo_agent-0.2.5/tests/test_interface/test_formatters.py

@@ -0,0 +1,75 @@
+"""
+Tests for formatters module.
+"""
+
+import pytest
+from rich.text import Text
+
+from todo_agent.interface.formatters import TaskFormatter
+
+
+class TestTaskFormatter:
+    """Test TaskFormatter functionality."""
+
+    def test_format_task_list_preserves_ansi_codes(self):
+        """Test that format_task_list preserves ANSI color codes."""
+        # Sample output with ANSI color codes (simulating todo.sh output)
+        raw_tasks = "\033[1;33m1\033[0m (A) \033[1;32m2025-08-29\033[0m Clean cat box \033[1;34m@home\033[0m \033[1;35m+chores\033[0m \033[1;31mdue:2025-08-29\033[0m"
+        
+        result = TaskFormatter.format_task_list(raw_tasks)
+        
+        # The result should be a Rich Text object
+        assert isinstance(result, Text)
+        
+        # Check that the Rich Text object contains the original ANSI codes
+        # We can check this by looking at the raw text content
+        result_str = result.plain
+        assert "1" in result_str  # Task number should be present
+        assert "(A)" in result_str  # Priority should be present
+        assert "2025-08-29" in result_str  # Date should be present
+        assert "@home" in result_str  # Context should be present
+        assert "+chores" in result_str  # Project should be present
+        assert "due:2025-08-29" in result_str  # Due date should be present
+
+    def test_format_completed_tasks_preserves_ansi_codes(self):
+        """Test that format_completed_tasks preserves ANSI color codes."""
+        # Sample completed task output with ANSI color codes
+        raw_tasks = "\033[1;32mx\033[0m \033[1;32m2025-08-29\033[0m \033[1;32m2025-08-28\033[0m Clean cat box \033[1;34m@home\033[0m \033[1;35m+chores\033[0m"
+        
+        result = TaskFormatter.format_completed_tasks(raw_tasks)
+        
+        # The result should be a Rich Text object
+        assert isinstance(result, Text)
+        
+        # Check that the Rich Text object contains the original content
+        # We can check this by looking at the raw text content
+        result_str = result.plain
+        assert "x" in result_str  # Completion marker should be present
+        assert "2025-08-29" in result_str  # Completion date should be present
+        assert "2025-08-28" in result_str  # Creation date should be present
+        assert "@home" in result_str  # Context should be present
+        assert "+chores" in result_str  # Project should be present
+
+    def test_format_task_list_handles_empty_input(self):
+        """Test that format_task_list handles empty input gracefully."""
+        result = TaskFormatter.format_task_list("")
+        assert isinstance(result, Text)
+        assert "No tasks found" in str(result)
+
+    def test_format_completed_tasks_handles_empty_input(self):
+        """Test that format_completed_tasks handles empty input gracefully."""
+        result = TaskFormatter.format_completed_tasks("")
+        assert isinstance(result, Text)
+        assert "No completed tasks found" in str(result)
+
+    def test_format_task_list_handles_whitespace_only(self):
+        """Test that format_task_list handles whitespace-only input."""
+        result = TaskFormatter.format_task_list("   \n  \t  ")
+        assert isinstance(result, Text)
+        assert "No tasks found" in str(result)
+
+    def test_format_completed_tasks_handles_whitespace_only(self):
+        """Test that format_completed_tasks handles whitespace-only input."""
+        result = TaskFormatter.format_completed_tasks("   \n  \t  ")
+        assert isinstance(result, Text)
+        assert "No completed tasks found" in str(result)

{todo_agent-0.2.3 → todo_agent-0.2.5}/tests/test_interface/test_tools.py

@@ -178,3 +178,62 @@ class TestToolErrorHandling:
 
         assert result["error"] is False
         assert result["output"] == "1. Test task"
+
+
+class TestCalendarTool:
+    """Test calendar tool functionality."""
+
+    def setup_method(self):
+        """Set up test fixtures."""
+        self.mock_todo_manager = Mock(spec=TodoManager)
+        self.mock_logger = Mock()
+        self.tool_handler = ToolCallHandler(self.mock_todo_manager, self.mock_logger)
+
+    @patch("subprocess.run")
+    def test_get_calendar_success(self, mock_run):
+        """Test successful calendar retrieval using system cal command."""
+        # Mock the subprocess.run to return a calendar
+        mock_run.return_value.stdout = "   January 2025\nSu Mo Tu We Th Fr Sa\n          1  2  3  4\n 5  6  7  8  9 10 11\n12 13 14 15 16 17 18\n19 20 21 22 23 24 25\n26 27 28 29 30 31\n"
+        mock_run.return_value.returncode = 0
+
+        tool_call = {
+            "function": {
+                "name": "get_calendar",
+                "arguments": '{"month": 1, "year": 2025}',
+            },
+            "id": "test_id",
+        }
+
+        result = self.tool_handler.execute_tool(tool_call)
+
+        assert result["error"] is False
+        assert "January 2025" in result["output"]
+        assert result["tool_call_id"] == "test_id"
+        assert result["name"] == "get_calendar"
+
+        # Verify subprocess.run was called with correct arguments
+        mock_run.assert_called_once_with(
+            ["cal", "1", "2025"], capture_output=True, text=True, check=True
+        )
+
+    @patch("subprocess.run")
+    def test_get_calendar_fallback_to_python(self, mock_run):
+        """Test calendar fallback to Python calendar module when cal command fails."""
+        # Mock subprocess.run to raise FileNotFoundError
+        mock_run.side_effect = FileNotFoundError("cal command not found")
+
+        tool_call = {
+            "function": {
+                "name": "get_calendar",
+                "arguments": '{"month": 1, "year": 2025}',
+            },
+            "id": "test_id",
+        }
+
+        result = self.tool_handler.execute_tool(tool_call)
+
+        assert result["error"] is False
+        assert "January" in result["output"]
+        assert "2025" in result["output"]
+        assert result["tool_call_id"] == "test_id"
+        assert result["name"] == "get_calendar"

{todo_agent-0.2.3 → todo_agent-0.2.5}/todo_agent/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.3'
-__version_tuple__ = version_tuple = (0, 2, 3)
+__version__ = version = '0.2.5'
+__version_tuple__ = version_tuple = (0, 2, 5)
 
-__commit_id__ = commit_id = 'ge1a08d166'
+__commit_id__ = commit_id = 'gcb2b8bbf9'

{todo_agent-0.2.3 → todo_agent-0.2.5}/todo_agent/core/conversation_manager.py

@@ -35,7 +35,7 @@ class ConversationManager:
     """Manages conversation state and memory for LLM interactions."""
 
     def __init__(
-        self, max_tokens: int = 4000, max_messages: int = 50, model: str = "gpt-4"
+        self, max_tokens: int = 16000, max_messages: int = 50, model: str = "gpt-4"
     ):
         self.history: List[ConversationMessage] = []
         self.max_tokens = max_tokens

{todo_agent-0.2.3 → todo_agent-0.2.5}/todo_agent/core/todo_manager.py

@@ -21,6 +21,39 @@ class TodoManager:
         due: Optional[str] = None,
     ) -> str:
         """Add new task with explicit project/context parameters."""
+        # Validate and sanitize inputs
+        if priority and not (
+            len(priority) == 1 and priority.isalpha() and priority.isupper()
+        ):
+            raise ValueError(
+                f"Invalid priority '{priority}'. Must be a single uppercase letter (A-Z)."
+            )
+
+        if project:
+            # Remove any existing + symbols to prevent duplication
+            project = project.strip().lstrip("+")
+            if not project:
+                raise ValueError(
+                    "Project name cannot be empty after removing + symbol."
+                )
+
+        if context:
+            # Remove any existing @ symbols to prevent duplication
+            context = context.strip().lstrip("@")
+            if not context:
+                raise ValueError(
+                    "Context name cannot be empty after removing @ symbol."
+                )
+
+        if due:
+            # Basic date format validation
+            try:
+                datetime.strptime(due, "%Y-%m-%d")
+            except ValueError:
+                raise ValueError(
+                    f"Invalid due date format '{due}'. Must be YYYY-MM-DD."
+                )
+
         # Build the full task description with priority, project, and context
         full_description = description
 

todo_agent-0.2.5/todo_agent/infrastructure/calendar_utils.py

@@ -0,0 +1,64 @@
+"""
+Calendar utilities for generating calendar output in system prompts.
+"""
+
+import calendar
+import subprocess
+from datetime import datetime, timedelta
+
+
+def get_calendar_output() -> str:
+    """
+    Generate calendar output for previous, current, and next month.
+
+    Returns:
+        Formatted calendar string showing three months side by side
+    """
+    try:
+        # Use cal -3 to get three months side by side
+        result = subprocess.run(
+            ["cal", "-3"], capture_output=True, text=True, check=True
+        )
+        return result.stdout.strip()
+    except (subprocess.SubprocessError, FileNotFoundError):
+        # Fallback to Python calendar module
+        return _get_python_cal_output()
+
+
+def _get_python_cal_output() -> str:
+    """
+    Generate calendar output using Python calendar module as fallback.
+
+    Returns:
+        Calendar output formatted similar to cal command
+    """
+    current_date = datetime.now()
+
+    # Calculate previous, current, and next month
+    prev_month = current_date - timedelta(days=current_date.day)
+    next_month = current_date.replace(day=1) + timedelta(days=32)
+    next_month = next_month.replace(day=1)
+
+    calendars = []
+
+    for date in [prev_month, current_date, next_month]:
+        cal = calendar.month(date.year, date.month)
+        calendars.append(cal.strip())
+
+    return "\n\n".join(calendars)
+
+
+def get_current_month_calendar() -> str:
+    """
+    Get calendar for current month only.
+
+    Returns:
+        Calendar output for current month
+    """
+    try:
+        result = subprocess.run(["cal"], capture_output=True, text=True, check=True)
+        return result.stdout.strip()
+    except (subprocess.SubprocessError, FileNotFoundError):
+        # Fallback to Python calendar
+        current_date = datetime.now()
+        return calendar.month(current_date.year, current_date.month).strip()

{todo_agent-0.2.3 → todo_agent-0.2.5}/todo_agent/infrastructure/inference.py

@@ -75,6 +75,15 @@ class Inference:
 
         current_datetime = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
 
+        # Get calendar output
+        from .calendar_utils import get_calendar_output
+
+        try:
+            calendar_output = get_calendar_output()
+        except Exception as e:
+            self.logger.warning(f"Failed to get calendar output: {e!s}")
+            calendar_output = "Calendar unavailable"
+
         # Load system prompt from file
         prompt_file_path = os.path.join(
             os.path.dirname(__file__), "prompts", "system_prompt.txt"
@@ -84,9 +93,11 @@ class Inference:
             with open(prompt_file_path, encoding="utf-8") as f:
                 system_prompt_template = f.read()
 
-            # Format the template with the tools section and current datetime
+            # Format the template with the tools section, current datetime, and calendar
             return system_prompt_template.format(
-                tools_section=tools_section, current_datetime=current_datetime
+                tools_section=tools_section,
+                current_datetime=current_datetime,
+                calendar_output=calendar_output,
             )
 
         except FileNotFoundError:

{todo_agent-0.2.3 → todo_agent-0.2.5}/todo_agent/infrastructure/llm_client_factory.py

@@ -2,6 +2,8 @@
 Factory for creating LLM clients based on configuration.
 """
 
+# mypy: disable-error-code="no-redef"
+
 from typing import Optional
 
 try:
@@ -15,8 +17,8 @@ except ImportError:
     from infrastructure.llm_client import LLMClient  # type: ignore[no-redef]
     from infrastructure.logger import Logger  # type: ignore[no-redef]
     from infrastructure.ollama_client import OllamaClient  # type: ignore[no-redef]
-    from infrastructure.openrouter_client import (  # type: ignore[no-redef]
-        OpenRouterClient,
+    from infrastructure.openrouter_client import (
+        OpenRouterClient,  # type: ignore[no-redef, misc]
     )
 
 

todo_agent-0.2.5/todo_agent/infrastructure/prompts/system_prompt.txt

@@ -0,0 +1,92 @@
+You are a todo.sh assistant managing tasks in standard todo.txt format.
+
+CURRENT DATE/TIME: {current_datetime}
+{calendar_output}
+
+CORE PRINCIPLES:
+1. Strategic Tool Usage: Batch discovery tools ([list_tasks, list_completed_tasks, list_projects, list_contexts]) to minimize API calls
+2. Conversational: Respond naturally without mentioning tools or technical details
+3. Data Integrity: Only reference tasks/projects/contexts returned by actual tool calls - NEVER hallucinate
+4. Safety: Always verify current state before modifications using list_tasks() and list_completed_tasks()
+5. Todo.txt Compliance: Use standard format and ordering
+
+TODO.TXT FORMAT:
+- Priority: (A), (B), (C) • Completion: "x YYYY-MM-DD" • Creation: YYYY-MM-DD
+- Projects: +project (single + symbol) • Contexts: @context (single @ symbol) • Due dates: due:YYYY-MM-DD
+- Example: "(A) 2024-01-15 Call dentist +health @phone due:2024-01-20"
+- CRITICAL: Never use double symbols like ++project or @@context - always use single + and @ symbols
+
+WORKFLOW:
+Discovery First: Gather context with batched tool calls before any action
+Verify Before Action: Check for duplicates, conflicts, or existing completions
+Sequential Processing: Tools execute in order within batches
+
+TASK COMPLETION:
+When users say something like "I finished X" or "I'm done with Y", search for matching tasks
+using list_tasks() and handle ambiguity by showing numbered options. Always verify task
+hasn't already been completed with list_completed_tasks().
+
+COMPLETION INTELLIGENCE:
+- If user's statement clearly matches exactly one task (e.g., "I finished mowing the lawn" 
+  when there's only one task with "yard work" in the description), complete it immediately
+- If user's statement matches multiple tasks, show numbered options and ask for clarification
+- If user's statement is ambiguous or could match many tasks, ask for clarification
+- When in doubt about ambiguity, ask for more information to clarify intent before taking any action
+
+CONTEXT AND PROJECT INFERENCE:
+- Extract temporal urgency from due dates and creation dates
+- Identify task relationships through shared projects/contexts
+- Determine scope boundaries from natural language (work vs personal tasks)
+- Recognize priority patterns and dependencies
+
+TASK CREATION INTELLIGENCE:
+- When users request to add a task, automatically infer appropriate projects, contexts, and due dates based on the task content
+- When intent is clear, create the task immediately without asking for confirmation
+- Only ask for clarification when project/context/due date is genuinely ambiguous
+- Use priority C for new tasks unless urgency is indicated
+- DUE DATE INFERENCE: Automatically infer due dates using multiple intelligence sources:
+  * Explicit expressions: "tomorrow", "next week", "next Monday", "by Friday" → Convert to YYYY-MM-DD format
+  * Relative expressions: "in 3 days", "next month", "end of month" → Calculate appropriate date
+  * Urgency indicators: "urgent", "asap", "today" → Set to today's date
+  * Vague expressions: "sometime this week" → Set to end of current week
+  * Task nature inference: Use common sense based on task type and existing patterns:
+    - Work tasks → Consider work week patterns and existing work task due dates
+    - Personal tasks → Consider weekend availability and personal schedule patterns
+    - Health/medical → Consider urgency and typical scheduling patterns
+    - Shopping/errands → Consider when items are needed and store hours
+    - Bills/payments → Consider due dates and late fees
+    - Maintenance tasks → Consider frequency patterns and current state
+  * Calendar context: Use current date/time and calendar output to inform timing decisions
+  * Existing task patterns: Look at similar tasks and their due dates for consistency
+  * Always infer: Every task should have a reasonable due date based on available context
+
+TASK ADVICE:
+Think deeply and critically to categorize tasks and suggest actions:
+- Consider real-life implications and importance to my responsibilities regardless of explicit priority
+- When users request prioritization help, use Eisenhower Matrix:
+    Q1 (Urgent+Important: DO), Q2 (Important: SCHEDULE), Q3 (Urgent: DELEGATE), Q4 (Neither: ELIMINATE) [assign SPARINGLY].
+
+ERROR HANDLING:
+- Empty results: Suggest next steps
+- Ambiguous requests: Show numbered options
+- Large lists: Use filtering/summaries for 10+ items
+- Failed operations: Explain clearly with alternatives
+
+OUTPUT FORMATTING:
+- Calendar Display: Show calendar output as plain text without backticks, code blocks, or markdown formatting
+- Task Lists: Present tasks in conversational language, not raw todo.txt format
+- Natural Language: Use conversational responses that feel natural and helpful
+- No Technical Details: Avoid mentioning tools, API calls, or technical implementation details
+
+CRITICAL RULES:
+- Anti-hallucination: If no tool data exists, say "I need to check your tasks first"
+- Use appropriate discovery tools extensively
+- Never assume task existence without verification
+- Maintain todo.txt standard compliance
+- Format Compliance: Always use single + for projects and single @ for contexts (never ++ or @@)
+- Display Formatting: When showing calendar output, display it as plain text without backticks or code blocks
+- Proactive Task Creation: When users request to add a task, create it immediately with inferred tags and due dates unless genuinely ambiguous
+- No Unnecessary Confirmation: Don't ask for confirmation when the task intent is clear and appropriate tags/due dates can be inferred
+- Due Date Intelligence: Always infer reasonable due dates using task nature, calendar context, existing patterns, and common sense. Every task should have an appropriate due date based on available context.
+
+AVAILABLE TOOLS: {tools_section}