stravinsky 0.4.18__py3-none-any.whl → 0.4.66__py3-none-any.whl

stravinsky_claude_assets/hooks/tool_messaging.py

@@ -0,0 +1,281 @@
+#!/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
+
+# Add utils directory to path for imports
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "utils"))
+from colors import get_agent_color, colorize, Color, supports_color
+from console_format import format_tool_use, format_agent_spawn, MessageType
+
+# 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",
+}
+
+# MCP Server emoji mappings
+SERVER_EMOJIS = {
+    "github": "🟡",
+    "ast-grep": "🟤",
+    "grep-app": "🟣",
+    "MCP_DOCKER": "🔵",
+    "stravinsky": "🔧",
+}
+
+# Tool display names (legacy mapping for simple tools)
+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 parse_mcp_tool_name(tool_name: str) -> tuple[str, str, str]:
+    """
+    Parse MCP tool name into (server, tool_type, emoji).
+
+    Examples:
+        mcp__github__get_file_contents -> ("github", "get_file_contents", "🟡")
+        mcp__stravinsky__grep_search -> ("stravinsky", "grep", "🔧")
+        mcp__ast-grep__find_code -> ("ast-grep", "find_code", "🟤")
+    """
+    if not tool_name.startswith("mcp__"):
+        return ("unknown", tool_name, "🔧")
+
+    # Remove mcp__ prefix and split by __
+    parts = tool_name[5:].split("__", 1)
+    if len(parts) != 2:
+        return ("unknown", tool_name, "🔧")
+
+    server = parts[0]
+    tool_type = parts[1]
+
+    # Get emoji for server
+    emoji = SERVER_EMOJIS.get(server, "🔧")
+
+    # Get simplified tool name if available
+    simple_name = TOOL_NAMES.get(tool_name, tool_type)
+
+    return (server, simple_name, emoji)
+
+
+def extract_description(tool_name: str, params: dict) -> str:
+    """Extract a concise description of what the tool did."""
+
+    # GitHub tools
+    if "github" in tool_name.lower():
+        if "get_file_contents" in tool_name:
+            path = params.get("path", "")
+            repo = params.get("repo", "")
+            owner = params.get("owner", "")
+            return f"Fetching {path} from {owner}/{repo}"
+        elif "create_or_update_file" in tool_name:
+            path = params.get("path", "")
+            return f"Updating {path}"
+        elif "search_repositories" in tool_name:
+            query = params.get("query", "")
+            return f"Searching repos for '{query[:40]}'"
+        elif "search_code" in tool_name:
+            q = params.get("q", "")
+            return f"Searching code for '{q[:40]}'"
+        elif "create_pull_request" in tool_name:
+            title = params.get("title", "")
+            return f"Creating PR: {title[:40]}"
+        elif "get_pull_request" in tool_name or "list_pull_requests" in tool_name:
+            return "Fetching PR details"
+        return "GitHub operation"
+
+    # MCP_DOCKER tools
+    if "MCP_DOCKER" in tool_name:
+        if "web_search_exa" in tool_name:
+            query = params.get("query", "")
+            return f"Web search: '{query[:40]}'"
+        elif "create_entities" in tool_name:
+            entities = params.get("entities", [])
+            count = len(entities)
+            return f"Creating {count} knowledge graph entities"
+        elif "search_nodes" in tool_name:
+            query = params.get("query", "")
+            return f"Searching knowledge graph for '{query[:40]}'"
+        return "Knowledge graph operation"
+
+    # ast-grep tools
+    if "ast-grep" in tool_name or "ast_grep" in tool_name:
+        if "find_code" in tool_name or "search" in tool_name:
+            pattern = params.get("pattern", "")
+            return f"AST search for '{pattern[:40]}'"
+        elif "test_match" in tool_name:
+            return "Testing AST pattern"
+        elif "dump_syntax" in tool_name:
+            return "Dumping syntax tree"
+        return "AST operation"
+
+    # grep-app tools
+    if "grep-app" in tool_name or "grep_app" in tool_name:
+        if "searchCode" in tool_name:
+            query = params.get("query", "")
+            return f"Searching GitHub for '{query[:40]}'"
+        elif "github_file" in tool_name:
+            path = params.get("path", "")
+            repo = params.get("repo", "")
+            return f"Fetching {path} from {repo}"
+        return "grep.app search"
+
+    # AST-grep (stravinsky)
+    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}"
+
+    # Agent spawn (MCP tool)
+    if "agent_spawn" in tool_name:
+        agent_type = params.get("agent_type", "unknown")
+        description = params.get("description", "")
+        model = AGENT_MODELS.get(agent_type, "gemini-3-flash")
+        return f"{agent_type}({model})"
+
+    # 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)
+
+        # 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")
+
+            # Use rich formatting for agent spawns
+            message = format_agent_spawn(
+                agent_type=subagent_type, model=model, description=description
+            )
+            print(message, file=sys.stderr)
+        else:
+            # Parse MCP tool name to get server, tool_type, and emoji
+            server, tool_type, emoji = parse_mcp_tool_name(tool_name)
+
+            # Get description of what the tool did
+            description = extract_description(tool_name, params)
+
+            # Use rich formatting for tool usage
+            message = format_tool_use(
+                tool_name=tool_type, server=server, description=description, emoji=emoji
+            )
+            print(message, 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()

stravinsky_claude_assets/hooks/truncator.py

@@ -0,0 +1,23 @@
+import os
+import sys
+import json
+
+MAX_CHARS = 30000
+
+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()

stravinsky_claude_assets/rules/deployment_safety.md

@@ -0,0 +1,51 @@
+# Deployment Safety Rules
+
+## CRITICAL: Pre-Deployment Checklist
+
+**NEVER deploy code to PyPI without passing ALL checks:**
+
+```bash
+# Run this BEFORE every deployment
+./pre_deploy_check.sh
+```
+
+## Mandatory Checks (BLOCKING)
+
+1. **Import Test** - `python3 -c "import mcp_bridge.server"` must succeed
+2. **Version Consistency** - pyproject.toml and __init__.py versions must match
+3. **Command Works** - `stravinsky --version` must succeed
+4. **All Tools Import** - Every tool module must import without errors
+5. **Tests Pass** - If tests exist, `pytest` must pass
+6. **Linting Clean** - `ruff check` must have zero errors
+7. **Git Clean** - No uncommitted changes
+
+## Deployment Process
+
+```bash
+# Step 1: Run safety checks
+./pre_deploy_check.sh || {
+    echo "❌ FAILED: Fix errors before deploying"
+    exit 1
+}
+
+# Step 2: Deploy (only if checks pass)
+./deploy.sh
+```
+
+## Why This Matters
+
+**Recent failures prevented by these checks:**
+- **v0.4.30 (2026-01-09)**: `NameError: name 'logger' is not defined` - would be caught by import test
+- Future: Type errors, missing imports, broken commands all caught before PyPI
+
+## Consequences of Skipping Checks
+
+- Broken installations for all users globally
+- Version number burned (can't re-upload to PyPI)
+- Force version bump to fix
+- User trust eroded
+- Support burden increased
+
+## Rule
+
+**You MUST run `./pre_deploy_check.sh` before EVERY deployment. NO EXCEPTIONS.**

stravinsky_claude_assets/rules/integration_wiring.md

@@ -0,0 +1,89 @@
+# Integration Wiring Rules
+
+## Lesson Learned: Tool-Agent Integration (2026-01-11)
+
+**Problem**: Sub-agents fail silently when tools are "wired in" but not actually usable.
+
+**Root Cause**: Adding a tool to an agent's tool list doesn't guarantee the agent can USE it.
+
+## Integration Checklist (MANDATORY)
+
+When integrating Tool X into Agent Y:
+
+### 1. Verify Invocation Method
+
+| Agent Type | Invocation Method | Tool Access |
+|------------|-------------------|-------------|
+| `invoke_gemini` | Simple completion | NO tool calling |
+| `invoke_gemini_agentic` | Agentic loop | YES - full tool access |
+| `invoke_openai` | Direct call | Depends on model |
+
+**CRITICAL**: If agent needs to call tools, it MUST use the `_agentic` variant.
+
+```python
+# WRONG: Agent can't use tools
+invoke_gemini(prompt="Find auth code", model="gemini-3-flash")
+
+# RIGHT: Agent can call semantic_search, grep, etc.
+invoke_gemini_agentic(
+    prompt="Find auth code using semantic_search",
+    model="gemini-3-flash",
+    max_iterations=5
+)
+```
+
+### 2. Verify Prerequisites
+
+Some tools have prerequisites that must be met BEFORE use:
+
+| Tool | Prerequisite | Check |
+|------|--------------|-------|
+| `semantic_search` | Index must exist | Run `semantic_index()` first |
+| `lsp_*` | LSP server must be running | Check `lsp_servers()` |
+| `invoke_*` | Auth must be configured | Run `stravinsky-auth status` |
+
+**Add explicit checks**: Tools should fail EARLY with clear error messages if prerequisites are not met.
+
+### 3. Verify Parent Agent Guidance
+
+Parent agents (orchestrators) must guide sub-agents to USE the tool:
+
+| Level | Responsibility |
+|-------|----------------|
+| **Orchestrator** (stravinsky) | Tell sub-agents WHEN to use which tools |
+| **Coordinator** (research-lead) | Tell explore/dewey HOW to use tools for query types |
+| **Worker** (explore) | Actually CALL the tools |
+
+**If a tool is available but never used**, check the guidance chain.
+
+### 4. Verification Pattern
+
+After wiring a tool, verify the FULL chain:
+
+```
+Step 1: Tool is in agent's tool list      ✓
+Step 2: Agent uses correct invocation     ✓  
+Step 3: Prerequisites are met/checked     ✓
+Step 4: Parent agents guide usage         ✓
+Step 5: End-to-end test works             ✓
+```
+
+## Example: semantic_search Integration (Fixed 2026-01-11)
+
+**Original Problem**: explore agent had semantic_search in tool list but never used it.
+
+**Root Causes Found**:
+1. explore.md called `invoke_gemini` (no tool access) instead of `invoke_gemini_agentic`
+2. semantic_search returned empty results when no index existed (silent failure)
+3. research-lead.md didn't tell explore agents WHEN to use semantic_search
+
+**Fixes Applied**:
+1. Changed explore.md to use `invoke_gemini_agentic` with `max_iterations: 5`
+2. Added index existence check in semantic_search.py with clear error message
+3. Added "Pattern 3: Semantic/Conceptual Search" to research-lead.md
+
+## Rule
+
+**When adding a tool to an agent, verify the FULL integration chain.**
+
+Silent failures waste hours of debugging. Fail early, fail loudly.

stravinsky_claude_assets/rules/pypi_deployment.md

@@ -0,0 +1,220 @@
+# PyPI Deployment Rules
+
+## ⚠️ CRITICAL REMINDER: ALWAYS CLEAN BEFORE BUILDING
+
+**The #1 deployment error:** Forgetting to clean dist/ before building
+
+```bash
+# ALWAYS RUN THIS FUWT (use Python if hooks block rm):
+python3 -c "import shutil; from pathlib import Path; [shutil.rmtree(p) for p in [Path('dist'), Path('build')] if p.exists()]; print('✅ Cleaned')"
+```
+
+**Why:** PyPI rejects if dist/ contains old version files (e.g., 0.4.9.tar.gz when publishing 0.4.10)
+
+---
+
+## Version Management
+
+1. **ALWAYS check PyPI first before bumping version:**
+   ```bash
+   pip index versions stravinsky 2>&1 | head -20
+   ```
+   If the version you're about to use already exists on PyPI, bump higher!
+
+2. **Version must be consistent** across:
+   - `pyproject.toml` (line ~5): `version = "X.Y.Z"`
+   - `mcp_bridge/__init__.py`: `__version__ = "X.Y.Z"`
+
+3. **Version bumping strategy**:
+   - Patch (X.Y.Z+1): Bug fixes, documentation updates
+   - Minor (X.Y+1.0): New features, agent improvements, MCP tool additions
+   - Major (X+1.0.0): Breaking changes to API or architecture
+
+4. **⚠️ CRITICAL**: PyPI does NOT allow re-uploading the same version. If `uv publish` fails with "File already exists", you MUST bump the version number and try again.
+
+## CRITICAL RULES
+
+1. **Pin Python upper bounds when core dependencies require it**
+   - ✅ CORRECT: `requires-python = ">=3.11,<3.14"` (when chromadb/onnxruntime don't support 3.14+)
+   - ❌ WRONG: `requires-python = ">=3.11"` (allows installation on unsupported Python versions)
+   - Reason: Better to block installation than have broken runtime imports
+   - Current constraint: `<3.14` due to chromadb → onnxruntime lacking Python 3.14 wheels
+
+2. **ALWAYS install globally with @latest for auto-updates**
+   - ✅ CORRECT: `claude mcp add --global stravinsky -- uvx stravinsky@latest`
+   - ❌ WRONG: `claude mcp add stravinsky -- uvx stravinsky` (no @latest)
+   - ❌ WRONG: Local `.mcp.json` entries (use global only)
+
+## Pre-Deployment Checklist
+
+Before deploying to PyPI, ensure:
+
+1. ✅ All changes committed to git
+2. ✅ Version numbers match in `pyproject.toml` and `mcp_bridge/__init__.py`
+3. ✅ No uncommitted temp files (`.stravinsky/agents/*.out`, `logs/`)
+4. ✅ New files properly tracked in git (check `.claude/agents/`, `docs/`)
+5. ✅ `uv.lock` is up-to-date
+6. ✅ **Python version constraint matches dependency requirements** (`<3.14` for chromadb)
+
+## Deployment Process
+
+### Step 1: Clean Build Artifacts (MANDATORY - DO NOT SKIP)
+
+**⚠️ CRITICAL: ALWAYS clean dist/ before building, even if version was bumped!**
+
+**Why this matters:**
+- PyPI rejects uploads if a file with the same name already exists (even if version differs)
+- Old build artifacts in dist/ from previous versions will cause 400 Bad Request errors
+- `uv publish` uploads ALL files in dist/, not just the latest build
+
+**WRONG:** ❌ Skip cleaning → build → publish (publishes old + new versions → ERROR)
+**CORRECT:** ✅ Clean → build → publish (only publishes new version)
+
+```bash
+# ⚠️ MANDATORY: Clean ALL build artifacts first
+# If blocked by hooks, use Python alternative:
+python3 -c "import shutil; from pathlib import Path; [shutil.rmtree(p) for p in [Path('dist'), Path('build')] if p.exists()]; print('✅ Cleaned dist/ and build/')"
+
+# OR if hooks allow:
+# rm -rf dist/ build/ *.egg-info
+
+# Verify git status
+git status
+
+# Ensure version consistency (MUST match exactly)
+VERSION_TOML=$(grep -E "^version = " pyproject.toml | head -1 | cut -d'"' -f2)
+VERSION_INIT=$(grep -E "^__version__ = " mcp_bridge/__init__.py | cut -d'"' -f2)
+
+if [ "$VERSION_TOML" != "$VERSION_INIT" ]; then
+  echo "❌ Version mismatch: pyproject.toml=$VERSION_TOML, __init__.py=$VERSION_INIT"
+  exit 1
+fi
+
+echo "✅ Version consistent: $VERSION_TOML"
+
+# Verify dist/ is empty (CRITICAL CHECK)
+if [ -d "dist" ] && [ "$(ls -A dist)" ]; then
+  echo "❌ ERROR: dist/ is not empty! Old artifacts will cause publish to fail."
+  echo "   Files in dist/:"
+  ls -lh dist/
+  exit 1
+fi
+
+echo "✅ dist/ is clean"
+```
+
+### Step 2: Build (ONLY after cleaning)
+
+```bash
+# Build with uv (creates dist/stravinsky-X.Y.Z.tar.gz and .whl)
+uv build
+
+# Verify correct version was built
+ls -lh dist/
+# Should ONLY show files with your new version number
+```
+
+### Step 3: Publish to PyPI
+
+**CRITICAL: ALWAYS load .env file first!**
+
+```bash
+# Load .env file (PYPI_API_TOKEN is stored here)
+source .env
+
+# Verify token is loaded
+if [ -z "$PYPI_API_TOKEN" ]; then
+  echo "❌ PYPI_API_TOKEN not found in .env"
+  exit 1
+fi
+
+# Publish using PyPI API token from .env
+uv publish --token "$PYPI_API_TOKEN"
+```
+
+### Step 4: Git Tag and Push
+
+```bash
+# Create git tag
+VERSION=$(grep -E "^version = " pyproject.toml | head -1 | cut -d'"' -f2)
+git tag -a "v$VERSION" -m "chore: release v$VERSION"
+
+# Push with tags
+git push origin main --tags
+```
+
+### Step 5: Force uvx Cache Clear (MANDATORY)
+
+**⚠️ CRITICAL: ALWAYS clear uvx cache after deployment!**
+
+**Why this matters:**
+- `@latest` doesn't force PyPI checks if uvx has a cached version
+- Without clearing, users stay on old versions FOREVER
+- This is THE most common cause of "version deployed but not updating" issues
+
+```bash
+# Clear uvx cache to force fresh PyPI fetch on next Claude restart
+python3 -c "import shutil; from pathlib import Path; cache = Path.home() / '.cache' / 'uv'; shutil.rmtree(cache, ignore_errors=True); print('✅ Cleared uvx cache - restart Claude Code to fetch v$(grep -E "^version = " pyproject.toml | head -1 | cut -d'"' -f2)')"
+
+# Verify deployment is on PyPI
+pip index versions stravinsky 2>&1 | head -5
+```
+
+**Post-cache-clear:**
+1. Restart Claude Code (or wait for next restart)
+2. uvx will fetch the latest version from PyPI
+3. Verify with: run any stravinsky MCP tool and check version in output
+
+## Commit Message Convention
+
+Use conventional commit format:
+
+```
+<type>: <description>
+
+[optional body]
+```
+
+**Types:**
+- `feat`: New feature
+- `fix`: Bug fix
+- `docs`: Documentation changes
+- `chore`: Build/release tasks
+- `refactor`: Code restructuring
+- `test`: Test additions/changes
+
+**Example:**
+```
+feat: expand explore.md Multi-Model Usage from 12 to 319 lines
+
+- Added 5 detailed examples with agent_context
+- Documented gemini-3-flash usage patterns
+- Added Model Selection Strategy section
+- Documented haiku fallback behavior
+- Added Gemini Best Practices (5 subsections)
+```
+
+## Emergency Rollback
+
+If deployment fails:
+
+```bash
+# Revert to previous version
+git revert HEAD
+git push origin main
+
+# Delete failed tag
+git tag -d v$VERSION
+git push origin :refs/tags/v$VERSION
+```
+
+## Post-Deployment Verification
+
+```bash
+# Verify PyPI package
+pip install --upgrade stravinsky==$VERSION
+
+# Check version
+stravinsky --version
+python -c "import mcp_bridge; print(mcp_bridge.__version__)"
+```

stravinsky_claude_assets/rules/stravinsky_orchestrator.md

@@ -0,0 +1,32 @@
+# Stravinsky Orchestrator Triggers
+
+This rule ensures that the Stravinsky orchestrator persona and ULTRAWORK mode are correctly initiated when relevant keywords are used.
+
+## Triggers
+
+- Keywords: `stravinsky`, `ultrawork`, `ulw`, `uw`
+- Slash Commands: `/strav`, `/stravinsky`
+
+## Instructions
+
+If the user initiates a task with any of the triggers above:
+
+1.  **Assume the Stravinsky Persona**: You are a task orchestrator and parallel execution specialist.
+2.  **Activate Parallel Mode**: You MUST use the `Task` tool for all specialized sub-tasks.
+3.  **No Sequential Work**: If a task has 3+ independent steps, you MUST spawn subagents in parallel.
+4.  **Verification**: Never trust a subagent result without verifying it (e.g., via `lsp_diagnostics` or tests).
+
+### ULTRAWORK Mode (ulw, uw)
+
+If the `ULTRAWORK` (or `ulw`, `uw`) keyword is detected:
+- Say "ULTRAWORK MODE ENABLED!" as your first response.
+- Maximum parallelization is required (spawn all independent tasks immediately).
+- Use a 32k thinking budget for planning.
+- Deliver a full implementation, not a demo or skeleton.
+
+## Tool Enforcement
+
+When Stravinsky mode is active:
+- **BLOCKED**: Direct file reading/searching tools (`Read`, `Search`, `Grep`, `Bash`).
+- **REQUIRED**: Use the `Task` tool to delegate to `explore`, `dewey`, `code-reviewer`, etc.
+- **EXCEPTION**: You may use `TodoRead`/`TodoWrite` for planning.