stravinsky 0.4.36__tar.gz → 0.4.42__tar.gz

{stravinsky-0.4.36 → stravinsky-0.4.42}/.claude/agents/stravinsky.md

@@ -74,7 +74,7 @@ Task(
 
 ## Workflow
 
-### Step 0: Check Skills FIRST (BLOCKING)
+### Step 0: Check Skills FUWT (BLOCKING)
 
 **Before ANY classification or action, scan for matching skills.**
 
@@ -92,7 +92,7 @@ Classify every request into one of 6 types:
 
 | Type | Signal | Action |
 |------|--------|--------|
-| **Skill Match** | Matches skill trigger phrase | **INVOKE skill FIRST** via `skill_get` tool |
+| **Skill Match** | Matches skill trigger phrase | **INVOKE skill FUWT** via `skill_get` tool |
 | **Trivial** | Typo fix, single-line change, known exact location | Direct tools only (UNLESS delegation applies) |
 | **Explicit** | Specific file/line, clear directive | Execute directly |
 | **Exploratory** | "How does X work?", "Find Y", "Where is Z?" | Fire explore (1-3) + tools in parallel |
@@ -137,7 +137,7 @@ This assessment guides how much freedom you have to make changes without asking.
 
 ## Parallel Execution (MANDATORY)
 
-### ⚠️ CRITICAL: PARALLEL-FIRST WORKFLOW
+### ⚠️ CRITICAL: PARALLEL-FUWT WORKFLOW
 
 **BLOCKING REQUIREMENT**: For implementation tasks, your response structure MUST be:
 

{stravinsky-0.4.36 → stravinsky-0.4.42}/.claude/commands/strav.md

@@ -15,7 +15,7 @@ Named after the composer known for revolutionary orchestration.
 
 ---
 
-## Phase 0: Check Skills FIRST (BLOCKING)
+## Phase 0: Check Skills FUWT (BLOCKING)
 
 Before ANY classification or action:
 1. Call `skill_list` to check available skills
@@ -26,13 +26,13 @@ Before ANY classification or action:
 
 ## Phase 1: Classify & Validate
 
-### Step 0: IRONSTAR Mode Detection (PRIORITY CHECK)
+### Step 0: ULTRAWORK Mode Detection (PRIORITY CHECK)
 
 **BEFORE classification, scan prompt for:**
-- Keywords: `ironstar`, `irs`, `ultrawork`, `ulw` (case-insensitive)
+- Keywords: `ultrawork`, `uw`, `ultrawork`, `ulw` (case-insensitive)
 - If detected: **ACTIVATE MAXIMUM PARALLEL MODE**
 
-**IRONSTAR MODE RULES:**
+**ULTRAWORK MODE RULES:**
 1. **ALWAYS use agents** - NEVER work alone with Read/Grep/Bash
 2. **Spawn ALL independent tasks in parallel** - Minimum 2+ agents for any multi-step work
 3. **Default to explore/dewey** - Use cheap agents aggressively
@@ -40,7 +40,7 @@ Before ANY classification or action:
 
 **Example:**
 ```
-User: "ironstar Find auth flow and error handling"
+User: "ultrawork Find auth flow and error handling"
 → IMMEDIATE: agent_spawn(explore, "auth flow") + agent_spawn(explore, "error handling")
 → NEVER: Read file yourself, grep yourself, or work sequentially
 ```
@@ -49,7 +49,7 @@ User: "ironstar Find auth flow and error handling"
 
 | Type | Signal | Action |
 |------|--------|--------|
-| **IRONSTAR Mode** | Contains: ironstar, irs, ultrawork, ulw | Maximum parallel delegation (2+ agents minimum) |
+| **ULTRAWORK Mode** | Contains: ultrawork, uw, ultrawork, ulw | Maximum parallel delegation (2+ agents minimum) |
 | **Skill Match** | Matches skill trigger | INVOKE skill via `skill_get` |
 | **Exploratory** | "How does X work?", "Find Y" | Fire explore agents in parallel |
 | **Implementation** | "Add feature", "Refactor" | Create TODO list → spawn parallel agents |
@@ -60,11 +60,11 @@ User: "ironstar Find auth flow and error handling"
 - Do I have implicit assumptions?
 - What tools/agents can I use: `agent_spawn`, parallel tools, LSP?
 - Should I challenge the user if design seems flawed?
-- **If IRONSTAR detected**: Am I spawning at least 2+ agents in parallel?
+- **If ULTRAWORK detected**: Am I spawning at least 2+ agents in parallel?
 
 ---
 
-## ⚠️ CRITICAL: PARALLEL-FIRST WORKFLOW
+## ⚠️ CRITICAL: PARALLEL-FUWT WORKFLOW
 
 **For ANY task with 2+ independent steps, your response MUST be:**
 
@@ -173,16 +173,16 @@ When using `agent_spawn`, include ALL 7 sections:
 
 | Domain | Delegate To | Trigger |
 |--------|-------------|---------|
-| **Maximum Parallel Mode** | `explore` + `dewey` | **IRONSTAR, IRS, ULTRAWORK, ULW** |
+| **Maximum Parallel Mode** | `explore` + `dewey` | **ULTRAWORK, UW, ULTRAWORK, ULW** |
 | Frontend Visual | `frontend` | Color, spacing, layout, CSS, animation |
 | External Research | `dewey` | Docs, library usage, OSS examples |
 | Internal Search | `explore` | Find patterns in THIS repo |
 | Architecture | `delphi` | Design decisions, tradeoffs |
 | Hard Debugging | `delphi` | After 2+ failed fixes |
 
-### IRONSTAR Mode Behavior
+### ULTRAWORK Mode Behavior
 
-When IRONSTAR/IRS/ULTRAWORK/ULW keywords detected:
+When ULTRAWORK/UW/ULTRAWORK/ULW keywords detected:
 
 **MANDATORY:**
 - ✅ Spawn 2+ agents minimum (even for simple tasks)
@@ -199,7 +199,7 @@ When IRONSTAR/IRS/ULTRAWORK/ULW keywords detected:
 
 ---
 
-## Execution Context (READ THIS FIRST)
+## Execution Context (READ THIS FUWT)
 
 **You are running as:** Stravinsky MCP Skill (via `/strav` command)
 

stravinsky-0.4.42/.claude/hooks/README.md

@@ -0,0 +1,248 @@
+# Claude Code Hooks Architecture
+
+## Overview
+
+This directory contains Claude Code hooks that enforce parallel delegation, provide rich console notifications, and track execution state across conversation turns.
+
+## Hook Execution Order
+
+### UserPromptSubmit (6 hooks)
+1. `context_monitor.py` - Track session context
+2. `parallel_execution.py` - Initial ULTRAWORK mode activation
+3. `parallel_reinforcement.py` - Legacy parallel reminders (deprecated)
+4. `parallel_reinforcement_v2.py` - **NEW** Smart adaptive reminders based on state
+5. `context.py` - Inject project context
+6. `todo_continuation.py` - Resume incomplete todos
+
+### PostToolUse
+1. `truncator.py` - Truncate large outputs
+2. `session_recovery.py` - Session state backup
+3. `execution_state_tracker.py` - **NEW** Track tool usage patterns across turns
+4. `tool_messaging.py` - User-friendly tool notifications (with colors)
+5. `edit_recovery.py` - Backup edited files
+6. `todo_delegation.py` - Enforce parallel after TodoWrite
+7. `dependency_tracker.py` - **NEW** Parse TODO dependencies and build graph
+
+## State Files
+
+Located in `.claude/` directory:
+
+- `execution_state.json` - Tool usage tracking (last 10 tools, Task spawn history)
+- `task_dependencies.json` - TODO dependency graph (independent vs dependent tasks)
+- `hooks/state/agent_batch.json` - Agent spawn batching for grouped notifications
+- `~/.stravinsky_mode` - Hard blocking mode marker (enables stravinsky mode)
+
+## Utilities
+
+### `utils/colors.py`
+- ANSI color codes for terminal output
+- Agent-specific color mappings (blue=explore, purple=dewey, etc.)
+- Terminal capability detection (`supports_color()`)
+
+### `utils/debug.py`
+- Debug mode control via `STRAVINSKY_DEBUG` environment variable
+- Silent by default, verbose when `STRAVINSKY_DEBUG=1`
+
+### `utils/console_format.py`
+- Standardized message formatting with `MessageType` enum
+- Multi-line agent spawn formatting
+- Tool usage formatting with colors
+
+## Environment Variables
+
+- `STRAVINSKY_DEBUG=1` - Enable debug output from hooks
+- `STRAVINSKY_NO_COLOR=1` - Disable ANSI colors (for unsupported terminals)
+- `NO_COLOR=1` - Standard no-color environment variable (also supported)
+
+## Key Features
+
+### 1. Parallel Delegation Enforcement
+
+**Problem**: After turn 3+, Claude degrades to sequential execution despite having independent tasks.
+
+**Solution**: State-based reinforcement via `parallel_reinforcement_v2.py`
+- Tracks last 10 tool calls
+- Detects when Task() hasn't been used recently (2+ turns)
+- Parses TODOs for dependency keywords
+- Injects aggressive reminders when degradation detected
+
+**Files**:
+- `dependency_tracker.py` - Parses TODOs for "after", "depends on", etc.
+- `execution_state_tracker.py` - Tracks tool usage history
+- `parallel_reinforcement_v2.py` - Smart context-aware reminders
+
+### 2. Rich Agent Notifications
+
+**Before**:
+```
+spawned explore:gemini-3-flash('task delegated')
+```
+
+**After**:
+```
+🔵 EXPLORE → gemini-3-flash
+   Task: Find all authentication implementations in codebase
+```
+
+**Features**:
+- Color-coded by agent type (blue, purple, green, orange, red)
+- Multi-line format with clear task descriptions
+- Model name explicitly shown
+- Graceful degradation if terminal doesn't support colors
+
+### 3. Silent Debug Mode
+
+**Problem**: Hook debug output pollutes console (`Failed to send event: ...`)
+
+**Solution**: File-based logging with `STRAVINSKY_DEBUG` control
+- `send_event.py` logs to `~/.claude/hooks/logs/event_sender.log`
+- All debug output hidden unless `STRAVINSKY_DEBUG=1`
+- Clean console by default
+
+## Agent Color Mapping
+
+| Agent | Color | Emoji | Model |
+|-------|-------|-------|-------|
+| explore | Blue | 🔵 | gemini-3-flash |
+| dewey | Purple | 🟣 | gemini-3-flash |
+| frontend | Green | 🟢 | gemini-3-pro-high |
+| delphi | Orange | 🟠 | gpt-5.2-medium |
+| debugger | Red | 🔴 | sonnet-4.5 |
+| code-reviewer | Purple | 🟣 | sonnet-4.5 |
+
+## Dependency Detection
+
+The `dependency_tracker.py` hook parses TODO content for dependency signals:
+
+**Dependency Keywords** (marks as dependent):
+- "after", "depends on", "requires", "once", "when", "then"
+
+**Parallel Keywords** (marks as independent):
+- "also", "meanwhile", "simultaneously", "and", "plus"
+
+**Example**:
+```json
+{
+  "dependencies": {
+    "todo_1": {"deps": [], "independent": true, "parallel_safe": true},
+    "todo_2": {"deps": [], "independent": true, "parallel_safe": true},
+    "todo_3": {"deps": ["todo_1"], "independent": false, "parallel_safe": false}
+  }
+}
+```
+
+## Parallel Reinforcement Algorithm
+
+1. **Check Mode**: Is `~/.stravinsky_mode` active? If not, skip.
+2. **Check State**: Are there 2+ pending TODOs? If not, skip.
+3. **Check History**: How many turns since last `Task()` spawn?
+   - If < 2 turns → skip (still fresh)
+   - If >= 2 turns → degradation detected
+4. **Check Dependencies**: How many independent tasks exist?
+   - If < 2 → skip (no parallelization needed)
+   - If >= 2 → inject aggressive reminder
+5. **Inject Reminder**: Add context-aware instructions to prompt
+
+## Testing
+
+### Test Parallel Delegation Persistence
+
+```bash
+# Create a multi-step task and track behavior over 10+ turns
+# Expected: Task() spawns for independent tasks even at turn 10
+```
+
+### Test Console Output
+
+```bash
+# Run hooks and verify no debug clutter
+export STRAVINSKY_DEBUG=0
+# Should see ONLY user-relevant messages (colored agent notifications)
+
+# Enable debug mode
+export STRAVINSKY_DEBUG=1
+# Should see debug output in ~/.claude/hooks/logs/event_sender.log
+```
+
+### Test Color Support
+
+```bash
+# Disable colors
+export STRAVINSKY_NO_COLOR=1
+# Should see emojis but no ANSI codes
+
+# Enable colors (default)
+unset STRAVINSKY_NO_COLOR
+# Should see colored output
+```
+
+## Architecture Comparison: Stravinsky vs oh-my-opencode
+
+| Aspect | oh-my-opencode (TS) | Stravinsky (Python) |
+|--------|---------------------|---------------------|
+| Parallel Enforcement | Structural (orchestrator pattern) | Prompt-based with state tracking |
+| State Management | Built-in TypeScript state | External JSON files |
+| Dependency Tracking | Explicit graph | Keyword-based parsing |
+| Agent Notifications | Rich formatting (assumed) | Rich formatting with ANSI colors |
+| Console Output | Clean separation | File-based logging + formatting |
+
+## Future Enhancements
+
+1. **Agent Batching** - Group parallel agent spawns visually
+2. **Dependency Graph Visualization** - CLI tool to view task dependencies
+3. **Performance Metrics** - Track agent completion times
+4. **ML-Based Agent Selection** - Predict best agent for task type
+
+## Troubleshooting
+
+### Import Errors in LSP
+
+**Symptom**: Pyright shows "Import could not be resolved" for `utils/*` modules
+
+**Cause**: LSP can't resolve relative imports in hook scripts
+
+**Solution**: These are false positives. Python resolves imports at runtime via `sys.path.insert(0, ...)` in each hook. Safe to ignore.
+
+### Parallel Delegation Still Fails
+
+**Check**:
+1. Is `~/.stravinsky_mode` file present?
+2. Run: `cat .claude/execution_state.json` - verify state is updating
+3. Run: `cat .claude/task_dependencies.json` - verify dependencies detected
+4. Enable debug: `STRAVINSKY_DEBUG=1` and check logs
+
+### Colors Not Showing
+
+**Check**:
+1. Terminal supports ANSI colors? (`echo $TERM`)
+2. `STRAVINSKY_NO_COLOR` or `NO_COLOR` set?
+3. Is stderr a TTY? (Colors disabled for piped output)
+
+## Maintenance
+
+### Adding New Hooks
+
+1. Create hook file in `.claude/hooks/`
+2. Add to appropriate section in `.claude/settings.json`
+3. Test in isolation with mock input
+4. Update this README
+
+### Modifying State Schema
+
+If changing `execution_state.json` or `task_dependencies.json` format:
+1. Update tracker scripts (`execution_state_tracker.py`, `dependency_tracker.py`)
+2. Update consumer scripts (`parallel_reinforcement_v2.py`)
+3. Add migration logic or document breaking change
+4. Consider versioning state files
+
+### Deprecating Old Hooks
+
+1. Mark as deprecated in comments
+2. Add to "Deprecated" section below
+3. After 1 month, remove from `settings.json`
+4. After 2 months, delete file
+
+## Deprecated Hooks
+
+- `parallel_reinforcement.py` - Replaced by `parallel_reinforcement_v2.py` (state-based)
+  - Removal target: TBD (keep for backward compatibility for now)

{stravinsky-0.4.36 → stravinsky-0.4.42}/.claude/hooks/context_monitor.py

@@ -56,7 +56,7 @@ def set_last_compact_tokens(tokens: int):
     """Record token count at compact recommendation."""
     ensure_state_dir()
     try:
-        state = {"last_compact_tokens": tokens, "timestamp": datetime.utcnow().isoformat()}
+        state = {"last_compact_tokens": tokens, "timestamp": datetime.now(timezone.utc).isoformat()}
         CONTEXT_STATE_FILE.write_text(json.dumps(state))
     except IOError:
         pass

stravinsky-0.4.42/.claude/hooks/dependency_tracker.py

@@ -0,0 +1,73 @@
+#!/usr/bin/env python3
+import json
+import os
+import sys
+from pathlib import Path
+
+
+def get_project_dir():
+    return Path(os.environ.get("CLAUDE_CWD", "."))
+
+
+def get_dependency_graph():
+    graph_file = get_project_dir() / ".claude/task_dependencies.json"
+    if graph_file.exists():
+        try:
+            return json.loads(graph_file.read_text())
+        except Exception:
+            pass
+    return {"dependencies": {}}
+
+
+def save_dependency_graph(graph):
+    graph_file = get_project_dir() / ".claude/task_dependencies.json"
+    graph_file.parent.mkdir(parents=True, exist_ok=True)
+    graph_file.write_text(json.dumps(graph, indent=2))
+
+
+DEPENDENCY_KEYWORDS = ["after", "depends on", "requires", "once", "when", "then"]
+PARALLEL_KEYWORDS = ["also", "meanwhile", "simultaneously", "and", "plus"]
+
+
+def parse_todo_dependencies(todos):
+    dependencies = {}
+
+    for todo in todos:
+        todo_id = todo.get("id")
+        content = todo.get("content", "").lower()
+
+        has_dependency = any(kw in content for kw in DEPENDENCY_KEYWORDS)
+        is_parallel = any(kw in content for kw in PARALLEL_KEYWORDS)
+
+        dependencies[todo_id] = {
+            "deps": [],
+            "independent": not has_dependency,
+            "parallel_safe": is_parallel or not has_dependency,
+        }
+
+    return dependencies
+
+
+def main():
+    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
+
+    tool_input = hook_input.get("tool_input", {})
+    todos = tool_input.get("todos", [])
+
+    graph = get_dependency_graph()
+    dependencies = parse_todo_dependencies(todos)
+    graph["dependencies"] = dependencies
+    save_dependency_graph(graph)
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

stravinsky-0.4.42/.claude/hooks/execution_state_tracker.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+import json
+import os
+import sys
+from pathlib import Path
+from datetime import datetime
+
+
+def get_project_dir():
+    return Path(os.environ.get("CLAUDE_CWD", "."))
+
+
+def get_execution_state():
+    state_file = get_project_dir() / ".claude/execution_state.json"
+    if state_file.exists():
+        try:
+            return json.loads(state_file.read_text())
+        except Exception:
+            pass
+
+    return {
+        "last_10_tools": [],
+        "last_task_spawn_index": -1,
+        "pending_todos": 0,
+        "parallel_mode_active": False,
+        "last_updated": None,
+    }
+
+
+def save_execution_state(state):
+    state_file = get_project_dir() / ".claude/execution_state.json"
+    state_file.parent.mkdir(parents=True, exist_ok=True)
+    state["last_updated"] = datetime.now().isoformat()
+    state_file.write_text(json.dumps(state, indent=2))
+
+
+def main():
+    try:
+        hook_input = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        return 0
+
+    tool_name = hook_input.get("tool_name", "")
+
+    state = get_execution_state()
+    state["last_10_tools"].append(tool_name)
+    state["last_10_tools"] = state["last_10_tools"][-10:]
+
+    if tool_name == "Task":
+        try:
+            index = len(state["last_10_tools"]) - 1
+            state["last_task_spawn_index"] = index
+        except:
+            pass
+
+    if tool_name == "TodoWrite":
+        tool_input = hook_input.get("tool_input", {})
+        todos = tool_input.get("todos", [])
+        pending = sum(1 for t in todos if t.get("status") == "pending")
+        state["pending_todos"] = pending
+        state["parallel_mode_active"] = pending >= 2
+
+    save_execution_state(state)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

stravinsky-0.4.42/.claude/hooks/notification_hook_v2.py

@@ -0,0 +1,96 @@
+#!/usr/bin/env python3
+import json
+import sys
+import os
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "utils"))
+
+try:
+    from colors import get_agent_color, Color
+    from console_format import format_agent_spawn
+except ImportError:
+
+    def get_agent_color(agent_type):
+        return ("", "⚪")
+
+    def format_agent_spawn(agent_type, model, description, color_code, emoji):
+        lines = [f"{emoji} {agent_type.upper()} → {model}", f"   Task: {description}", ""]
+        return "\n".join(lines)
+
+
+AGENT_DISPLAY_MODELS = {
+    "explore": "gemini-3-flash",
+    "dewey": "gemini-3-flash",
+    "document_writer": "gemini-3-flash",
+    "multimodal": "gemini-3-flash",
+    "frontend": "gemini-3-pro-high",
+    "delphi": "gpt-5.2-medium",
+    "planner": "opus-4.5",
+    "code-reviewer": "sonnet-4.5",
+    "debugger": "sonnet-4.5",
+    "_default": "sonnet-4.5",
+}
+
+
+def extract_agent_info(message):
+    message_lower = message.lower()
+    agent_type = None
+    description = ""
+
+    for agent in AGENT_DISPLAY_MODELS.keys():
+        if agent == "_default":
+            continue
+        if agent in message_lower:
+            agent_type = agent
+            idx = message_lower.find(agent)
+            description = message[idx + len(agent) :].strip()[:80]
+            break
+
+    if not agent_type:
+        return None
+
+    description = description.strip(":-() ")
+    if not description:
+        description = "task delegated"
+
+    model = AGENT_DISPLAY_MODELS.get(agent_type, AGENT_DISPLAY_MODELS["_default"])
+    color_code, emoji = get_agent_color(agent_type)
+
+    return {
+        "agent_type": agent_type,
+        "model": model,
+        "description": description,
+        "color_code": color_code,
+        "emoji": emoji,
+    }
+
+
+def main():
+    try:
+        hook_input = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        return 0
+
+    message = hook_input.get("message", "")
+    agent_keywords = ["agent", "spawn", "delegat", "task"]
+    if not any(kw in message.lower() for kw in agent_keywords):
+        return 0
+
+    agent_info = extract_agent_info(message)
+    if not agent_info:
+        return 0
+
+    formatted = format_agent_spawn(
+        agent_info["agent_type"],
+        agent_info["model"],
+        agent_info["description"],
+        agent_info["color_code"],
+        agent_info["emoji"],
+    )
+    print(formatted, file=sys.stderr)
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())