shotgun-sh 0.1.0.dev20__py3-none-any.whl → 0.1.0.dev23__py3-none-any.whl

shotgun/tui/app.py

@@ -29,10 +29,13 @@ class ShotgunApp(App[None]):
     ]
     CSS_PATH = "styles.tcss"
 
-    def __init__(self, no_update_check: bool = False) -> None:
+    def __init__(
+        self, no_update_check: bool = False, continue_session: bool = False
+    ) -> None:
         super().__init__()
         self.config_manager: ConfigManager = get_config_manager()
         self.no_update_check = no_update_check
+        self.continue_session = continue_session
         self.update_notification: str | None = None
 
         # Start async update check
@@ -77,7 +80,8 @@ class ShotgunApp(App[None]):
 
         if isinstance(self.screen, ChatScreen):
             return
-        self.push_screen("chat")
+        # Pass continue_session flag to ChatScreen
+        self.push_screen(ChatScreen(continue_session=self.continue_session))
 
     def check_local_shotgun_directory_exists(self) -> bool:
         shotgun_dir = get_shotgun_base_path()
@@ -97,13 +101,14 @@ class ShotgunApp(App[None]):
         return []  # we don't want any system commands
 
 
-def run(no_update_check: bool = False) -> None:
+def run(no_update_check: bool = False, continue_session: bool = False) -> None:
     """Run the TUI application.
 
     Args:
         no_update_check: If True, disable automatic update checks.
+        continue_session: If True, continue from previous conversation.
     """
-    app = ShotgunApp(no_update_check=no_update_check)
+    app = ShotgunApp(no_update_check=no_update_check, continue_session=continue_session)
     app.run(inline_no_clear=True)
 
 

shotgun/tui/screens/chat.py

@@ -22,13 +22,18 @@ from textual.widgets import Button, DirectoryTree, Input, Label, Markdown, Stati
 
 from shotgun.agents.agent_manager import (
     AgentManager,
-    AgentType,
     MessageHistoryUpdated,
     PartialResponseMessage,
 )
 from shotgun.agents.config import get_provider_model
+from shotgun.agents.conversation_history import (
+    ConversationHistory,
+    ConversationState,
+)
+from shotgun.agents.conversation_manager import ConversationManager
 from shotgun.agents.models import (
     AgentDeps,
+    AgentType,
     FileOperationTracker,
     UserAnswer,
     UserQuestion,
@@ -36,12 +41,13 @@ from shotgun.agents.models import (
 from shotgun.codebase.core.manager import CodebaseAlreadyIndexedError
 from shotgun.sdk.codebase import CodebaseSDK
 from shotgun.sdk.exceptions import CodebaseNotFoundError, InvalidPathError
-from shotgun.sdk.services import get_artifact_service, get_codebase_service
+from shotgun.sdk.services import get_codebase_service
 from shotgun.tui.commands import CommandHandler
 from shotgun.tui.screens.chat_screen.history import ChatHistory
 
 from ..components.prompt_input import PromptInput
 from ..components.spinner import Spinner
+from ..utils.mode_progress import PlaceholderHints
 from .chat_screen.command_providers import (
     AgentModeProvider,
     CodebaseCommandProvider,
@@ -116,6 +122,7 @@ class ModeIndicator(Widget):
         """
         super().__init__()
         self.mode = mode
+        self.progress_checker = PlaceholderHints().progress_checker
 
     def render(self) -> str:
         """Render the mode indicator."""
@@ -137,7 +144,11 @@ class ModeIndicator(Widget):
         mode_title = mode_display.get(self.mode, self.mode.value.title())
         description = mode_description.get(self.mode, "")
 
-        return f"[bold $text-accent]{mode_title} mode[/][$foreground-muted] ({description})[/]"
+        # Check if mode has content
+        has_content = self.progress_checker.has_mode_content(self.mode)
+        status_icon = " ✓" if has_content else ""
+
+        return f"[bold $text-accent]{mode_title}{status_icon} mode[/][$foreground-muted] ({description})[/]"
 
 
 class FilteredDirectoryTree(DirectoryTree):
@@ -174,9 +185,11 @@ class CodebaseIndexPromptScreen(ModalScreen[bool]):
 
     def compose(self) -> ComposeResult:
         with Container(id="index-prompt-dialog"):
-            yield Label("Index your codebase?", id="index-prompt-title")
+            yield Label("Index this codebase?", id="index-prompt-title")
             yield Static(
-                "We found project files but no index yet. Indexing enables smarter chat."
+                f"Would you like to index the codebase at:\n{Path.cwd()}\n\n"
+                "This is required for the agent to understand your code and answer "
+                "questions about it. Without indexing, the agent cannot analyze your codebase."
             )
             with Container(id="index-prompt-buttons"):
                 yield Button(
@@ -306,24 +319,6 @@ class ChatScreen(Screen[None]):
 
     COMMANDS = {AgentModeProvider, ProviderSetupProvider, CodebaseCommandProvider}
 
-    _PLACEHOLDER_BY_MODE: dict[AgentType, str] = {
-        AgentType.RESEARCH: (
-            "Ask for investigations, e.g. research strengths and weaknesses of PydanticAI vs its rivals"
-        ),
-        AgentType.PLAN: (
-            "Describe a goal to plan, e.g. draft a rollout plan for launching our Slack automation"
-        ),
-        AgentType.TASKS: (
-            "Request actionable work, e.g. break down tasks to wire OpenTelemetry into the API"
-        ),
-        AgentType.SPECIFY: (
-            "Request detailed specifications, e.g. create a comprehensive spec for user authentication system"
-        ),
-        AgentType.EXPORT: (
-            "Request export tasks, e.g. export research findings to Markdown or convert tasks to CSV"
-        ),
-    }
-
     value = reactive("")
     mode = reactive(AgentType.RESEARCH)
     history: PromptHistory = PromptHistory()
@@ -333,12 +328,11 @@ class ChatScreen(Screen[None]):
     indexing_job: reactive[CodebaseIndexSelection | None] = reactive(None)
     partial_message: reactive[ModelMessage | None] = reactive(None)
 
-    def __init__(self) -> None:
+    def __init__(self, continue_session: bool = False) -> None:
         super().__init__()
         # Get the model configuration and services
         model_config = get_provider_model()
         codebase_service = get_codebase_service()
-        artifact_service = get_artifact_service()
         self.codebase_sdk = CodebaseSDK()
 
         # Create shared deps without system_prompt_fn (agents provide their own)
@@ -350,18 +344,26 @@ class ChatScreen(Screen[None]):
 
         self.deps = AgentDeps(
             interactive_mode=True,
+            is_tui_context=True,
             llm_model=model_config,
             codebase_service=codebase_service,
-            artifact_service=artifact_service,
             system_prompt_fn=_placeholder_system_prompt_fn,
         )
         self.agent_manager = AgentManager(deps=self.deps, initial_type=self.mode)
         self.command_handler = CommandHandler()
+        self.placeholder_hints = PlaceholderHints()
+        self.conversation_manager = ConversationManager()
+        self.continue_session = continue_session
 
     def on_mount(self) -> None:
         self.query_one(PromptInput).focus(scroll_visible=True)
         # Hide spinner initially
         self.query_one("#spinner").display = False
+
+        # Load conversation history if --continue flag was provided
+        if self.continue_session and self.conversation_manager.exists():
+            self._load_conversation()
+
         self.call_later(self.check_if_codebase_is_indexed)
         # Start the question listener worker to handle ask_user interactions
         self.call_later(self.add_question_listener)
@@ -407,7 +409,10 @@ class ChatScreen(Screen[None]):
             mode_indicator.refresh()
 
             prompt_input = self.query_one(PromptInput)
-            prompt_input.placeholder = self._placeholder_for_mode(new_mode)
+            # Force new hint selection when mode changes
+            prompt_input.placeholder = self._placeholder_for_mode(
+                new_mode, force_new=True
+            )
             prompt_input.refresh()
 
     def watch_working(self, is_working: bool) -> None:
@@ -483,6 +488,10 @@ class ChatScreen(Screen[None]):
         if not chat_history.vertical_tail:
             return
         chat_history.vertical_tail.mount(Markdown(markdown))
+        # Scroll to bottom after mounting hint
+        chat_history.vertical_tail.call_after_refresh(
+            chat_history.vertical_tail.scroll_end, animate=False
+        )
 
     @on(PartialResponseMessage)
     def handle_partial_response(self, event: PartialResponseMessage) -> None:
@@ -503,6 +512,14 @@ class ChatScreen(Screen[None]):
         self._clear_partial_response()
         self.messages = event.messages
 
+        # Refresh placeholder and mode indicator in case artifacts were created
+        prompt_input = self.query_one(PromptInput)
+        prompt_input.placeholder = self._placeholder_for_mode(self.mode)
+        prompt_input.refresh()
+
+        mode_indicator = self.query_one(ModeIndicator)
+        mode_indicator.refresh()
+
         # If there are file operations, add a message showing the modified files
         if event.file_operations:
             chat_history = self.query_one(ChatHistory)
@@ -577,9 +594,17 @@ class ChatScreen(Screen[None]):
         prompt_input = self.query_one(PromptInput)
         prompt_input.clear()
 
-    def _placeholder_for_mode(self, mode: AgentType) -> str:
-        """Return the placeholder text appropriate for the current mode."""
-        return self._PLACEHOLDER_BY_MODE.get(mode, "Type your message")
+    def _placeholder_for_mode(self, mode: AgentType, force_new: bool = False) -> str:
+        """Return the placeholder text appropriate for the current mode.
+
+        Args:
+            mode: The current agent mode.
+            force_new: If True, force selection of a new random hint.
+
+        Returns:
+            Dynamic placeholder hint based on mode and progress.
+        """
+        return self.placeholder_hints.get_placeholder_for_mode(mode)
 
     def index_codebase_command(self) -> None:
         start_path = Path.cwd()
@@ -677,9 +702,46 @@ class ChatScreen(Screen[None]):
         )
         self.working = False
 
+        # Save conversation after each interaction
+        self._save_conversation()
+
         prompt_input = self.query_one(PromptInput)
         prompt_input.focus()
 
+    def _save_conversation(self) -> None:
+        """Save the current conversation to persistent storage."""
+        # Get conversation state from agent manager
+        state = self.agent_manager.get_conversation_state()
+
+        # Create conversation history object
+        conversation = ConversationHistory(
+            last_agent_model=state.agent_type,
+        )
+        conversation.set_agent_messages(state.agent_messages)
+
+        # Save to file
+        self.conversation_manager.save(conversation)
+
+    def _load_conversation(self) -> None:
+        """Load conversation from persistent storage."""
+        conversation = self.conversation_manager.load()
+        if conversation is None:
+            return
+
+        # Restore agent state
+        agent_messages = conversation.get_agent_messages()
+
+        # Create ConversationState for restoration
+        state = ConversationState(
+            agent_messages=agent_messages,
+            agent_type=conversation.last_agent_model,
+        )
+
+        self.agent_manager.restore_conversation_state(state)
+
+        # Update the current mode
+        self.mode = AgentType(conversation.last_agent_model)
+
 
 def codebase_indexed_hint(codebase_name: str) -> str:
     return (

shotgun/tui/screens/chat_screen/command_providers.py

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING, cast
 
 from textual.command import DiscoveryHit, Hit, Provider
 
-from shotgun.agents.agent_manager import AgentType
+from shotgun.agents.models import AgentType
 from shotgun.codebase.models import CodebaseGraph
 
 if TYPE_CHECKING:

shotgun/tui/screens/chat_screen/history.py

@@ -187,6 +187,12 @@ class AgentResponseWidget(Widget):
     def _format_tool_call_part(self, part: ToolCallPart) -> str:
         if part.tool_name == "ask_user":
             return self._format_ask_user_part(part)
+        # write_file
+        if part.tool_name == "write_file" or part.tool_name == "append_file":
+            if isinstance(part.args, dict) and "filename" in part.args:
+                return f"{part.tool_name}({part.args['filename']})"
+            else:
+                return f"{part.tool_name}()"
         if part.tool_name == "write_artifact_section":
             if isinstance(part.args, dict) and "section_title" in part.args:
                 return f"{part.tool_name}({part.args['section_title']})"

shotgun/tui/utils/__init__.py

@@ -0,0 +1,5 @@
+"""TUI utilities package."""
+
+from .mode_progress import ModeProgressChecker, PlaceholderHints
+
+__all__ = ["ModeProgressChecker", "PlaceholderHints"]

shotgun/tui/utils/mode_progress.py

@@ -0,0 +1,257 @@
+"""Utility module for checking mode progress in .shotgun directories."""
+
+import random
+from pathlib import Path
+
+from shotgun.agents.models import AgentType
+from shotgun.utils.file_system_utils import get_shotgun_base_path
+
+
+class ModeProgressChecker:
+    """Checks progress across different agent modes based on file contents."""
+
+    # Minimum file size in characters to consider a mode as "started"
+    MIN_CONTENT_SIZE = 20
+
+    # Map agent types to their corresponding files (in workflow order)
+    MODE_FILES = {
+        AgentType.RESEARCH: "research.md",
+        AgentType.SPECIFY: "specification.md",
+        AgentType.PLAN: "plan.md",
+        AgentType.TASKS: "tasks.md",
+        AgentType.EXPORT: "exports/",  # Export mode creates files in exports folder
+    }
+
+    def __init__(self, base_path: Path | None = None):
+        """Initialize the progress checker.
+
+        Args:
+            base_path: Base path for .shotgun directory. Defaults to current directory.
+        """
+        self.base_path = base_path or get_shotgun_base_path()
+
+    def has_mode_content(self, mode: AgentType) -> bool:
+        """Check if a mode has meaningful content.
+
+        Args:
+            mode: The agent mode to check.
+
+        Returns:
+            True if the mode has a file with >20 characters.
+        """
+        if mode not in self.MODE_FILES:
+            return False
+
+        file_or_dir = self.MODE_FILES[mode]
+
+        # Special handling for export mode (checks directory)
+        if mode == AgentType.EXPORT:
+            export_path = self.base_path / file_or_dir
+            if export_path.exists() and export_path.is_dir():
+                # Check if any files exist in exports directory
+                for item in export_path.glob("*"):
+                    if item.is_file() and not item.name.startswith("."):
+                        try:
+                            content = item.read_text(encoding="utf-8")
+                            if len(content.strip()) > self.MIN_CONTENT_SIZE:
+                                return True
+                        except (OSError, UnicodeDecodeError):
+                            continue
+            return False
+
+        # Check single file for other modes
+        file_path = self.base_path / file_or_dir
+        if not file_path.exists() or not file_path.is_file():
+            return False
+
+        try:
+            content = file_path.read_text(encoding="utf-8")
+            # Check if file has meaningful content
+            return len(content.strip()) > self.MIN_CONTENT_SIZE
+        except (OSError, UnicodeDecodeError):
+            return False
+
+    def get_next_suggested_mode(self, current_mode: AgentType) -> AgentType | None:
+        """Get the next suggested mode based on current progress.
+
+        Args:
+            current_mode: The current agent mode.
+
+        Returns:
+            The next suggested mode, or None if no suggestion.
+        """
+        mode_order = [
+            AgentType.RESEARCH,
+            AgentType.SPECIFY,
+            AgentType.TASKS,
+            AgentType.EXPORT,
+        ]
+
+        try:
+            current_index = mode_order.index(current_mode)
+        except ValueError:
+            # Mode not in standard order (e.g., PLAN mode)
+            return None
+
+        # Check if current mode has content
+        if not self.has_mode_content(current_mode):
+            # Current mode is empty, no suggestion for next mode
+            return None
+
+        # Get next mode in sequence
+        if current_index < len(mode_order) - 1:
+            return mode_order[current_index + 1]
+
+        # Export mode cycles back to Research
+        return mode_order[0]
+
+
+class PlaceholderHints:
+    """Manages dynamic placeholder hints for each mode based on progress."""
+
+    # Placeholder variations for each mode and state
+    HINTS = {
+        # Research mode
+        AgentType.RESEARCH: {
+            False: [
+                "Research a product or idea (SHIFT+TAB to cycle modes)",
+                "What would you like to explore? Start your research journey here (SHIFT+TAB to switch modes)",
+                "Dive into discovery mode - research anything that sparks curiosity (SHIFT+TAB for mode menu)",
+                "Ready to investigate? Feed me your burning questions (SHIFT+TAB to explore other modes)",
+                " 🔍 The research rabbit hole awaits! What shall we uncover? (SHIFT+TAB for mode carousel)",
+            ],
+            True: [
+                "Research complete! SHIFT+TAB to move to Specify mode",
+                "Great research! Time to specify (SHIFT+TAB to Specify mode)",
+                "Research done! Ready to create specifications (SHIFT+TAB to Specify)",
+                "Findings gathered! Move to specifications (SHIFT+TAB for Specify mode)",
+                " 🎯 Research complete! Advance to Specify mode (SHIFT+TAB)",
+            ],
+        },
+        # Specify mode
+        AgentType.SPECIFY: {
+            False: [
+                "Create detailed specifications and requirements (SHIFT+TAB to switch modes)",
+                "Define your project specifications here (SHIFT+TAB to navigate modes)",
+                "Time to get specific - write comprehensive specs (SHIFT+TAB for mode options)",
+                "Specification station: Document requirements and designs (SHIFT+TAB to change modes)",
+                " 📋 Spec-tacular time! Let's architect your ideas (SHIFT+TAB for mode magic)",
+            ],
+            True: [
+                "Specifications complete! SHIFT+TAB to create a Plan",
+                "Specs ready! Time to plan (SHIFT+TAB to Plan mode)",
+                "Requirements defined! Move to planning (SHIFT+TAB to Plan)",
+                "Specifications done! Create your roadmap (SHIFT+TAB for Plan mode)",
+                " 🚀 Specs complete! Advance to Plan mode (SHIFT+TAB)",
+            ],
+        },
+        # Tasks mode
+        AgentType.TASKS: {
+            False: [
+                "Break down your project into actionable tasks (SHIFT+TAB for modes)",
+                "Task creation time! Define your implementation steps (SHIFT+TAB to switch)",
+                "Ready to get tactical? Create your task list (SHIFT+TAB for mode options)",
+                "Task command center: Organize your work items (SHIFT+TAB to navigate)",
+                " ✅ Task mode activated! Break it down into bite-sized pieces (SHIFT+TAB)",
+            ],
+            True: [
+                "Tasks defined! Ready to export or cycle back (SHIFT+TAB)",
+                "Task list complete! Export your work (SHIFT+TAB to Export)",
+                "All tasks created! Time to export (SHIFT+TAB for Export mode)",
+                "Implementation plan ready! Export everything (SHIFT+TAB to Export)",
+                " 🎊 Tasks complete! Export your masterpiece (SHIFT+TAB)",
+            ],
+        },
+        # Export mode
+        AgentType.EXPORT: {
+            False: [
+                "Export your complete project documentation (SHIFT+TAB for modes)",
+                "Ready to package everything? Export time! (SHIFT+TAB to switch)",
+                "Export station: Generate deliverables (SHIFT+TAB for mode menu)",
+                "Time to share your work! Export documents (SHIFT+TAB to navigate)",
+                " 📦 Export mode! Package and share your creation (SHIFT+TAB)",
+            ],
+            True: [
+                "Exported! Start new research or continue refining (SHIFT+TAB)",
+                "Export complete! New cycle begins (SHIFT+TAB to Research)",
+                "All exported! Ready for another round (SHIFT+TAB for Research)",
+                "Documents exported! Start fresh (SHIFT+TAB to Research mode)",
+                " 🎉 Export complete! Begin a new adventure (SHIFT+TAB)",
+            ],
+        },
+        # Plan mode
+        AgentType.PLAN: {
+            False: [
+                "Create a strategic plan for your project (SHIFT+TAB for modes)",
+                "Planning phase: Map out your roadmap (SHIFT+TAB to switch)",
+                "Time to strategize! Create your project plan (SHIFT+TAB for options)",
+                "Plan your approach and milestones (SHIFT+TAB to navigate)",
+                " 🗺️ Plan mode! Chart your course to success (SHIFT+TAB)",
+            ],
+            True: [
+                "Plan complete! Move to Tasks mode (SHIFT+TAB)",
+                "Strategy ready! Time for tasks (SHIFT+TAB to Tasks mode)",
+                "Roadmap done! Create task list (SHIFT+TAB for Tasks)",
+                "Planning complete! Break into tasks (SHIFT+TAB to Tasks)",
+                " ⚡ Plan ready! Advance to Tasks mode (SHIFT+TAB)",
+            ],
+        },
+    }
+
+    def __init__(self, base_path: Path | None = None):
+        """Initialize placeholder hints with progress checker.
+
+        Args:
+            base_path: Base path for checking progress. Defaults to current directory.
+        """
+        self.progress_checker = ModeProgressChecker(base_path)
+        self._cached_hints: dict[tuple[AgentType, bool], str] = {}
+        self._hint_indices: dict[tuple[AgentType, bool], int] = {}
+
+    def get_hint(self, current_mode: AgentType, force_refresh: bool = False) -> str:
+        """Get a dynamic hint based on current mode and progress.
+
+        Args:
+            current_mode: The current agent mode.
+            force_refresh: Force recalculation of progress state.
+
+        Returns:
+            A contextual hint string for the placeholder.
+        """
+        # Default hint if mode not configured
+        if current_mode not in self.HINTS:
+            return f"Enter your {current_mode.value} mode prompt (SHIFT+TAB to switch modes)"
+
+        # Determine if mode has content
+        has_content = self.progress_checker.has_mode_content(current_mode)
+
+        # Get hint variations for this mode and state
+        hints_list = self.HINTS[current_mode][has_content]
+
+        # Cache key for this mode and state
+        cache_key = (current_mode, has_content)
+
+        # Force refresh or first time
+        if force_refresh or cache_key not in self._cached_hints:
+            # Initialize index for this cache key if not exists
+            if cache_key not in self._hint_indices:
+                self._hint_indices[cache_key] = random.randint(0, len(hints_list) - 1)  # noqa: S311
+
+            # Get hint at current index
+            hint_index = self._hint_indices[cache_key]
+            self._cached_hints[cache_key] = hints_list[hint_index]
+
+        return self._cached_hints[cache_key]
+
+    def get_placeholder_for_mode(self, current_mode: AgentType) -> str:
+        """Get placeholder text for a given mode.
+
+        This is an alias for get_hint() to maintain compatibility.
+
+        Args:
+            current_mode: The current agent mode.
+
+        Returns:
+            A contextual hint string for the placeholder.
+        """
+        return self.get_hint(current_mode)

{shotgun_sh-0.1.0.dev20.dist-info → shotgun_sh-0.1.0.dev23.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: shotgun-sh
-Version: 0.1.0.dev20
+Version: 0.1.0.dev23
 Summary: AI-powered research, planning, and task management CLI tool
 Project-URL: Homepage, https://shotgun.sh/
 Project-URL: Repository, https://github.com/shotgun-sh/shotgun
@@ -16,12 +16,11 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Utilities
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Requires-Dist: anthropic>=0.39.0
 Requires-Dist: google-generativeai>=0.8.5
 Requires-Dist: httpx>=0.27.0
@@ -177,7 +176,7 @@ The update command automatically detects and uses the appropriate method:
 
 ### Requirements
 
-- **Python 3.10+** (3.13 recommended)
+- **Python 3.11+** (3.13 recommended)
 - **uv** - Fast Python package installer and resolver
 - **actionlint** (optional) - For GitHub Actions workflow validation
 
@@ -289,17 +288,17 @@ go install github.com/rhysd/actionlint/cmd/actionlint@latest
 
 ### Python Version Management
 
-The project supports **Python 3.10+**. The `.python-version` file specifies Python 3.10 to ensure development against the minimum supported version.
+The project supports **Python 3.11+**. The `.python-version` file specifies Python 3.11 to ensure development against the minimum supported version.
 
 If using **pyenv**:
 ```bash
-pyenv install 3.10.16  # or latest 3.10.x
+pyenv install 3.11
 ```
 
 If using **uv** (recommended):
 ```bash
-uv python install 3.10
-uv sync --python 3.10
+uv python install 3.11
+uv sync --python 3.11
 ```
 
 ### Commit Message Convention
@@ -350,7 +349,7 @@ uv run cz commit
 
 GitHub Actions automatically:
 - Runs on pull requests and pushes to main
-- Tests with Python 3.10
+- Tests with Python 3.11
 - Validates code with ruff, ruff-format, and mypy
 - Ensures all checks pass before merge