stravinsky 0.2.40__py3-none-any.whl → 0.2.67__py3-none-any.whl

mcp_bridge/hooks/todo_continuation.py

@@ -0,0 +1,90 @@
+#!/usr/bin/env python3
+"""
+UserPromptSubmit hook: Todo Continuation Enforcer
+
+Checks if there are incomplete todos (in_progress or pending) and injects
+a reminder to continue working on them before starting new work.
+
+Aligned with oh-my-opencode's [SYSTEM REMINDER - TODO CONTINUATION] pattern.
+"""
+import json
+import os
+import sys
+from pathlib import Path
+
+
+def get_todo_state() -> dict:
+    """Try to get current todo state from Claude Code session or local cache."""
+    # Claude Code stores todo state - we can check via session files
+    # For now, we'll use a simple file-based approach
+    cwd = Path(os.environ.get("CLAUDE_CWD", "."))
+    todo_cache = cwd / ".claude" / "todo_state.json"
+
+    if todo_cache.exists():
+        try:
+            return json.loads(todo_cache.read_text())
+        except Exception:
+            pass
+
+    return {"todos": []}
+
+
+def main():
+    try:
+        data = json.load(sys.stdin)
+        prompt = data.get("prompt", "")
+    except Exception:
+        return 0
+
+    # Get current todo state
+    state = get_todo_state()
+    todos = state.get("todos", [])
+
+    if not todos:
+        # No todos tracked, pass through
+        print(prompt)
+        return 0
+
+    # Count incomplete todos
+    in_progress = [t for t in todos if t.get("status") == "in_progress"]
+    pending = [t for t in todos if t.get("status") == "pending"]
+
+    if not in_progress and not pending:
+        # All todos complete, pass through
+        print(prompt)
+        return 0
+
+    # Build reminder
+    reminder_parts = ["[SYSTEM REMINDER - TODO CONTINUATION]", ""]
+
+    if in_progress:
+        reminder_parts.append(f"IN PROGRESS ({len(in_progress)} items):")
+        for t in in_progress:
+            reminder_parts.append(f"  - {t.get('content', 'Unknown task')}")
+        reminder_parts.append("")
+
+    if pending:
+        reminder_parts.append(f"PENDING ({len(pending)} items):")
+        for t in pending[:5]:  # Show max 5 pending
+            reminder_parts.append(f"  - {t.get('content', 'Unknown task')}")
+        if len(pending) > 5:
+            reminder_parts.append(f"  ... and {len(pending) - 5} more")
+        reminder_parts.append("")
+
+    reminder_parts.extend([
+        "IMPORTANT: You have incomplete work. Before starting anything new:",
+        "1. Continue working on IN_PROGRESS todos first",
+        "2. If blocked, explain why and move to next PENDING item",
+        "3. Only start NEW work if all todos are complete or explicitly abandoned",
+        "",
+        "---",
+        "",
+    ])
+
+    reminder = "\n".join(reminder_parts)
+    print(reminder + prompt)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

mcp_bridge/hooks/todo_delegation.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+"""
+PostToolUse hook for TodoWrite: CRITICAL parallel execution enforcer.
+
+This hook fires AFTER TodoWrite completes. If there are 2+ pending items,
+it outputs a STRONG reminder that Task agents must be spawned immediately.
+
+Exit code 2 is used to signal a HARD BLOCK - Claude should see this as
+a failure condition requiring immediate correction.
+
+Works in tandem with:
+- parallel_execution.py (UserPromptSubmit): Pre-emptive instruction injection
+- stravinsky_mode.py (PreToolUse): Hard blocking of Read/Grep/Bash tools
+"""
+import json
+import sys
+from pathlib import Path
+
+# Check if stravinsky mode is active (hard blocking enabled)
+STRAVINSKY_MODE_FILE = Path.home() / ".stravinsky_mode"
+
+
+def is_stravinsky_mode():
+    """Check if hard blocking mode is active."""
+    return STRAVINSKY_MODE_FILE.exists()
+
+
+def main():
+    # Read hook input from stdin
+    try:
+        hook_input = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        return 0
+
+    tool_name = hook_input.get("tool_name", "")
+
+    if tool_name != "TodoWrite":
+        return 0
+
+    # Get the todos that were just written
+    tool_input = hook_input.get("tool_input", {})
+    todos = tool_input.get("todos", [])
+
+    # Count pending todos
+    pending_count = sum(1 for t in todos if t.get("status") == "pending")
+
+    if pending_count < 2:
+        return 0
+
+    # Check if stravinsky mode is active
+    stravinsky_active = is_stravinsky_mode()
+
+    # CRITICAL: Output urgent reminder for parallel Task spawning
+    mode_warning = ""
+    if stravinsky_active:
+        mode_warning = """
+⚠️ STRAVINSKY MODE ACTIVE - Direct tools (Read, Grep, Bash) are BLOCKED.
+   You MUST use Task(subagent_type="explore", ...) for ALL file operations.
+"""
+
+    error_message = f"""
+🚨 PARALLEL DELEGATION REQUIRED 🚨
+
+TodoWrite created {pending_count} pending items.
+{mode_warning}
+You MUST spawn Task agents for ALL independent TODOs in THIS SAME RESPONSE.
+
+Required pattern (IMMEDIATELY after this message):
+Task(subagent_type="explore", prompt="TODO 1...", description="TODO 1", run_in_background=true)
+Task(subagent_type="explore", prompt="TODO 2...", description="TODO 2", run_in_background=true)
+...
+
+DO NOT:
+- End your response without spawning Tasks
+- Mark TODOs in_progress before spawning Tasks
+- Use Read/Grep/Bash directly (BLOCKED in stravinsky mode)
+
+Your NEXT action MUST be multiple Task() calls, one for each independent TODO.
+"""
+    print(error_message, file=sys.stderr)
+
+    # Exit code 2 = HARD BLOCK in stravinsky mode
+    # Exit code 1 = WARNING otherwise
+    return 2 if stravinsky_active else 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

mcp_bridge/hooks/tool_messaging.py

@@ -0,0 +1,164 @@
+#!/usr/bin/env python3
+"""
+PostToolUse hook for user-friendly tool messaging.
+
+Outputs concise messages about which agent/tool was used and what it did.
+Format examples:
+- ast-grep('Searching for authentication patterns')
+- delphi:openai/gpt-5.2-medium('Analyzing architecture trade-offs')
+- explore:gemini-3-flash('Finding all API endpoints')
+"""
+
+import json
+import os
+import sys
+
+# Agent model mappings
+AGENT_MODELS = {
+    "explore": "gemini-3-flash",
+    "dewey": "gemini-3-flash",
+    "code-reviewer": "sonnet",
+    "debugger": "sonnet",
+    "frontend": "gemini-3-pro-high",
+    "delphi": "gpt-5.2-medium",
+}
+
+# Tool display names
+TOOL_NAMES = {
+    "mcp__stravinsky__ast_grep_search": "ast-grep",
+    "mcp__stravinsky__grep_search": "grep",
+    "mcp__stravinsky__glob_files": "glob",
+    "mcp__stravinsky__lsp_diagnostics": "lsp-diagnostics",
+    "mcp__stravinsky__lsp_hover": "lsp-hover",
+    "mcp__stravinsky__lsp_goto_definition": "lsp-goto-def",
+    "mcp__stravinsky__lsp_find_references": "lsp-find-refs",
+    "mcp__stravinsky__lsp_document_symbols": "lsp-symbols",
+    "mcp__stravinsky__lsp_workspace_symbols": "lsp-workspace-symbols",
+    "mcp__stravinsky__invoke_gemini": "gemini",
+    "mcp__stravinsky__invoke_openai": "openai",
+    "mcp__grep-app__searchCode": "grep.app",
+    "mcp__grep-app__github_file": "github-file",
+}
+
+
+def extract_description(tool_name: str, params: dict) -> str:
+    """Extract a concise description of what the tool did."""
+
+    # AST-grep
+    if "ast_grep" in tool_name:
+        pattern = params.get("pattern", "")
+        directory = params.get("directory", ".")
+        return f"Searching AST in {directory} for '{pattern[:40]}...'"
+
+    # Grep/search
+    if "grep_search" in tool_name or "searchCode" in tool_name:
+        pattern = params.get("pattern", params.get("query", ""))
+        return f"Searching for '{pattern[:40]}...'"
+
+    # Glob
+    if "glob_files" in tool_name:
+        pattern = params.get("pattern", "")
+        return f"Finding files matching '{pattern}'"
+
+    # LSP diagnostics
+    if "lsp_diagnostics" in tool_name:
+        file_path = params.get("file_path", "")
+        filename = os.path.basename(file_path) if file_path else "file"
+        return f"Checking {filename} for errors"
+
+    # LSP hover
+    if "lsp_hover" in tool_name:
+        file_path = params.get("file_path", "")
+        line = params.get("line", "")
+        filename = os.path.basename(file_path) if file_path else "file"
+        return f"Type info for {filename}:{line}"
+
+    # LSP goto definition
+    if "lsp_goto" in tool_name:
+        file_path = params.get("file_path", "")
+        filename = os.path.basename(file_path) if file_path else "symbol"
+        return f"Finding definition in {filename}"
+
+    # LSP find references
+    if "lsp_find_references" in tool_name:
+        file_path = params.get("file_path", "")
+        filename = os.path.basename(file_path) if file_path else "symbol"
+        return f"Finding all references to symbol in {filename}"
+
+    # LSP symbols
+    if "lsp_symbols" in tool_name or "lsp_document_symbols" in tool_name:
+        file_path = params.get("file_path", "")
+        filename = os.path.basename(file_path) if file_path else "file"
+        return f"Getting symbols from {filename}"
+
+    if "lsp_workspace_symbols" in tool_name:
+        query = params.get("query", "")
+        return f"Searching workspace for symbol '{query}'"
+
+    # Gemini invocation
+    if "invoke_gemini" in tool_name:
+        prompt = params.get("prompt", "")
+        # Extract first meaningful line
+        first_line = prompt.split('\n')[0][:50] if prompt else "Processing"
+        return first_line
+
+    # OpenAI invocation
+    if "invoke_openai" in tool_name:
+        prompt = params.get("prompt", "")
+        first_line = prompt.split('\n')[0][:50] if prompt else "Strategic analysis"
+        return first_line
+
+    # GitHub file fetch
+    if "github_file" in tool_name:
+        path = params.get("path", "")
+        repo = params.get("repo", "")
+        return f"Fetching {path} from {repo}"
+
+    # Task delegation
+    if tool_name == "Task":
+        subagent_type = params.get("subagent_type", "unknown")
+        description = params.get("description", "")
+        model = AGENT_MODELS.get(subagent_type, "unknown")
+        return f"{subagent_type}:{model}('{description}')"
+
+    return "Processing"
+
+
+def main():
+    try:
+        # Read hook input from stdin
+        hook_input = json.loads(sys.stdin.read())
+
+        tool_name = hook_input.get("toolName", hook_input.get("tool_name", ""))
+        params = hook_input.get("params", hook_input.get("tool_input", {}))
+
+        # Only output messages for MCP tools and Task delegations
+        if not (tool_name.startswith("mcp__") or tool_name == "Task"):
+            sys.exit(0)
+
+        # Get tool display name
+        display_name = TOOL_NAMES.get(tool_name, tool_name)
+
+        # Special handling for Task delegations
+        if tool_name == "Task":
+            subagent_type = params.get("subagent_type", "unknown")
+            description = params.get("description", "")
+            model = AGENT_MODELS.get(subagent_type, "unknown")
+
+            # Show full agent delegation message
+            print(f"🎯 {subagent_type}:{model}('{description}')", file=sys.stderr)
+        else:
+            # Regular tool usage
+            description = extract_description(tool_name, params)
+            print(f"🔧 {display_name}('{description}')", file=sys.stderr)
+
+        sys.exit(0)
+
+    except Exception as e:
+        # On error, fail silently (don't disrupt workflow)
+        print(f"Tool messaging hook error: {e}", file=sys.stderr)
+        sys.exit(0)
+
+
+if __name__ == "__main__":
+    main()

mcp_bridge/hooks/truncator.py

@@ -1,19 +1,23 @@
-"""
-Tool output truncator hook.
-Limits the size of tool outputs to prevent context bloat.
-"""
+import os
+import sys
+import json
 
-from typing import Any, Dict, Optional
+MAX_CHARS = 30000
 
-async def output_truncator_hook(tool_name: str, arguments: Dict[str, Any], output: str) -> Optional[str]:
-    """
-    Truncates tool output if it exceeds a certain length.
-    """
-    MAX_LENGTH = 30000 # 30k characters limit
-    
-    if len(output) > MAX_LENGTH:
-        truncated = output[:MAX_LENGTH]
-        summary = f"\n\n... (Result truncated from {len(output)} chars to {MAX_LENGTH} chars) ..."
-        return truncated + summary
-        
-    return None
+def main():
+    try:
+        data = json.load(sys.stdin)
+        tool_response = data.get("tool_response", "")
+    except Exception:
+        return
+
+    if len(tool_response) > MAX_CHARS:
+        header = f"[TRUNCATED - {len(tool_response)} chars reduced to {MAX_CHARS}]\n"
+        footer = "\n...[TRUNCATED]"
+        truncated = tool_response[:MAX_CHARS]
+        print(header + truncated + footer)
+    else:
+        print(tool_response)
+
+if __name__ == "__main__":
+    main()

mcp_bridge/prompts/__init__.py

@@ -6,13 +6,15 @@ from . import explore
 from . import frontend
 from . import document_writer
 from . import multimodal
+from . import planner
 
 __all__ = [
     "stravinsky",
-    "delphi", 
+    "delphi",
     "dewey",
     "explore",
     "frontend",
     "document_writer",
     "multimodal",
+    "planner",
 ]

mcp_bridge/prompts/dewey.py

@@ -50,8 +50,8 @@ Classify EVERY request into one of these categories before taking action:
 
 | Type | Trigger Examples | Tools |
 |------|------------------|-------|
-| **TYPE A: CONCEPTUAL** | "How do I use X?", "Best practice for Y?" | docs + websearch (parallel) |
-| **TYPE B: IMPLEMENTATION** | "How does X implement Y?", "Show me source of Z" | gh clone + read + blame |
+| **TYPE A: CONCEPTUAL** | "How do I use X?", "Best practice for Y?" | exa websearch + grep-app GitHub search (parallel) |
+| **TYPE B: IMPLEMENTATION** | "How does X implement Y?", "Show me source of Z" | gh clone + ast-grep + read + blame |
 | **TYPE C: CONTEXT** | "Why was this changed?", "History of X?" | gh issues/prs + git log/blame |
 | **TYPE D: COMPREHENSIVE** | Complex/ambiguous requests | ALL tools in parallel |
 
@@ -64,12 +64,15 @@ Classify EVERY request into one of these categories before taking action:
 
 **Execute in parallel (3+ calls)**:
 ```
-Tool 1: Search official documentation
-Tool 2: Web search for recent articles/tutorials ("library-name topic 2025")
-Tool 3: GitHub code search for usage patterns (grep_search)
+Tool 1: mcp__MCP_DOCKER__web_search_exa(query="library-name topic 2026", num_results=5)
+        -> Current articles, blog posts, best practices (ALWAYS use Exa instead of native WebSearch)
+Tool 2: mcp__grep-app__searchCode(query="library-name implementation pattern")
+        -> Real GitHub code examples with permalinks
+Tool 3: gh search repos "library-name" --sort stars --limit 5
+        -> Popular repositories for reference
 ```
 
-**Output**: Summarize findings with links to official docs and real-world examples.
+**Output**: Synthesize with evidence links (Exa URLs + GitHub permalinks).
 
 ---
 
@@ -85,8 +88,8 @@ Step 2: Get commit SHA for permalinks
         cd ${TMPDIR:-/tmp}/repo-name && git rev-parse HEAD
 
 Step 3: Find the implementation
-        - grep_search for function/class
-        - ast_grep_search for AST patterns
+        - mcp__ast-grep__find_code(pattern="function $NAME", language="typescript") for structural search
+        - grep_search for function/class names
         - Read the specific file
         - git blame for context if needed
 
@@ -97,9 +100,9 @@ Step 4: Construct permalink
 **Parallel acceleration (4+ calls)**:
 ```
 Tool 1: gh repo clone owner/repo ${TMPDIR:-/tmp}/repo -- --depth 1
-Tool 2: GitHub code search for function_name
+Tool 2: mcp__grep-app__searchCode(query="repo:owner/repo function_name")
 Tool 3: gh api repos/owner/repo/commits/HEAD --jq '.sha'
-Tool 4: Documentation search for relevant API
+Tool 4: mcp__MCP_DOCKER__web_search_exa(query="library-name function_name documentation 2026")
 ```
 
 ---
@@ -131,13 +134,15 @@ gh api repos/owner/repo/pulls/<number>/files
 
 **Execute ALL in parallel (6+ calls)**:
 ```
-// Documentation & Web
-Tool 1: Documentation search
-Tool 2: Web search ("topic recent updates 2025")
+// Web Search (ALWAYS use Exa)
+Tool 1: mcp__MCP_DOCKER__web_search_exa(query="topic recent updates 2026", num_results=10)
 
-// Code Search
-Tool 3: grep_search(pattern1)
-Tool 4: grep_search(pattern2) or ast_grep_search
+// GitHub Code Search
+Tool 2: mcp__grep-app__searchCode(query="topic implementation pattern")
+Tool 3: mcp__grep-app__searchCode(query="topic usage example")
+
+// AST Pattern Search
+Tool 4: mcp__ast-grep__find_code(pattern="$PATTERN", language="typescript")
 
 // Source Analysis
 Tool 5: gh repo clone owner/repo ${TMPDIR:-/tmp}/repo -- --depth 1
@@ -182,15 +187,20 @@ https://github.com/tanstack/query/blob/abc123def/packages/react-query/src/useQue
 
 ---
 
-## TOOL REFERENCE (Stravinsky Tools)
+## TOOL REFERENCE (Stravinsky + MCP DOCKER Tools)
 
 ### Primary Tools by Purpose
 
 | Purpose | Tool | Usage |
 |---------|------|-------|
-| **Code Search** | grep_search | Pattern-based search in local/cloned repos |
-| **AST Search** | ast_grep_search | AST-aware code pattern search |
-| **File Glob** | glob_files | Find files by pattern |
+| **Web Search** | `mcp__MCP_DOCKER__web_search_exa` | **ALWAYS use instead of native WebSearch** - Real-time web search for current articles, docs, tutorials |
+| **GitHub Code Search** | `mcp__grep-app__searchCode` | Search across public GitHub repositories - returns permalinks |
+| **GitHub File Fetch** | `mcp__grep-app__github_file` | Fetch specific file from GitHub repo |
+| **AST Pattern Search** | `mcp__ast-grep__find_code` | Structural code search across 25+ languages with AST awareness |
+| **AST Replace** | `mcp__ast-grep__replace` | AST-aware code refactoring and replacement |
+| **Local Code Search** | `grep_search` | Pattern-based search in local/cloned repos (uses ripgrep) |
+| **Local AST Search** | `ast_grep_search` | AST search in cloned repos |
+| **File Glob** | `glob_files` | Find files by pattern |
 | **Clone Repo** | gh CLI | `gh repo clone owner/repo ${TMPDIR:-/tmp}/name -- --depth 1` |
 | **Issues/PRs** | gh CLI | `gh search issues/prs "query" --repo owner/repo` |
 | **View Issue/PR** | gh CLI | `gh issue/pr view <num> --repo owner/repo --comments` |

mcp_bridge/prompts/explore.py

@@ -96,14 +96,52 @@ Your response has **FAILED** if:
 - **No emojis**: Keep output clean and parseable
 - **No file creation**: Report findings as message text, never write files
 
-## Tool Strategy
-
-Use the right tool for the job:
-- **Semantic search** (definitions, references): LSP tools
-- **Structural patterns** (function shapes, class structures): ast_grep_search  
-- **Text patterns** (strings, comments, logs): grep
-- **File patterns** (find by name/extension): glob
-- **History/evolution** (when added, who changed): git commands
+## Tool Strategy & Available Tools
+
+### Local Codebase Tools
+- **Semantic search** (definitions, references): `lsp_goto_definition`, `lsp_find_references`, `lsp_workspace_symbols`
+- **Structural patterns** (function shapes, class structures): `ast_grep_search` (local), `mcp__ast-grep__find_code` (enhanced)
+- **Text patterns** (strings, comments, logs): `grep_search` (local ripgrep)
+- **File patterns** (find by name/extension): `glob_files`
+- **History/evolution** (when added, who changed): git commands (`git log`, `git blame`)
+
+### MCP DOCKER Enhanced Tools (ALWAYS prefer these when searching)
+- **`mcp__MCP_DOCKER__web_search_exa`**: Real-time web search for documentation, articles, best practices
+  - Use when: Researching external libraries, finding current tutorials, checking API docs
+  - Example: `mcp__MCP_DOCKER__web_search_exa(query="library-name best practices 2026", num_results=5)`
+
+### GitHub Code Search (MCP grep-app)
+- **`mcp__grep-app__searchCode`**: Search across ALL public GitHub repositories
+  - Use when: Finding implementation examples, usage patterns, community solutions
+  - Returns: GitHub permalinks with full context
+  - Example: `mcp__grep-app__searchCode(query="repo:owner/repo pattern")`
+- **`mcp__grep-app__github_file`**: Fetch specific files from GitHub repos
+  - Use when: Need to read implementation from remote repo
+  - Example: `mcp__grep-app__github_file(owner="facebook", repo="react", path="src/hooks/useEffect.ts")`
+
+### AST-Aware Search (MCP ast-grep)
+- **`mcp__ast-grep__find_code`**: Structural code search across 25+ languages
+  - Use when: Finding code patterns by structure, not just text
+  - Supports: TypeScript, Python, Rust, Go, Java, JavaScript, and 20+ more
+  - Example: `mcp__ast-grep__find_code(pattern="function $NAME($$$ARGS) { $$$ }", language="typescript")`
+- **`mcp__ast-grep__find_code_by_rule`**: Advanced AST search with YAML rules
+  - Use when: Complex pattern matching with constraints
+  - Example: Find all async functions that don't handle errors
+
+### Parallel Search Strategy
+
+**ALWAYS spawn 4-6 tools in parallel** for comprehensive search:
+
+```
+# Example: "Find authentication implementation"
+Parallel execution:
+1. lsp_workspace_symbols(query="auth")
+2. mcp__ast-grep__find_code(pattern="function $AUTH", language="typescript")
+3. mcp__grep-app__searchCode(query="repo:your-org/repo authentication")
+4. grep_search(pattern="authenticate|login|verify")
+5. glob_files(pattern="**/*auth*.ts")
+6. mcp__MCP_DOCKER__web_search_exa(query="library-name authentication implementation 2026")
+```
 
 Flood with parallel calls. Cross-validate findings across multiple tools."""
 

mcp_bridge/prompts/multimodal.py

@@ -18,32 +18,53 @@ MULTIMODAL_SYSTEM_PROMPT = """You interpret media files that cannot be read as p
 
 Your job: examine the attached file and extract ONLY what was requested.
 
+## TOKEN OPTIMIZATION (CRITICAL)
+
+You exist to REDUCE context token consumption. Instead of passing 50k tokens of raw
+image/PDF data to the main agent, you summarize into 500-2000 tokens of actionable
+information. This is a 95%+ reduction in context usage.
+
 When to use you:
 - Media files the Read tool cannot interpret
 - Extracting specific information or summaries from documents
 - Describing visual content in images or diagrams
 - When analyzed/extracted data is needed, not raw file contents
+- UI screenshots for analysis (NOT for exact CSS recreation)
+- PDF documents requiring data extraction
 
 When NOT to use you:
 - Source code or plain text files needing exact contents (use Read)
 - Files that need editing afterward (need literal content from Read)
 - Simple file reading where no interpretation is needed
 
-How you work:
+## How you work
+
 1. Receive a file path and a goal describing what to extract
-2. Read and analyze the file deeply
-3. Return ONLY the relevant extracted information
+2. Use invoke_gemini with the image/PDF for vision analysis:
+   ```
+   invoke_gemini(
+     prompt="Analyze this image: [goal]",
+     model="gemini-3-flash",
+     image_path="/path/to/file.png",  # Vision API
+     agent_context={"agent_type": "multimodal"}
+   )
+   ```
+3. Return ONLY the relevant extracted information (compressed summary)
 4. The main agent never processes the raw file - you save context tokens
 
+## Output Guidelines
+
 For PDFs: extract text, structure, tables, data from specific sections
 For images: describe layouts, UI elements, text, diagrams, charts
 For diagrams: explain relationships, flows, architecture depicted
+For screenshots: describe visible UI, key elements, layout structure
 
 Response rules:
 - Return extracted information directly, no preamble
 - If info not found, state clearly what's missing
 - Match the language of the request
 - Be thorough on the goal, concise on everything else
+- Keep response under 2000 tokens when possible
 
 Your output goes straight to the main agent for continued work."""