shotgun-sh 0.2.8.dev2__py3-none-any.whl → 0.3.3.dev1__py3-none-any.whl

shotgun/llm_proxy/models.py

@@ -0,0 +1,137 @@
+"""Pydantic models for LiteLLM Proxy API."""
+
+from enum import StrEnum
+
+from pydantic import BaseModel, Field
+
+
+class BudgetSource(StrEnum):
+    """Source of budget information."""
+
+    KEY = "key"
+    TEAM = "team"
+
+
+class KeyInfoData(BaseModel):
+    """Key information data from /key/info endpoint."""
+
+    key_name: str = Field(description="Key name/identifier")
+    key_alias: str | None = Field(default=None, description="Human-readable key alias")
+    spend: float = Field(description="Current spend for this key in USD")
+    max_budget: float | None = Field(
+        default=None, description="Maximum budget for this key in USD"
+    )
+    team_id: str = Field(description="Team ID associated with this key")
+    user_id: str = Field(description="User ID associated with this key")
+    models: list[str] = Field(
+        default_factory=list, description="List of models available to this key"
+    )
+
+
+class KeyInfoResponse(BaseModel):
+    """Response from /key/info endpoint."""
+
+    key: str = Field(description="The API key")
+    info: KeyInfoData = Field(description="Key information data")
+
+
+class TeamInfoData(BaseModel):
+    """Team information data from /team/info endpoint."""
+
+    team_id: str = Field(description="Team identifier")
+    team_alias: str | None = Field(
+        default=None, description="Human-readable team alias"
+    )
+    max_budget: float | None = Field(
+        default=None, description="Maximum budget for this team in USD"
+    )
+    spend: float = Field(description="Current spend for this team in USD")
+    models: list[str] = Field(
+        default_factory=list, description="List of models available to this team"
+    )
+
+
+class TeamInfoResponse(BaseModel):
+    """Response from /team/info endpoint."""
+
+    team_id: str = Field(description="Team identifier")
+    team_info: TeamInfoData = Field(description="Team information data")
+
+
+class BudgetInfo(BaseModel):
+    """Unified budget information.
+
+    Combines key and team budget information to provide a single view
+    of budget status. Budget can come from either key-level or team-level,
+    with key-level taking priority if set.
+    """
+
+    max_budget: float = Field(description="Maximum budget in USD")
+    spend: float = Field(description="Current spend in USD")
+    remaining: float = Field(description="Remaining budget in USD")
+    source: BudgetSource = Field(
+        description="Source of budget information (key or team)"
+    )
+    percentage_used: float = Field(description="Percentage of budget used (0-100)")
+
+    @classmethod
+    def from_key_info(cls, key_info: KeyInfoData) -> "BudgetInfo":
+        """Create BudgetInfo from key-level budget.
+
+        Args:
+            key_info: Key information containing budget data
+
+        Returns:
+            BudgetInfo instance with key-level budget
+
+        Raises:
+            ValueError: If key does not have max_budget set
+        """
+        if key_info.max_budget is None:
+            raise ValueError("Key does not have max_budget set")
+
+        remaining = key_info.max_budget - key_info.spend
+        percentage_used = (
+            (key_info.spend / key_info.max_budget * 100)
+            if key_info.max_budget > 0
+            else 0.0
+        )
+
+        return cls(
+            max_budget=key_info.max_budget,
+            spend=key_info.spend,
+            remaining=remaining,
+            source=BudgetSource.KEY,
+            percentage_used=percentage_used,
+        )
+
+    @classmethod
+    def from_team_info(cls, team_info: TeamInfoData) -> "BudgetInfo":
+        """Create BudgetInfo from team-level budget.
+
+        Args:
+            team_info: Team information containing budget data
+
+        Returns:
+            BudgetInfo instance with team-level budget
+
+        Raises:
+            ValueError: If team does not have max_budget set
+        """
+        if team_info.max_budget is None:
+            raise ValueError("Team does not have max_budget set")
+
+        remaining = team_info.max_budget - team_info.spend
+        percentage_used = (
+            (team_info.spend / team_info.max_budget * 100)
+            if team_info.max_budget > 0
+            else 0.0
+        )
+
+        return cls(
+            max_budget=team_info.max_budget,
+            spend=team_info.spend,
+            remaining=remaining,
+            source=BudgetSource.TEAM,
+            percentage_used=percentage_used,
+        )

shotgun/logging_config.py

@@ -2,12 +2,16 @@
 
 import logging
 import logging.handlers
-import os
 import sys
+from datetime import datetime, timezone
 from pathlib import Path
 
+from shotgun.settings import settings
 from shotgun.utils.env_utils import is_truthy
 
+# Generate a single timestamp for this run to be used across all loggers
+_RUN_TIMESTAMP = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%SZ")
+
 
 def get_log_directory() -> Path:
     """Get the log directory path, creating it if necessary.
@@ -23,6 +27,44 @@ def get_log_directory() -> Path:
     return log_dir
 
 
+def cleanup_old_log_files(log_dir: Path, max_files: int) -> None:
+    """Remove old log files, keeping only the most recent ones.
+
+    Also removes the legacy shotgun.log file if it exists.
+
+    Args:
+        log_dir: Directory containing log files
+        max_files: Maximum number of log files to keep
+    """
+    try:
+        # Remove legacy non-timestamped log file if it exists
+        legacy_log = log_dir / "shotgun.log"
+        if legacy_log.exists():
+            try:
+                legacy_log.unlink()
+            except OSError:
+                pass  # noqa: S110
+
+        # Find all shotgun log files
+        log_files = sorted(
+            log_dir.glob("shotgun-*.log"),
+            key=lambda p: p.stat().st_mtime,
+            reverse=True,  # Newest first
+        )
+
+        # Remove files beyond the limit
+        files_to_delete = log_files[max_files:]
+        for log_file in files_to_delete:
+            try:
+                log_file.unlink()
+            except OSError:
+                # Ignore errors when deleting individual files
+                pass  # noqa: S110
+    except Exception:  # noqa: S110
+        # Silently fail - log cleanup shouldn't break the application
+        pass
+
+
 class ColoredFormatter(logging.Formatter):
     """Custom formatter with colors for different log levels."""
 
@@ -66,21 +108,16 @@ def setup_logger(
     logger = logging.getLogger(name)
 
     # Check if we already have a file handler
-    has_file_handler = any(
-        isinstance(h, logging.handlers.TimedRotatingFileHandler)
-        for h in logger.handlers
-    )
+    has_file_handler = any(isinstance(h, logging.FileHandler) for h in logger.handlers)
 
     # If we already have a file handler, just return the logger
     if has_file_handler:
         return logger
 
-    # Get log level from environment variable, default to INFO
-    env_level = os.getenv("SHOTGUN_LOG_LEVEL", "INFO").upper()
-    if env_level not in ["DEBUG", "INFO", "WARNING", "ERROR", "CRITICAL"]:
-        env_level = "INFO"
+    # Get log level from settings (already validated and uppercased)
+    log_level = settings.logging.log_level
 
-    logger.setLevel(getattr(logging, env_level))
+    logger.setLevel(getattr(logging, log_level))
 
     # Default format string
     if format_string is None:
@@ -102,13 +139,13 @@ def setup_logger(
     # Check if console logging is enabled (default: off)
     # Force console logging OFF if Logfire is enabled in dev build
     console_logging_enabled = (
-        is_truthy(os.getenv("LOGGING_TO_CONSOLE", "false")) and not is_logfire_dev_build
+        settings.logging.logging_to_console and not is_logfire_dev_build
     )
 
     if console_logging_enabled:
         # Create console handler
         console_handler = logging.StreamHandler(sys.stdout)
-        console_handler.setLevel(getattr(logging, env_level))
+        console_handler.setLevel(getattr(logging, log_level))
 
         # Use colored formatter for console
         console_formatter = ColoredFormatter(format_string, datefmt="%H:%M:%S")
@@ -118,26 +155,25 @@ def setup_logger(
         logger.addHandler(console_handler)
 
     # Check if file logging is enabled (default: on)
-    file_logging_enabled = is_truthy(os.getenv("LOGGING_TO_FILE", "true"))
+    file_logging_enabled = settings.logging.logging_to_file
 
     if file_logging_enabled:
         try:
-            # Create file handler with rotation
+            # Create file handler with ISO8601 timestamp for each run
             log_dir = get_log_directory()
-            log_file = log_dir / "shotgun.log"
 
-            # Use TimedRotatingFileHandler - rotates daily and keeps 7 days of logs
-            file_handler = logging.handlers.TimedRotatingFileHandler(
+            # Clean up old log files before creating a new one
+            cleanup_old_log_files(log_dir, settings.logging.max_log_files)
+
+            log_file = log_dir / f"shotgun-{_RUN_TIMESTAMP}.log"
+
+            # Use regular FileHandler - each run gets its own isolated log file
+            file_handler = logging.FileHandler(
                 filename=log_file,
-                when="midnight",  # Rotate at midnight
-                interval=1,  # Every 1 day
-                backupCount=7,  # Keep 7 days of logs
                 encoding="utf-8",
             )
 
-            # Also set max file size (10MB) using RotatingFileHandler as fallback
-            # Note: We'll use TimedRotatingFileHandler which handles both time and size
-            file_handler.setLevel(getattr(logging, env_level))
+            file_handler.setLevel(getattr(logging, log_level))
 
             # Use standard formatter for file (no colors)
             file_formatter = logging.Formatter(
@@ -191,10 +227,7 @@ def get_logger(name: str) -> logging.Logger:
     logger = logging.getLogger(name)
 
     # Check if we have a file handler already
-    has_file_handler = any(
-        isinstance(h, logging.handlers.TimedRotatingFileHandler)
-        for h in logger.handlers
-    )
+    has_file_handler = any(isinstance(h, logging.FileHandler) for h in logger.handlers)
 
     # If no file handler, set up the logger (will add file handler)
     if not has_file_handler:

shotgun/main.py

@@ -23,12 +23,16 @@ from dotenv import load_dotenv
 from shotgun import __version__
 from shotgun.agents.config import get_config_manager
 from shotgun.cli import (
+    clear,
     codebase,
+    compact,
     config,
+    context,
     export,
     feedback,
     plan,
     research,
+    spec,
     specify,
     tasks,
     update,
@@ -52,9 +56,13 @@ logger = get_logger(__name__)
 logger.debug("Logfire observability enabled: %s", _logfire_enabled)
 
 # Initialize configuration
+# Note: If config migration fails, ConfigManager will auto-create fresh config
+# and set migration_failed flag for user notification
 try:
+    import asyncio
+
     config_manager = get_config_manager()
-    config_manager.load()  # Ensure config is loaded at startup
+    asyncio.run(config_manager.load())  # Ensure config is loaded at startup
 except Exception as e:
     logger.debug("Configuration initialization warning: %s", e)
 
@@ -78,6 +86,9 @@ app.add_typer(config.app, name="config", help="Manage Shotgun configuration")
 app.add_typer(
     codebase.app, name="codebase", help="Manage and query code knowledge graphs"
 )
+app.add_typer(context.app, name="context", help="Analyze conversation context usage")
+app.add_typer(compact.app, name="compact", help="Compact conversation history")
+app.add_typer(clear.app, name="clear", help="Clear conversation history")
 app.add_typer(research.app, name="research", help="Perform research with agentic loops")
 app.add_typer(plan.app, name="plan", help="Generate structured plans")
 app.add_typer(specify.app, name="specify", help="Generate comprehensive specifications")
@@ -85,6 +96,7 @@ app.add_typer(tasks.app, name="tasks", help="Generate task lists with agentic ap
 app.add_typer(export.app, name="export", help="Export artifacts to various formats")
 app.add_typer(update.app, name="update", help="Check for and install updates")
 app.add_typer(feedback.app, name="feedback", help="Send us feedback")
+app.add_typer(spec.app, name="spec", help="Manage shared specifications")
 
 
 def version_callback(value: bool) -> None:
@@ -125,6 +137,41 @@ def main(
             help="Continue previous TUI conversation",
         ),
     ] = False,
+    web: Annotated[
+        bool,
+        typer.Option(
+            "--web",
+            help="Serve TUI as web application",
+        ),
+    ] = False,
+    port: Annotated[
+        int,
+        typer.Option(
+            "--port",
+            help="Port for web server (only used with --web)",
+        ),
+    ] = 8000,
+    host: Annotated[
+        str,
+        typer.Option(
+            "--host",
+            help="Host address for web server (only used with --web)",
+        ),
+    ] = "localhost",
+    public_url: Annotated[
+        str | None,
+        typer.Option(
+            "--public-url",
+            help="Public URL if behind proxy (only used with --web)",
+        ),
+    ] = None,
+    force_reindex: Annotated[
+        bool,
+        typer.Option(
+            "--force-reindex",
+            help="Force re-indexing of codebase (ignores existing index)",
+        ),
+    ] = False,
 ) -> None:
     """Shotgun - AI-powered CLI tool."""
     logger.debug("Starting shotgun CLI application")
@@ -134,16 +181,35 @@ def main(
         perform_auto_update_async(no_update_check=no_update_check)
 
     if ctx.invoked_subcommand is None and not ctx.resilient_parsing:
-        logger.debug("Launching shotgun TUI application")
-        try:
-            tui_app.run(
-                no_update_check=no_update_check, continue_session=continue_session
-            )
-        finally:
-            # Ensure PostHog is shut down cleanly even if TUI exits unexpectedly
-            from shotgun.posthog_telemetry import shutdown
-
-            shutdown()
+        if web:
+            logger.debug("Launching shotgun TUI as web application")
+            try:
+                tui_app.serve(
+                    host=host,
+                    port=port,
+                    public_url=public_url,
+                    no_update_check=no_update_check,
+                    continue_session=continue_session,
+                    force_reindex=force_reindex,
+                )
+            finally:
+                # Ensure PostHog is shut down cleanly even if server exits unexpectedly
+                from shotgun.posthog_telemetry import shutdown
+
+                shutdown()
+        else:
+            logger.debug("Launching shotgun TUI application")
+            try:
+                tui_app.run(
+                    no_update_check=no_update_check,
+                    continue_session=continue_session,
+                    force_reindex=force_reindex,
+                )
+            finally:
+                # Ensure PostHog is shut down cleanly even if TUI exits unexpectedly
+                from shotgun.posthog_telemetry import shutdown
+
+                shutdown()
         raise typer.Exit()
 
     # For CLI commands, register PostHog shutdown handler

shotgun/posthog_telemetry.py

@@ -8,8 +8,9 @@ from pydantic import BaseModel
 
 from shotgun import __version__
 from shotgun.agents.config import get_config_manager
-from shotgun.agents.conversation_manager import ConversationManager
+from shotgun.agents.conversation import ConversationManager
 from shotgun.logging_config import get_early_logger
+from shotgun.settings import settings
 
 # Use early logger to prevent automatic StreamHandler creation
 logger = get_early_logger(__name__)
@@ -17,6 +18,9 @@ logger = get_early_logger(__name__)
 # Global PostHog client instance
 _posthog_client = None
 
+# Cache the shotgun instance ID to avoid async calls during event tracking
+_shotgun_instance_id: str | None = None
+
 
 def setup_posthog_observability() -> bool:
     """Set up PostHog analytics for usage tracking.
@@ -24,7 +28,7 @@ def setup_posthog_observability() -> bool:
     Returns:
         True if PostHog was successfully set up, False otherwise
     """
-    global _posthog_client
+    global _posthog_client, _shotgun_instance_id
 
     try:
         # Check if PostHog is already initialized
@@ -32,10 +36,15 @@ def setup_posthog_observability() -> bool:
             logger.debug("PostHog is already initialized, skipping")
             return True
 
-        # Hardcoded PostHog configuration
-        api_key = "phc_KKnChzZUKeNqZDOTJ6soCBWNQSx3vjiULdwTR9H5Mcr"
+        # Get API key from settings (handles build constants + env vars automatically)
+        api_key = settings.telemetry.posthog_api_key
+
+        # If no API key is available, skip PostHog initialization
+        if not api_key:
+            logger.debug("No PostHog API key available, skipping initialization")
+            return False
 
-        logger.debug("Using hardcoded PostHog configuration")
+        logger.debug("Using PostHog API key from settings")
 
         # Determine environment based on version
         # Dev versions contain "dev", "rc", "alpha", or "beta"
@@ -51,29 +60,20 @@ def setup_posthog_observability() -> bool:
         # Store the client for later use
         _posthog_client = posthog
 
-        # Set user context with anonymous shotgun instance ID from config
+        # Cache the shotgun instance ID for later use (avoids async issues)
         try:
-            config_manager = get_config_manager()
-            shotgun_instance_id = config_manager.get_shotgun_instance_id()
-
-            # Identify the user in PostHog
-            posthog.identify(  # type: ignore[attr-defined]
-                distinct_id=shotgun_instance_id,
-                properties={
-                    "version": __version__,
-                    "environment": environment,
-                },
-            )
+            import asyncio
 
-            # Set default properties for all events
-            posthog.disabled = False
-            posthog.personal_api_key = None  # Not needed for event tracking
+            config_manager = get_config_manager()
+            _shotgun_instance_id = asyncio.run(config_manager.get_shotgun_instance_id())
 
             logger.debug(
-                "PostHog user identified with anonymous ID: %s", shotgun_instance_id
+                "PostHog initialized with shotgun instance ID: %s",
+                _shotgun_instance_id,
             )
         except Exception as e:
-            logger.warning("Failed to set user context: %s", e)
+            logger.warning("Failed to load shotgun instance ID: %s", e)
+            # Continue anyway - we'll try to get it during event tracking
 
         logger.debug(
             "PostHog analytics configured successfully (environment: %s, version: %s)",
@@ -94,16 +94,19 @@ def track_event(event_name: str, properties: dict[str, Any] | None = None) -> No
         event_name: Name of the event to track
         properties: Optional properties to include with the event
     """
-    global _posthog_client
+    global _posthog_client, _shotgun_instance_id
 
     if _posthog_client is None:
         logger.debug("PostHog not initialized, skipping event: %s", event_name)
         return
 
     try:
-        # Get shotgun instance ID for tracking
-        config_manager = get_config_manager()
-        shotgun_instance_id = config_manager.get_shotgun_instance_id()
+        # Use cached instance ID (loaded during setup)
+        if _shotgun_instance_id is None:
+            logger.warning(
+                "Shotgun instance ID not available, skipping event: %s", event_name
+            )
+            return
 
         # Add version and environment to properties
         if properties is None:
@@ -118,7 +121,7 @@ def track_event(event_name: str, properties: dict[str, Any] | None = None) -> No
 
         # Track the event using PostHog's capture method
         _posthog_client.capture(
-            distinct_id=shotgun_instance_id, event=event_name, properties=properties
+            distinct_id=_shotgun_instance_id, event=event_name, properties=properties
         )
         logger.debug("Tracked PostHog event: %s", event_name)
     except Exception as e:
@@ -162,10 +165,16 @@ def submit_feedback_survey(feedback: Feedback) -> None:
         logger.debug("PostHog not initialized, skipping feedback survey")
         return
 
+    import asyncio
+
     config_manager = get_config_manager()
-    config = config_manager.load()
+    config = asyncio.run(config_manager.load())
     conversation_manager = ConversationManager()
-    conversation = conversation_manager.load()
+    conversation = None
+    try:
+        conversation = asyncio.run(conversation_manager.load())
+    except Exception as e:
+        logger.debug(f"Failed to load conversation history: {e}")
     last_10_messages = []
     if conversation is not None:
         last_10_messages = conversation.get_agent_messages()[:10]

shotgun/prompts/agents/partials/common_agent_system_prompt.j2

@@ -4,12 +4,38 @@ Your extensive expertise spans, among other things:
 * Software Architecture
 * Software Development
 
+## YOUR ROLE IN THE PIPELINE
+
+**CRITICAL**: You are a DOCUMENTATION and PLANNING agent, NOT a coding/implementation agent.
+
+- You produce DOCUMENTS (research, specifications, plans, tasks) that AI coding agents will consume
+- You do NOT write production code, implement features, or make code changes
+- NEVER offer to "move forward with implementation" or "start coding" - that's not your job
+- NEVER ask "would you like me to implement this?" - implementation is done by separate AI coding tools
+- Your deliverable is always a document file (.md), not code execution
+- When your work is complete, the user will take your documents to a coding agent (Claude Code, Cursor, etc.)
+
+## AGENT FILE PERMISSIONS
+
+There are four agents in the pipeline, and each agent can ONLY write to specific files. The user can switch between agents using **Shift+Tab**.
+
+The **Research agent** can only write to `research.md`. If the user asks about specifications, plans, or tasks, tell them: "Use **Shift+Tab** to switch to the [appropriate] agent which can edit that file for you."
+
+The **Specification agent** can only write to `specification.md` and files inside the `.shotgun/contracts/` directory. If the user asks about research, plans, or tasks, tell them which agent handles that file.
+
+The **Plan agent** can only write to `plan.md`. If the user asks about research, specifications, or tasks, tell them which agent handles that file.
+
+The **Tasks agent** can only write to `tasks.md`. If the user asks about research, specifications, or plans, tell them which agent handles that file.
+
+When a user asks you to edit a file you cannot write to, you MUST tell them which agent can help and how to switch: "I can't edit [filename] - that's handled by the [agent name] agent. Use **Shift+Tab** to switch to that agent and it can edit that file for you."
+
 ## KEY RULES
 
 {% if interactive_mode %}
-0. Always ask CLARIFYING QUESTIONS using structured output if the user's request is ambiguous or lacks sufficient detail.
+0. Ask CLARIFYING QUESTIONS using structured output for complex or multi-step tasks when the request lacks sufficient detail.
    - Return your response with the clarifying_questions field populated
-   - Do not make assumptions about what the user wants
+   - For simple, straightforward requests, make reasonable assumptions and proceed.
+   - Only ask the most critical questions to avoid overwhelming the user.
    - Questions should be clear, specific, and answerable
 {% endif %}
 1. Above all, prefer using tools to do the work and NEVER respond with text.

shotgun/prompts/agents/partials/interactive_mode.j2

@@ -19,10 +19,10 @@ You must return responses using this structured format:
 
 ## When to Use Clarifying Questions
 
-- BEFORE GETTING TO WORK: If the user's request is ambiguous, use clarifying_questions to ask what they want
+- BEFORE GETTING TO WORK: For complex or multi-step tasks where the request is ambiguous or lacks sufficient detail, use clarifying_questions to ask what they want
 - DURING WORK: After using write_file(), you can suggest that the user review it and ask any clarifying questions with clarifying_questions
-- Don't assume - ask for confirmation of your understanding
-- When in doubt about any aspect of the goal, include clarifying_questions
+- For simple, straightforward requests, make reasonable assumptions and proceed
+- Only ask critical questions that significantly impact the outcome
 
 ## Important Notes
 

shotgun/prompts/agents/plan.j2

@@ -6,6 +6,22 @@ Your job is to help create comprehensive, actionable plans for software projects
 
 {% include 'agents/partials/common_agent_system_prompt.j2' %}
 
+## YOUR SCOPE AND HANDOFFS
+
+You are the **Plan agent**. Your file is `plan.md` - this is the ONLY file you can write to.
+
+When your plan is complete, suggest the next step:
+"I've completed the plan. Use **Shift+Tab** to switch to the tasks agent to break this plan into actionable tasks."
+
+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 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."
+
+NEVER offer to do work outside your scope:
+- Don't offer to write research, specifications, or tasks - redirect the user to the appropriate agent
+- Don't offer to implement code - you are not a coding agent
+
 ## MEMORY MANAGEMENT PROTOCOL
 
 - You have exclusive write access to: `plan.md`

shotgun/prompts/agents/research.j2

@@ -4,6 +4,22 @@ Your job is to help the user research various subjects related to their software
 
 {% include 'agents/partials/common_agent_system_prompt.j2' %}
 
+## YOUR SCOPE AND HANDOFFS
+
+You are the **Research agent**. Your file is `research.md` - this is the ONLY file you can write to.
+
+When your research is complete, suggest the next step:
+"I've completed the research and updated research.md. Use **Shift+Tab** to switch to the specification agent to create the specification based on this research."
+
+If the user asks you to edit other files, redirect them helpfully:
+- 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."
+- 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."
+
+NEVER offer to do work outside your scope:
+- Don't offer to write specifications, plans, or tasks - redirect the user to the appropriate agent
+- Don't offer to implement code - you are not a coding agent
+
 ## MEMORY MANAGEMENT PROTOCOL
 
 - You have exclusive write access to: `research.md`
@@ -38,9 +54,6 @@ For research tasks:
 
 ## RESEARCH PRINCIPLES
 
-{% if interactive_mode -%}
-- CRITICAL: BEFORE RUNNING ANY SEARCH TOOL, ASK THE USER FOR APPROVAL using clarifying questions. Include what you plan to search for and ask if they want you to proceed.
-{% endif -%}
 - Build upon existing research rather than starting from scratch
 - Focus on practical, actionable information over theoretical concepts
 - Include specific examples, tools, and implementation details