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

mcp_bridge/config/skills_manifest.json

@@ -0,0 +1,128 @@
+{
+  "schema_version": "1.0.0",
+  "manifest_version": "0.3.9",
+  "description": "Stravinsky skills for Claude Code command integration",
+  "generated_date": "2026-01-08T23:53:08.837988Z",
+  "skills": {
+    "commit.md": {
+      "file_path": "commit.md",
+      "description": "Git Master - Intelligent atomic commit orchestration",
+      "checksum": "f09aee4cc46e",
+      "lines_of_code": 531,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "delphi.md": {
+      "file_path": "delphi.md",
+      "description": "Strategic advisor for architecture and debugging",
+      "checksum": "46ce352164a5",
+      "lines_of_code": 5,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "dewey.md": {
+      "file_path": "dewey.md",
+      "description": "Research librarian for documentation and examples",
+      "checksum": "de4e41fc0e08",
+      "lines_of_code": 54,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "index.md": {
+      "file_path": "str/index.md",
+      "description": "Index project for semantic search",
+      "checksum": "a37c570b70a5",
+      "lines_of_code": 199,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "publish.md": {
+      "file_path": "publish.md",
+      "description": "Publish to PyPI with version bump",
+      "checksum": "9e6ed392ebc4",
+      "lines_of_code": 66,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "review.md": {
+      "file_path": "review.md",
+      "description": "Code review recent changes",
+      "checksum": "47274e796826",
+      "lines_of_code": 67,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "search.md": {
+      "file_path": "str/search.md",
+      "description": "Stravinsky skill",
+      "checksum": "eb092d567333",
+      "lines_of_code": 205,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "start_filewatch.md": {
+      "file_path": "str/start_filewatch.md",
+      "description": "Stravinsky skill",
+      "checksum": "23ca1f6a1999",
+      "lines_of_code": 136,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "stats.md": {
+      "file_path": "str/stats.md",
+      "description": "Stravinsky skill",
+      "checksum": "017f4fc6d099",
+      "lines_of_code": 71,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "stop_filewatch.md": {
+      "file_path": "str/stop_filewatch.md",
+      "description": "Stravinsky skill",
+      "checksum": "dbe92100d0ba",
+      "lines_of_code": 89,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "cancel-loop.md": {
+      "file_path": "strav/cancel-loop.md",
+      "description": "Cancel active continuation loop",
+      "checksum": "d811ea8bb0e9",
+      "lines_of_code": 128,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "loop.md": {
+      "file_path": "strav/loop.md",
+      "description": "Continuation loop for iterative execution",
+      "checksum": "defc1ae0aae4",
+      "lines_of_code": 193,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "strav.md": {
+      "file_path": "strav.md",
+      "description": "Stravinsky Orchestrator - Parallel agent execution",
+      "checksum": "9c9969cf8c09",
+      "lines_of_code": 216,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "verify.md": {
+      "file_path": "verify.md",
+      "description": "Post-implementation verification",
+      "checksum": "87894579d5ec",
+      "lines_of_code": 60,
+      "updatable": true,
+      "priority": "medium"
+    },
+    "version.md": {
+      "file_path": "version.md",
+      "description": "Stravinsky skill",
+      "checksum": "1cf41d5d28da",
+      "lines_of_code": 5,
+      "updatable": true,
+      "priority": "medium"
+    }
+  }
+}

mcp_bridge/hooks/HOOKS_SETTINGS.json

@@ -47,6 +47,11 @@
             "type": "command",
             "command": "python3 ~/.claude/hooks/stravinsky_mode.py",
             "description": "Hard blocking of direct tools in stravinsky mode"
+          },
+          {
+            "type": "command",
+            "command": "python3 ~/.claude/hooks/pre_tool/agent_spawn_validator.py",
+            "description": "Blocks sequential tool usage when parallel delegation is required"
           }
         ]
       }
@@ -111,6 +116,11 @@
             "type": "command",
             "command": "python3 ~/.claude/hooks/todo_delegation.py",
             "description": "Parallel execution enforcer after TodoWrite"
+          },
+          {
+            "type": "command",
+            "command": "python3 ~/.claude/hooks/post_tool/parallel_validation.py",
+            "description": "Tracks pending tasks for hard enforcement"
           }
         ]
       }
@@ -139,7 +149,9 @@
     "execution_control": {
       "parallel_execution.py": "Detects implementation tasks and injects parallel execution instructions before response generation. Activates stravinsky mode on /stravinsky invocation.",
       "stravinsky_mode.py": "Blocks native file tools (Read, Grep, Bash, Edit) when stravinsky mode is active, forcing Task delegation.",
-      "todo_delegation.py": "Hard blocks response completion after TodoWrite if 2+ pending items exist without spawning Task agents."
+      "todo_delegation.py": "Hard blocks response completion after TodoWrite if 2+ pending items exist without spawning Task agents.",
+      "parallel_validation.py": "Tracks pending tasks count after TodoWrite to enable hard enforcement state.",
+      "agent_spawn_validator.py": "Blocks sequential tool usage (Read, Grep, etc.) if parallel delegation is required and enabled."
     },
     "context_management": {
       "context.py": "Auto-injects CLAUDE.md, README.md, or AGENTS.md content into prompts for project-specific context.",
@@ -166,10 +178,11 @@
   "state_files": {
     "~/.stravinsky_mode": "Marker file indicating stravinsky orchestrator mode is active (enables hard blocking)",
     "~/.claude/state/compaction.jsonl": "Audit log of context compaction events with preserved items",
-    ".claude/todo_state.json": "Cached todo state for continuation enforcement"
+    ".claude/todo_state.json": "Cached todo state for continuation enforcement",
+    ".claude/parallel_state.json": "Transient state tracking pending tasks for hard enforcement"
   },
   
-  "version": "0.2.63",
+  "version": "0.2.64",
   "package": "stravinsky",
   "documentation": "https://github.com/GratefulDave/stravinsky"
-}
+}

mcp_bridge/hooks/__init__.py

@@ -99,22 +99,37 @@ __all__ = [
     "parallel_execution",
     "stravinsky_mode",
     "todo_delegation",
-    
     # Context & state
     "context",
     "todo_continuation",
     "pre_compact",
-    
     # Tool enhancement
     "tool_messaging",
     "edit_recovery",
     "truncator",
-    
     # Agent lifecycle
     "notification_hook",
     "subagent_stop",
 ]
 
-__version__ = "0.2.63"
+
+def initialize_hooks():
+    """Initialize and register all hooks with the HookManager."""
+    from .delegation_policy import DelegationReminderPolicy
+    from .edit_recovery_policy import EditRecoveryPolicy
+    from .manager import get_hook_manager
+    from .parallel_enforcement_policy import ParallelEnforcementPolicy
+    from .truncation_policy import TruncationPolicy
+
+    manager = get_hook_manager()
+
+    # Register unified policies
+    manager.register_policy(TruncationPolicy())
+    manager.register_policy(DelegationReminderPolicy())
+    manager.register_policy(EditRecoveryPolicy())
+    manager.register_policy(ParallelEnforcementPolicy())
+
+
+__version__ = "0.4.60"
 __author__ = "David Andrews"
 __description__ = "Claude Code hooks for Stravinsky MCP parallel execution"

mcp_bridge/hooks/agent_reminder.py

@@ -6,7 +6,7 @@ suggests using background agents for more comprehensive results.
 """
 
 import logging
-from typing import Any, Dict, Optional
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -28,8 +28,8 @@ SEARCH_TOOLS = {"grep", "glob", "rg", "find", "Grep", "Glob", "grep_search", "gl
 
 
 async def agent_reminder_hook(
-    tool_name: str, arguments: Dict[str, Any], output: str
-) -> Optional[str]:
+    tool_name: str, arguments: dict[str, Any], output: str
+) -> str | None:
     """
     Post-tool call hook that suggests background agents after direct search tool usage.
     """
@@ -51,7 +51,7 @@ async def agent_reminder_hook(
     return None
 
 
-def _extract_search_context(arguments: Dict[str, Any]) -> str:
+def _extract_search_context(arguments: dict[str, Any]) -> str:
     """Extract search context from tool arguments."""
     for key in ("pattern", "query", "search", "name", "path"):
         if key in arguments:

mcp_bridge/hooks/auto_slash_command.py

@@ -11,7 +11,7 @@ Detects and auto-processes slash commands in user input:
 import logging
 import re
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Tuple
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -19,7 +19,7 @@ logger = logging.getLogger(__name__)
 SLASH_COMMAND_PATTERN = re.compile(r'(?:^|(?<=\s))\/([a-zA-Z][a-zA-Z0-9_-]*)\b', re.MULTILINE)
 
 
-def extract_slash_commands(text: str) -> List[str]:
+def extract_slash_commands(text: str) -> list[str]:
     """
     Extract all slash command names from text.
 
@@ -40,7 +40,7 @@ def extract_slash_commands(text: str) -> List[str]:
     return unique
 
 
-def load_skill_content(command_name: str, project_path: Optional[str] = None) -> Optional[Tuple[str, str]]:
+def load_skill_content(command_name: str, project_path: str | None = None) -> tuple[str, str] | None:
     """
     Load skill content by command name.
 
@@ -92,7 +92,7 @@ def load_skill_content(command_name: str, project_path: Optional[str] = None) ->
         return None
 
 
-def get_project_path_from_prompt(prompt: str) -> Optional[str]:
+def get_project_path_from_prompt(prompt: str) -> str | None:
     """
     Try to extract project path from prompt context.
     Looks for common patterns that indicate the working directory.
@@ -126,7 +126,7 @@ SKILL_NOT_FOUND_WARNING = """
 """
 
 
-async def auto_slash_command_hook(params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+async def auto_slash_command_hook(params: dict[str, Any]) -> dict[str, Any] | None:
     """
     Pre-model invoke hook that detects slash commands and injects skill content.
 

mcp_bridge/hooks/budget_optimizer.py

@@ -3,14 +3,14 @@ Thinking budget optimizer hook.
 Analyzes prompt complexity and adjusts thinking_budget for models that support it.
 """
 
-from typing import Any, Dict, Optional
+from typing import Any
 
 REASONING_KEYWORDS = [
     "architect", "design", "refactor", "debug", "complex", "optimize", 
     "summarize", "analyze", "explain", "why", "review", "strangler"
 ]
 
-async def budget_optimizer_hook(params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+async def budget_optimizer_hook(params: dict[str, Any]) -> dict[str, Any] | None:
     """
     Adjusts the thinking_budget based on presence of reasoning-heavy keywords.
     """

mcp_bridge/hooks/claude_limits_hook.py

@@ -0,0 +1,114 @@
+#!/usr/bin/env python3
+"""
+PostToolUse hook for Claude rate limit detection.
+
+Monitors model invocation responses for Claude-specific rate limit indicators
+and updates the provider state tracker accordingly.
+"""
+
+import json
+import logging
+import sys
+from pathlib import Path
+
+# Add parent directory to path for imports
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+try:
+    from routing import get_provider_tracker
+except ImportError:
+    get_provider_tracker = None  # type: ignore
+
+
+logger = logging.getLogger(__name__)
+
+# Claude rate limit indicators
+CLAUDE_RATE_LIMIT_PATTERNS = [
+    "rate limit",
+    "rate_limit_error",
+    "too many requests",
+    "429",
+    "quota exceeded",
+    "rate-limited",
+    "overloaded_error",
+]
+
+
+def detect_claude_rate_limit(tool_result: str | dict) -> bool:
+    """
+    Detect if a tool result indicates Claude rate limiting.
+
+    Args:
+        tool_result: Tool result string or dict
+
+    Returns:
+        True if rate limit detected, False otherwise
+    """
+    # Convert result to searchable string
+    if isinstance(tool_result, dict):
+        search_text = json.dumps(tool_result).lower()
+    else:
+        search_text = str(tool_result).lower()
+
+    # Check for rate limit patterns
+    for pattern in CLAUDE_RATE_LIMIT_PATTERNS:
+        if pattern in search_text:
+            logger.info(f"[ClaudeLimitsHook] Detected rate limit pattern: {pattern}")
+            return True
+
+    return False
+
+
+def main() -> None:
+    """Process PostToolUse hook event."""
+    try:
+        # Read hook input from stdin
+        hook_input = json.loads(sys.stdin.read())
+
+        tool_name = hook_input.get("tool_name", "")
+        tool_result = hook_input.get("tool_result", "")
+
+        # Only monitor invoke tools (Claude uses default Claude models)
+        # We're looking for rate limits from the main Claude context
+        # This is different from invoke_openai/invoke_gemini which are explicit
+        if not any(
+            keyword in tool_name.lower() for keyword in ["invoke", "chat", "generate", "complete"]
+        ):
+            # Not a model invocation tool - skip
+            sys.exit(0)
+
+        # Check for rate limit indicators
+        if detect_claude_rate_limit(tool_result):
+            logger.warning("[ClaudeLimitsHook] Claude rate limit detected")
+
+            if get_provider_tracker and callable(get_provider_tracker):
+                tracker = get_provider_tracker()
+                if tracker:
+                    tracker.mark_rate_limited("claude", duration=300, reason="Claude rate limit")
+                    logger.info("[ClaudeLimitsHook] Marked Claude as rate-limited (300s cooldown)")
+
+                    print(
+                        "\n⚠️ Claude Rate Limit Detected\n"
+                        "→ Routing future requests to OpenAI/Gemini for 5 minutes\n",
+                        file=sys.stderr,
+                    )
+            else:
+                logger.debug(
+                    "[ClaudeLimitsHook] Provider tracker not available, skipping state update"
+                )
+
+        sys.exit(0)
+
+    except Exception as e:
+        # Log error but don't block
+        logger.error(f"[ClaudeLimitsHook] Error: {e}", exc_info=True)
+        print(f"[ClaudeLimitsHook] Warning: {e}", file=sys.stderr)
+        sys.exit(0)  # Exit 0 to not block execution
+
+
+if __name__ == "__main__":
+    # Configure logging
+    logging.basicConfig(
+        level=logging.INFO, format="%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+    )
+    main()

mcp_bridge/hooks/comment_checker.py

@@ -6,8 +6,7 @@ Code should be self-documenting; excessive comments indicate AI slop.
 """
 
 import logging
-import re
-from typing import Any, Dict, Optional
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -53,8 +52,8 @@ CODE_EXTENSIONS = {
 
 
 async def comment_checker_hook(
-    tool_name: str, arguments: Dict[str, Any], output: str
-) -> Optional[str]:
+    tool_name: str, arguments: dict[str, Any], output: str
+) -> str | None:
     """
     Post-tool call hook that checks for excessive comments in code edits.
     """

mcp_bridge/hooks/compaction.py

@@ -3,7 +3,7 @@ Preemptive context compaction hook.
 Monitors context size and injects optimization reminders.
 """
 
-from typing import Any, Dict, Optional
+from typing import Any
 
 THRESHOLD_CHARS = 100000 # Roughly 25k-30k tokens for typical LLM text
 
@@ -17,7 +17,7 @@ COMPACTION_REMINDER = """
 > 4. Keep your next responses concise and focused only on the current sub-task.
 """
 
-async def context_compaction_hook(params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+async def context_compaction_hook(params: dict[str, Any]) -> dict[str, Any] | None:
     """
     Checks prompt length and injects a compaction reminder if it's too large.
     """

mcp_bridge/hooks/context.py

@@ -1,8 +1,9 @@
+import json
 import os
 import sys
-import json
 from pathlib import Path
 
+
 def main():
     try:
         data = json.load(sys.stdin)

mcp_bridge/hooks/context_monitor.py

@@ -7,7 +7,7 @@ At 85%, suggests compaction before hitting hard limits.
 """
 
 import logging
-from typing import Any, Dict, Optional
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -32,7 +32,7 @@ CONTEXT_THRESHOLD_WARNING = 0.85
 ESTIMATED_MAX_TOKENS = 200000
 
 
-async def context_monitor_hook(params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+async def context_monitor_hook(params: dict[str, Any]) -> dict[str, Any] | None:
     """
     Pre-model invoke hook that monitors context window usage.
     """

mcp_bridge/hooks/delegation_policy.py

@@ -0,0 +1,85 @@
+import os
+import time
+from pathlib import Path
+
+from ..utils.session_state import get_current_session_id, update_session_state
+from .events import EventType, HookPolicy, PolicyResult, ToolCallEvent
+
+# 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()
+
+
+class DelegationReminderPolicy(HookPolicy):
+    """
+    Policy for TodoWrite: CRITICAL parallel execution enforcer.
+    """
+
+    @property
+    def event_type(self) -> EventType:
+        return EventType.POST_TOOL_CALL
+
+    async def evaluate(self, event: ToolCallEvent) -> PolicyResult:
+        if event.tool_name != "TodoWrite":
+            return PolicyResult(modified_data=event.output)
+
+        todos = event.arguments.get("todos", [])
+        pending_count = sum(1 for t in todos if t.get("status") == "pending")
+
+        # Update session state
+        session_id = event.metadata.get("session_id") or get_current_session_id()
+        update_session_state(
+            {
+                "last_todo_write_at": time.time(),
+                "pending_todo_count": pending_count,
+            },
+            session_id=session_id,
+        )
+
+        if pending_count < 2:
+            return PolicyResult(modified_data=event.output)
+
+        stravinsky_active = is_stravinsky_mode()
+
+        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.strip()}                                                              ║
+║                                                                          ║
+║  You MUST spawn Task agents for ALL independent TODOs in this response.  ║
+║                                                                          ║
+╠══════════════════════════════════════════════════════════════════════════╣
+║  REQUIRED PATTERN:                                                       ║
+║  Task(subagent_type="explore", prompt="TODO 1...", run_in_background=t)  ║
+║  Task(subagent_type="explore", prompt="TODO 2...", run_in_background=t)  ║
+║  ...                                                                     ║
+╚══════════════════════════════════════════════════════════════════════════╝
+"""
+        # In PostToolUse, we often want to APPEND the reminder to the output
+        new_output = (event.output or "") + "\n" + error_message
+
+        return PolicyResult(
+            modified_data=new_output,
+            message=error_message,  # For native hooks, we might just print the message
+            should_block=stravinsky_active,
+            exit_code=2 if stravinsky_active else 1,
+        )
+
+
+if __name__ == "__main__":
+    policy = DelegationReminderPolicy()
+    policy.run_as_native()

mcp_bridge/hooks/directory_context.py

@@ -3,11 +3,11 @@ Directory context injector hook.
 Automatically finds and injects local AGENTS.md or README.md content based on the current context.
 """
 
-import os
 from pathlib import Path
-from typing import Any, Dict, Optional
+from typing import Any
 
-async def directory_context_hook(params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+
+async def directory_context_hook(params: dict[str, Any]) -> dict[str, Any] | None:
     """
     Search for AGENTS.md or README.md in the current working directory and inject them.
     """

mcp_bridge/hooks/edit_recovery.py

@@ -1,7 +1,8 @@
-import os
-import sys
 import json
+import os
 import re
+import sys
+
 
 def main():
     # Claude Code PostToolUse inputs via Environment Variables

mcp_bridge/hooks/edit_recovery_policy.py

@@ -0,0 +1,49 @@
+import re
+
+from .events import EventType, HookPolicy, PolicyResult, ToolCallEvent
+
+
+class EditRecoveryPolicy(HookPolicy):
+    """
+    Policy to provide recovery guidance when Edit/MultiEdit tools fail.
+    """
+
+    @property
+    def event_type(self) -> EventType:
+        return EventType.POST_TOOL_CALL
+
+    async def evaluate(self, event: ToolCallEvent) -> PolicyResult:
+        if event.tool_name not in ["Edit", "MultiEdit", "replace"]:
+            return PolicyResult(modified_data=event.output)
+
+        if not event.output:
+            return PolicyResult(modified_data=event.output)
+
+        # Error patterns
+        error_patterns = [
+            r"oldString not found",
+            r"oldString matched multiple times",
+            r"line numbers out of range",
+            r"does not match exactly",
+            r"failed to find the target string",
+        ]
+
+        recovery_needed = any(re.search(p, event.output, re.IGNORECASE) for p in error_patterns)
+
+        if recovery_needed:
+            correction = (
+                "\n\n[SYSTEM RECOVERY] It appears the Edit tool failed to find the target string. "
+                "Please call 'Read' on the file again to verify the current content, "
+                "then ensure your 'oldString' is an EXACT match including all whitespace."
+            )
+            return PolicyResult(
+                modified_data=event.output + correction,
+                message=correction,
+            )
+
+        return PolicyResult(modified_data=event.output)
+
+
+if __name__ == "__main__":
+    policy = EditRecoveryPolicy()
+    policy.run_as_native()

mcp_bridge/hooks/empty_message_sanitizer.py

@@ -10,7 +10,7 @@ Cleans up empty/malformed messages:
 
 import logging
 import re
-from typing import Any, Dict, List, Optional
+from typing import Any
 
 logger = logging.getLogger(__name__)
 
@@ -181,7 +181,7 @@ def sanitize_message_blocks(prompt: str) -> tuple[str, int]:
     return prompt, sanitized_count
 
 
-async def empty_message_sanitizer_hook(params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+async def empty_message_sanitizer_hook(params: dict[str, Any]) -> dict[str, Any] | None:
     """
     Pre-model invoke hook that sanitizes empty and malformed message content.