shotgun-sh 0.3.3.dev1__py3-none-any.whl → 0.4.0.dev1__py3-none-any.whl

shotgun/prompts/agents/specify.j2

@@ -1,26 +1,46 @@
 You are an experienced Specification Analyst.
 
-Your job is to help the user create comprehensive software specifications for their projects and maintain the specification.md file.
-
-Transform requirements into detailed, actionable specifications that development teams can implement.
+Your job is to help the user create software specifications and maintain the specification.md file.
 
 {% include 'agents/partials/common_agent_system_prompt.j2' %}
 
-## YOUR SCOPE AND HANDOFFS
+## CRITICAL: START MINIMAL, ASK QUESTIONS
 
-You are the **Specification agent**. Your files are `specification.md` and `.shotgun/contracts/*` - these are the ONLY files you can write to.
+**DO NOT write a comprehensive spec on the first pass.**
+
+Instead:
+1. **Write the bare minimum** - A skeleton spec with just the essentials
+2. **Ask clarifying questions** - What's unclear? What decisions need user input?
+3. **Iterate** - Expand the spec based on user answers
 
-When your specification is complete, suggest the next step:
-"I've completed the specification. Use **Shift+Tab** to switch to the plan agent to create an implementation plan based on this specification."
+**Your first response should:**
+- Create a minimal spec outline (TLDR + 2-3 key sections)
+- List 2-4 clarifying questions in `clarifying_questions`
+- NOT try to cover everything
 
-If the user asks you to edit other files, redirect them helpfully:
-- For research.md: "I can't edit research.md - that's handled by the research agent. Use **Shift+Tab** to switch to that agent and it can edit that file for you."
-- For plan.md: "I can't edit plan.md - that's handled by the plan agent. Use **Shift+Tab** to switch to that agent and it can edit that file for you."
-- For tasks.md: "I can't edit tasks.md - that's handled by the tasks agent. Use **Shift+Tab** to switch to that agent and it can edit that file for you."
+**Example first response:**
+```
+I've created a minimal specification outline for the evaluation system.
+
+Before I expand it, I have a few questions:
+1. Should the evaluation run as a CLI command or as part of CI/CD?
+2. What scoring scale do you prefer (1-5, 1-10, pass/fail)?
+3. Should results be stored persistently or just printed?
+```
 
-NEVER offer to do work outside your scope:
-- Don't offer to write research, plans, or tasks - redirect the user to the appropriate agent
-- Don't offer to implement code - you are not a coding agent
+**DO NOT:**
+- ❌ Write 8 detailed sections on the first pass
+- ❌ Invent requirements the user didn't ask for
+- ❌ Create comprehensive documentation without asking what's needed
+- ❌ Front-load all possible features
+
+**The user will tell you what to expand.** Start small.
+
+{% include 'agents/partials/router_delegation_mode.j2' %}
+
+## YOUR SCOPE
+
+You are the **Specification agent**. Your files are `specification.md` and `.shotgun/contracts/*` - these are the ONLY files you can write to.
 
 ## MEMORY MANAGEMENT PROTOCOL
 
@@ -50,6 +70,8 @@ specification.md is your prose documentation file. It should contain:
 - Configuration requirements described (e.g., "App needs database URL and API key in environment")
 - Testing strategies and acceptance criteria
 - References to contract files (e.g., "See contracts/user_models.py for User type definition")
+  - **IMPORTANT**: Only reference contract files that you have ALREADY created using `write_file()`
+  - Never reference contract files that don't exist - create them first, then reference them
 
 **DO NOT INCLUDE in specification.md:**
 - Code blocks, type definitions, or function signatures (those go in contracts/)
@@ -355,8 +377,9 @@ For specification tasks:
 2. **Check research**: Read `research.md` if it exists to understand technical context and findings
 3. **Analyze requirements**: Understand the functional and non-functional requirements
 4. **Define specifications**: Create detailed technical and functional specifications
-5. **Write TLDR section**: Start specification.md with a TLDR section summarizing key points, major features, and any key concerns
-6. **Structure documentation**: Use `write_file("specification.md", content)` to save comprehensive specifications
+5. **Create contract files FIRST**: If your spec will reference contract files, create them with `write_file("contracts/filename.ext", content)` BEFORE writing specification.md
+6. **Write TLDR section**: Start specification.md with a TLDR section summarizing key points, major features, and any key concerns
+7. **Structure documentation**: Use `write_file("specification.md", content)` to save comprehensive specifications - only reference contract files you've already created
 
 ## SPECIFICATION PRINCIPLES
 

shotgun/prompts/agents/state/system_state.j2

@@ -4,6 +4,20 @@ Your training data may be old. The current date and time is: {{ current_datetime
 
 {% include 'agents/state/codebase/codebase_graphs_available.j2' %}
 
+{% if execution_plan %}
+## Current Execution Plan
+
+{{ execution_plan }}
+
+{% if pending_approval %}
+**⚠️ PLAN AWAITING USER APPROVAL**
+
+The plan above requires user approval before execution can begin.
+You MUST call `final_result` now to present this plan to the user.
+Do NOT attempt to delegate to any sub-agents until the user approves.
+{% endif %}
+
+{% endif %}
 ## Available Files
 
 {% if existing_files %}
@@ -14,12 +28,7 @@ Your working files are:
 - `{{ file }}`
 {% endfor %}
 {% else %}
-No files currently exist in your allowed directories. You can create:
-- `research.md` - Research findings and analysis
-- `plan.md` - Project plans and roadmaps
-- `tasks.md` - Task lists and management
-- `specification.md` - Technical specifications
-- `exports/` folder - For exported documents
+No research or planning documents exist yet. Refer to your agent-specific instructions above for which files you can create.
 {% endif %}
 
 {% if markdown_toc %}

shotgun/prompts/agents/tasks.j2

@@ -4,21 +4,33 @@ Your job is to help create and manage actionable tasks for software projects and
 
 {% include 'agents/partials/common_agent_system_prompt.j2' %}
 
-## YOUR SCOPE AND HANDOFFS
+## CRITICAL: CREATE MINIMAL TASKS, ASK QUESTIONS
 
-You are the **Tasks agent**. Your file is `tasks.md` - this is the ONLY file you can write to.
+**DO NOT generate a comprehensive task list on the first pass.**
+
+Instead:
+1. **Create only essential tasks** - The minimum to start work
+2. **Ask clarifying questions** - What's the priority? What can wait?
+3. **Iterate** - Add tasks based on user feedback
+
+**Your first response should:**
+- Generate 3-5 high-priority tasks max
+- Ask if these are the right starting tasks
+- Identify what decisions affect task breakdown
+
+**DO NOT:**
+- ❌ Generate 20 tasks when 5 would start the work
+- ❌ Create tasks for every edge case
+- ❌ Add "nice to have" tasks without asking
+- ❌ Break simple work into many tiny tasks
 
-When your tasks are complete, suggest the next step:
-"I've created the task list in tasks.md. You can now take these tasks to a coding agent like Claude Code, Cursor, or Windsurf to implement them."
+**The user will tell you what to add.** Start with essentials.
 
-If the user asks you to edit other files, redirect them helpfully:
-- For research.md: "I can't edit research.md - that's handled by the research agent. Use **Shift+Tab** to switch to that agent and it can edit that file for you."
-- For specification.md or contracts: "I can't edit specification.md - that's handled by the specification agent. Use **Shift+Tab** to switch to that agent and it can edit that file for you."
-- For plan.md: "I can't edit plan.md - that's handled by the plan agent. Use **Shift+Tab** to switch to that agent and it can edit that file for you."
+{% include 'agents/partials/router_delegation_mode.j2' %}
 
-NEVER offer to do work outside your scope:
-- Don't offer to write research, specifications, or plans - redirect the user to the appropriate agent
-- Don't offer to implement code - you are not a coding agent
+## YOUR SCOPE
+
+You are the **Tasks agent**. Your file is `tasks.md` - this is the ONLY file you can write to.
 
 ## MEMORY MANAGEMENT PROTOCOL
 
@@ -27,9 +39,9 @@ NEVER offer to do work outside your scope:
 - This is your persistent memory store - ALWAYS load it first
 - Compress content regularly to stay within context limits
 - Keep your file updated as you work - it's your memory across sessions
-- Archive completed tasks to a compressed section at the bottom
+- Keep completed tasks marked with `[X]` for reference
 - Consolidate similar or duplicate tasks when compressing
-- Maintain structure: Active Tasks → Backlog → Archived (compressed)
+- Maintain structure: Stages with numbered tasks (Stage 1, Stage 2, etc.)
 
 ## AI AGENT PIPELINE AWARENESS
 
@@ -56,9 +68,10 @@ Example task format:
 For task management:
 1. **Load existing tasks**: ALWAYS first use `read_file("tasks.md")` to see what tasks already exist (if the file exists)
 2. **Review context**: Read `plan.md` and `specification.md` if they exist to understand project context
-3. **Analyze requirements**: Understand the current situation and user's task requirements
-4. **Create structured tasks**: Use `write_file("tasks.md", content)` to save organized tasks
-5. **Build incrementally**: Update and refine tasks based on new information
+3. **Verify paths exist**: Check the "Available Files" list in your System Status to see what files exist in `.shotgun/`. If a path doesn't exist, tasks must CREATE it, not modify files within it.
+4. **Analyze requirements**: Understand the current situation and user's task requirements
+5. **Create structured tasks**: Use `write_file("tasks.md", content)` to save organized tasks
+6. **Build incrementally**: Update and refine tasks based on new information
 
 ## TASK FORMAT
 
@@ -69,33 +82,36 @@ For task management:
 
 ## TASK FILE STRUCTURE
 
-Start tasks.md with these instructions:
+**CRITICAL**: Start tasks.md with instructions for AI coding agents, then organize tasks by stages. Do NOT include "In Progress", "Done", or "Blocked" sections - the checkboxes handle completion tracking.
+
 ```markdown
 # Task Management
 
-## Instructions
-- Mark tasks as complete by replacing `[ ]` with `[X]`
-- Tasks without an `[X]` are not finished yet
-```
+## Instructions for AI Coding Agents
 
-Then organize tasks into logical sections:
-```markdown
-## Backlog
-- [ ] Task description with clear action
-- [ ] Another specific task to complete
+When working on these tasks:
+1. Focus on ONE stage at a time, completing all tasks in that stage before moving to the next
+2. Mark each task complete by replacing `[ ]` with `[X]` as you finish it
+3. Do NOT modify any other content in this file unless explicitly instructed by the user
+4. Tasks without an `[X]` are not finished yet
 
-## In Progress
-- [ ] Currently working on this task
-- [ ] Task being actively developed
+---
 
-## Done
-- [X] Completed task for reference
-- [X] Another finished task
+### Stage 1: [Stage Name]
+- [ ] Task description with clear action
+- [ ] Another specific task to complete
 
-## Blocked
-- [ ] Task waiting on dependency (blocked by: reason)
+### Stage 2: [Stage Name]
+- [ ] Task in the next stage
+- [ ] Another task in this stage
 ```
 
+**IMPORTANT**:
+- Group related tasks under numbered stages (Stage 1, Stage 2, etc.)
+- Do NOT create separate "In Progress", "Done", or "Blocked" sections
+- The `[ ]` / `[X]` checkboxes are the ONLY mechanism for tracking completion
+- Each stage should be completable independently before moving to the next
+
 ## TASK CREATION PRINCIPLES
 
 - **ALWAYS use checkbox format `[ ]` for every task**
@@ -145,6 +161,14 @@ INTEGRATION WITH RESEARCH & PLAN:
 - Create validation/testing tasks for success criteria from plan
 - Break down high-level plan steps into granular, executable tasks
 
+PATH VERIFICATION (CRITICAL):
+- Before generating tasks that reference specific file paths in `.shotgun/`, check the "Available Files" list in your System Status
+- If specification.md references files under `.shotgun/contracts/` that don't appear in "Available Files", DO NOT generate tasks for those files
+  - The Specification agent is responsible for creating contract files, not downstream coding agents
+  - Tasks should reference files that EXIST or will be created in the project codebase (src/, tests/, etc.), not in `.shotgun/`
+- Only generate tasks for `.shotgun/` files if they appear in the "Available Files" list and the task is about modifying them
+- Do NOT generate tasks referencing `.shotgun/contracts/*` files unless those files already exist
+
 IMPORTANT RULES:
 - Make at most 1 tasks file write per request
 - Always base tasks on available research and plan when relevant

shotgun/tui/app.py

@@ -13,6 +13,7 @@ from shotgun.agents.config import (
 from shotgun.agents.models import AgentType
 from shotgun.logging_config import get_logger
 from shotgun.tui.containers import TUIContainer
+from shotgun.tui.dependencies import create_default_router_deps
 from shotgun.tui.screens.splash import SplashScreen
 from shotgun.utils.file_system_utils import (
     ensure_shotgun_directory_exists,
@@ -166,13 +167,11 @@ class ShotgunApp(App[None]):
                 return
 
             # Create ChatScreen with all dependencies injected from container
-            # Get the default agent mode (RESEARCH)
-            agent_mode = AgentType.RESEARCH
+            # Get the default agent mode (ROUTER)
+            agent_mode = AgentType.ROUTER
 
-            # Create AgentDeps asynchronously (get_provider_model is now async)
-            from shotgun.tui.dependencies import create_default_tui_deps
-
-            agent_deps = await create_default_tui_deps()
+            # Create RouterDeps asynchronously (get_provider_model is now async)
+            agent_deps = await create_default_router_deps()
 
             # Create AgentManager with async initialization
             agent_manager = AgentManager(deps=agent_deps, initial_type=agent_mode)

shotgun/tui/components/mode_indicator.py

@@ -1,20 +1,68 @@
 """Widget to display the current agent mode."""
 
+from enum import StrEnum
+
 from textual.widget import Widget
 
 from shotgun.agents.models import AgentType
-from shotgun.tui.protocols import QAStateProvider
+from shotgun.agents.router.models import RouterMode
+from shotgun.tui.protocols import (
+    ActiveSubAgentProvider,
+    QAStateProvider,
+    RouterModeProvider,
+)
 from shotgun.tui.utils.mode_progress import PlaceholderHints
 
 
+class RouterModeCssClass(StrEnum):
+    """CSS class names for router mode styling."""
+
+    PLANNING = "mode-planning"
+    DRAFTING = "mode-drafting"
+
+
+# Shared display name mapping for agent types
+AGENT_DISPLAY_NAMES: dict[AgentType, str] = {
+    AgentType.RESEARCH: "Research",
+    AgentType.SPECIFY: "Specify",
+    AgentType.PLAN: "Planning",
+    AgentType.TASKS: "Tasks",
+    AgentType.EXPORT: "Export",
+}
+
+# Mode descriptions for legacy agent display
+AGENT_DESCRIPTIONS: dict[AgentType, str] = {
+    AgentType.RESEARCH: "Research topics with web search and synthesize findings",
+    AgentType.PLAN: "Create comprehensive, actionable plans with milestones",
+    AgentType.TASKS: "Generate specific, actionable tasks from research and plans",
+    AgentType.SPECIFY: "Create detailed specifications and requirements documents",
+    AgentType.EXPORT: "Export artifacts and findings to various formats",
+}
+
+
 class ModeIndicator(Widget):
-    """Widget to display the current agent mode."""
+    """Widget to display the current agent mode.
+
+    For router mode, displays:
+    - Idle: "📋 Planning mode" or "✍️ Drafting mode"
+    - During execution: "📋 Planning → Research" format
+
+    For legacy agents, displays the agent name and description.
+    """
 
     DEFAULT_CSS = """
         ModeIndicator {
             text-wrap: wrap;
             padding-left: 1;
         }
+
+        ModeIndicator.mode-planning {
+            /* Planning mode styling - blue/cyan accent */
+        }
+
+        ModeIndicator.mode-drafting {
+            /* Drafting mode styling - green accent */
+        }
     """
 
     def __init__(self, mode: AgentType) -> None:
@@ -29,41 +77,88 @@ class ModeIndicator(Widget):
 
     def render(self) -> str:
         """Render the mode indicator."""
-        # Check if in Q&A mode first
+        # Check if in Q&A mode first - takes priority
         if isinstance(self.screen, QAStateProvider) and self.screen.qa_mode:
             return (
                 "[bold $text-accent]Q&A mode[/]"
                 "[$foreground-muted] (Answer the clarifying questions or ESC to cancel)[/]"
             )
 
-        mode_display = {
-            AgentType.RESEARCH: "Research",
-            AgentType.PLAN: "Planning",
-            AgentType.TASKS: "Tasks",
-            AgentType.SPECIFY: "Specify",
-            AgentType.EXPORT: "Export",
-        }
-        mode_description = {
-            AgentType.RESEARCH: (
-                "Research topics with web search and synthesize findings"
-            ),
-            AgentType.PLAN: "Create comprehensive, actionable plans with milestones",
-            AgentType.TASKS: (
-                "Generate specific, actionable tasks from research and plans"
-            ),
-            AgentType.SPECIFY: (
-                "Create detailed specifications and requirements documents"
-            ),
-            AgentType.EXPORT: "Export artifacts and findings to various formats",
-        }
+        # Router mode display
+        if self.mode == AgentType.ROUTER:
+            return self._render_router_mode()
 
-        mode_title = mode_display.get(self.mode, self.mode.value.title())
-        description = mode_description.get(self.mode, "")
+        # Legacy agent mode display
+        return self._render_legacy_mode()
+
+    def _render_router_mode(self) -> str:
+        """Render the router mode indicator.
+
+        Shows:
+        - "📋 Planning mode" or "✍️ Drafting mode" when idle
+        - "📋 Planning → Research" format when sub-agent is executing
+        """
+        # Get router mode from screen
+        router_mode: str | None = None
+        if isinstance(self.screen, RouterModeProvider):
+            router_mode = self.screen.router_mode
+
+        # Get active sub-agent from screen
+        active_sub_agent: AgentType | None = None
+        if isinstance(self.screen, ActiveSubAgentProvider):
+            sub_agent_str = self.screen.active_sub_agent
+            if sub_agent_str:
+                # Convert string back to AgentType enum
+                try:
+                    active_sub_agent = AgentType(sub_agent_str)
+                except ValueError:
+                    pass
+
+        # Determine mode display using RouterMode enum
+        if router_mode == RouterMode.DRAFTING.value:
+            icon = "✍️"
+            mode_name = "Drafting"
+            description = "Auto-execute without confirmation"
+            css_class = RouterModeCssClass.DRAFTING
+        else:
+            # Default to planning mode
+            icon = "📋"
+            mode_name = "Planning"
+            description = "Review plans before execution"
+            css_class = RouterModeCssClass.PLANNING
+
+        # Update CSS class for styling
+        self.set_classes(css_class)
+
+        # Add sub-agent suffix if executing
+        if active_sub_agent:
+            # Use shared display name mapping
+            sub_agent_name = AGENT_DISPLAY_NAMES.get(
+                active_sub_agent, active_sub_agent.value.title()
+            )
+            return f"[bold $text-accent]{icon} {mode_name} → {sub_agent_name}[/]"
+
+        return (
+            f"[bold $text-accent]{icon} {mode_name} mode[/]"
+            f"[$foreground-muted] ({description})[/]"
+        )
+
+    def _render_legacy_mode(self) -> str:
+        """Render the legacy agent mode indicator.
+
+        Shows the agent name with description and content status.
+        """
+        mode_title = AGENT_DISPLAY_NAMES.get(self.mode, self.mode.value.title())
+        description = AGENT_DESCRIPTIONS.get(self.mode, "")
 
         # Check if mode has content
         has_content = self.progress_checker.has_mode_content(self.mode)
         status_icon = " ✓" if has_content else ""
 
+        # Clear any router mode CSS classes
+        self.remove_class(RouterModeCssClass.PLANNING)
+        self.remove_class(RouterModeCssClass.DRAFTING)
+
         return (
             f"[bold $text-accent]{mode_title}{status_icon} mode[/]"
             f"[$foreground-muted] ({description})[/]"

shotgun/tui/components/status_bar.py

@@ -37,12 +37,12 @@ class StatusBar(Widget):
             return (
                 "[$foreground-muted][bold $text]esc[/] to stop • "
                 "[bold $text]enter[/] to send • [bold $text]ctrl+j[/] for newline • "
-                "[bold $text]ctrl+p[/] command palette • [bold $text]shift+tab[/] cycle modes • "
+                "[bold $text]ctrl+p[/] command palette • [bold $text]shift+tab[/] toggle mode • "
                 "/help for commands[/]"
             )
         else:
             return (
                 "[$foreground-muted][bold $text]enter[/] to send • "
                 "[bold $text]ctrl+j[/] for newline • [bold $text]ctrl+p[/] command palette • "
-                "[bold $text]shift+tab[/] cycle modes • /help for commands[/]"
+                "[bold $text]shift+tab[/] toggle mode • /help for commands[/]"
             )

shotgun/tui/dependencies.py

@@ -1,13 +1,44 @@
 """Dependency creation utilities for TUI components."""
 
+from typing import Any
+
 from pydantic_ai import RunContext
 
-from shotgun.agents.config import get_provider_model
+from shotgun.agents.config import get_config_manager, get_provider_model
+from shotgun.agents.config.models import ModelConfig
 from shotgun.agents.models import AgentDeps
+from shotgun.agents.router.models import RouterDeps, RouterMode
+from shotgun.codebase.service import CodebaseService
 from shotgun.tui.filtered_codebase_service import FilteredCodebaseService
 from shotgun.utils import get_shotgun_home
 
 
+async def _get_tui_config() -> tuple[ModelConfig, CodebaseService]:
+    """Get common TUI configuration components.
+
+    Returns:
+        Tuple of (model_config, codebase_service) for TUI deps.
+    """
+    model_config = await get_provider_model()
+    storage_dir = get_shotgun_home() / "codebases"
+    codebase_service = FilteredCodebaseService(storage_dir)
+    return model_config, codebase_service
+
+
+def _placeholder_system_prompt_fn(ctx: RunContext[Any]) -> str:
+    """Placeholder system prompt that should never be called.
+
+    Agents provide their own system_prompt_fn via their create functions.
+    This placeholder exists only to satisfy the AgentDeps requirement.
+
+    Raises:
+        RuntimeError: Always, as this should never be invoked.
+    """
+    raise RuntimeError(
+        "This should not be called - agents provide their own system_prompt_fn"
+    )
+
+
 async def create_default_tui_deps() -> AgentDeps:
     """Create default AgentDeps for TUI components.
 
@@ -21,14 +52,7 @@ async def create_default_tui_deps() -> AgentDeps:
     Returns:
         Configured AgentDeps instance ready for TUI use.
     """
-    model_config = await get_provider_model()
-    storage_dir = get_shotgun_home() / "codebases"
-    codebase_service = FilteredCodebaseService(storage_dir)
-
-    def _placeholder_system_prompt_fn(ctx: RunContext[AgentDeps]) -> str:
-        raise RuntimeError(
-            "This should not be called - agents provide their own system_prompt_fn"
-        )
+    model_config, codebase_service = await _get_tui_config()
 
     return AgentDeps(
         interactive_mode=True,
@@ -37,3 +61,34 @@ async def create_default_tui_deps() -> AgentDeps:
         codebase_service=codebase_service,
         system_prompt_fn=_placeholder_system_prompt_fn,
     )
+
+
+async def create_default_router_deps() -> RouterDeps:
+    """Create default RouterDeps for TUI components with router mode.
+
+    This creates a RouterDeps configuration suitable for interactive
+    TUI usage with:
+    - Router mode loaded from config (default: PLANNING)
+    - Interactive mode enabled
+    - TUI context flag set
+    - Filtered codebase service (restricted to CWD)
+    - Placeholder system prompt (router provides its own)
+
+    Returns:
+        Configured RouterDeps instance ready for TUI use.
+    """
+    model_config, codebase_service = await _get_tui_config()
+
+    # Load router mode from config (default to PLANNING)
+    config_manager = get_config_manager()
+    config = await config_manager.load()
+    router_mode = RouterMode(config.router_mode)
+
+    return RouterDeps(
+        interactive_mode=True,
+        is_tui_context=True,
+        llm_model=model_config,
+        codebase_service=codebase_service,
+        system_prompt_fn=_placeholder_system_prompt_fn,
+        router_mode=router_mode,
+    )

shotgun/tui/protocols.py

@@ -43,3 +43,40 @@ class ProcessingStateProvider(Protocol):
             True if an agent is processing, False otherwise.
         """
         ...
+
+
+@runtime_checkable
+class RouterModeProvider(Protocol):
+    """Protocol for screens that provide router mode state.
+
+    This protocol allows components to check the current router mode
+    (Planning or Drafting) without importing the concrete ChatScreen class.
+    """
+
+    @property
+    def router_mode(self) -> str | None:
+        """The current router mode.
+
+        Returns:
+            'planning' or 'drafting' if in router mode, None otherwise.
+        """
+        ...
+
+
+@runtime_checkable
+class ActiveSubAgentProvider(Protocol):
+    """Protocol for screens that provide active sub-agent state.
+
+    This protocol allows components to check which sub-agent is currently
+    executing during router delegation without importing ChatScreen.
+    """
+
+    @property
+    def active_sub_agent(self) -> str | None:
+        """The currently executing sub-agent type.
+
+        Returns:
+            The sub-agent type string (e.g., 'research', 'specify') if
+            a sub-agent is executing, None if idle.
+        """
+        ...

shotgun/tui/screens/chat/chat.tcss

@@ -16,11 +16,19 @@ ModeIndicator {
   height: auto;
 }
 
+ModeIndicator.mode-planning {
+  /* Blue/cyan accent for planning mode */
+}
+
+ModeIndicator.mode-drafting {
+  /* Green accent for drafting mode */
+}
+
 #footer {
   dock: bottom;
   height: auto;
   padding: 1 1 1 2;
-  max-height: 14;
+  max-height: 24;
 }
 
 #window {