stravinsky 0.4.17__tar.gz → 0.4.41__tar.gz

{stravinsky-0.4.17 → stravinsky-0.4.41}/.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.41/.claude/commands/git-master.md

@@ -0,0 +1,112 @@
+# Git Master Skill
+
+Atomic commits with conventional format and smart history search.
+
+## Invocation
+
+```
+/git-master <command>
+```
+
+## Commands
+
+### commit - Smart Atomic Commit
+
+```
+/git-master commit
+```
+
+Workflow:
+1. Run `git status` and `git diff --staged`
+2. Analyze changes to determine commit type
+3. Generate conventional commit message
+4. Create atomic commit
+
+**Commit Types** (Conventional Commits):
+- `feat`: New feature
+- `fix`: Bug fix
+- `docs`: Documentation only
+- `style`: Formatting, no code change
+- `refactor`: Code restructuring
+- `perf`: Performance improvement
+- `test`: Adding/updating tests
+- `chore`: Build, config, dependencies
+
+**Message Format**:
+```
+<type>(<scope>): <description>
+
+[optional body]
+
+[optional footer]
+```
+
+### search - History Search
+
+```
+/git-master search <pattern>
+```
+
+Find commits matching a pattern:
+- By message: `/git-master search "fix auth"`
+- By file: `/git-master search --file src/auth.py`
+- By author: `/git-master search --author david`
+- By date: `/git-master search --since "1 week ago"`
+
+### split - Split Large Changes
+
+```
+/git-master split
+```
+
+When staged changes are too large:
+1. Analyze logical groupings
+2. Suggest split points
+3. Create multiple atomic commits
+
+### amend - Smart Amend
+
+```
+/git-master amend
+```
+
+Safely amend the last commit:
+1. Verify commit hasn't been pushed
+2. Verify you're the author
+3. Add staged changes to last commit
+4. Update message if requested
+
+## Rules
+
+1. **Atomic Commits**: One logical change per commit
+2. **Conventional Format**: Always use conventional commits
+3. **No Secrets**: Block commits containing secrets
+4. **Pre-push Check**: Verify before push to main/master
+
+## Examples
+
+```bash
+# Smart commit with auto-generated message
+/git-master commit
+
+# Search for auth-related commits
+/git-master search "auth"
+
+# Find commits that modified a specific file
+/git-master search --file mcp_bridge/auth/oauth.py
+
+# Split large staged changes
+/git-master split
+```
+
+## Safety Checks
+
+Before committing, Git Master checks for:
+- Exposed secrets (API keys, tokens, passwords)
+- Debug/test code that shouldn't be committed
+- Large binary files
+- Merge conflict markers
+
+---
+
+$ARGUMENTS: command (required) - The git-master command to execute

stravinsky-0.4.41/.claude/commands/str/list_watchers.md

@@ -0,0 +1,96 @@
+---
+description: /str:list_watchers - List all active file watchers across projects
+allowed-tools: mcp__stravinsky__list_file_watchers
+---
+
+# List Active File Watchers
+
+View all currently running file watchers for automatic semantic search reindexing.
+
+## What This Does
+
+Displays information about active file watchers across all projects including:
+- Project path being watched
+- Embedding provider (ollama, gemini, openai, huggingface)
+- Debounce interval (wait time before reindexing)
+- Current status (running/stopped)
+
+## Prerequisites
+
+At least one file watcher must be running. Start a watcher with `/str:start_filewatch` first.
+
+## Usage
+
+Call the MCP tool directly (no parameters):
+
+```python
+mcp__stravinsky__list_file_watchers()
+```
+
+Returns a list of dicts with:
+- `project_path`: Root directory being watched
+- `provider`: Embedding provider name
+- `debounce_seconds`: Wait time before reindexing
+- `status`: "running" or "stopped"
+
+## Example Output
+
+```
+Active File Watchers
+====================
+
+Watcher 1:
+  Project: /Users/dev/project1
+  Provider: ollama
+  Debounce: 2.0s
+  Status: running
+
+Watcher 2:
+  Project: /Users/dev/project2
+  Provider: gemini
+  Debounce: 3.0s
+  Status: running
+
+Total: 2 active watchers
+```
+
+## Use Cases
+
+**Before stopping a watcher:**
+```python
+# List watchers to get project path
+mcp__stravinsky__list_file_watchers()
+
+# Stop specific watcher
+mcp__stravinsky__stop_file_watcher(project_path="/Users/dev/project1")
+```
+
+**Check status across multiple repos:**
+```python
+# See all watched projects at once
+mcp__stravinsky__list_file_watchers()
+```
+
+**Verify watcher started successfully:**
+```python
+# After starting watcher
+mcp__stravinsky__start_file_watcher(project_path=".", provider="ollama")
+
+# Confirm it's running
+mcp__stravinsky__list_file_watchers()
+```
+
+## Troubleshooting
+
+**"No active watchers"**: Start a watcher with `/str:start_filewatch` first.
+
+**"Watcher shows stopped"**: The watcher encountered an error or was manually stopped. Restart with `/str:start_filewatch`.
+
+**Multiple watchers for same project**: This indicates duplicate watcher processes. Stop and restart with `/str:stop_filewatch`.
+
+## Tips
+
+- Run this before stopping watchers to identify project paths
+- Use to verify watchers are running after system restart
+- Check status if reindexing seems not to be happening automatically
+- Each project can only have ONE active watcher per provider

{stravinsky-0.4.17 → stravinsky-0.4.41}/.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,10 +26,30 @@ Before ANY classification or action:
 
 ## Phase 1: Classify & Validate
 
+### Step 0: ULTRAWORK Mode Detection (PRIORITY CHECK)
+
+**BEFORE classification, scan prompt for:**
+- Keywords: `ultrawork`, `uw`, `ultrawork`, `ulw` (case-insensitive)
+- If detected: **ACTIVATE MAXIMUM PARALLEL MODE**
+
+**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
+4. **No sequential work** - If tasks can run in parallel, they MUST
+
+**Example:**
+```
+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
+```
+
 ### Step 1: Classify Request Type
 
 | Type | Signal | Action |
 |------|--------|--------|
+| **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 |
@@ -40,22 +60,24 @@ Before ANY classification or action:
 - 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 ULTRAWORK detected**: Am I spawning at least 2+ agents in parallel?
 
 ---
 
-## ⚠️ CRITICAL: PARALLEL-FIRST WORKFLOW
+## ⚠️ CRITICAL: PARALLEL-FUWT WORKFLOW
 
-**For implementation tasks, your response MUST be:**
+**For ANY task with 2+ independent steps, your response MUST be:**
 
 ```
-1. TodoWrite (create all items)
-2. SAME RESPONSE: Multiple agent_spawn() calls for ALL independent TODOs
+1. TodoWrite (create all items) OR identify independent subtasks
+2. SAME RESPONSE: Multiple agent_spawn() calls for ALL independent work
 3. NEVER mark in_progress until agents return
+4. NEVER use Read/Grep/Bash when agents can do it
 ```
 
-**BLOCKING REQUIREMENT**: After TodoWrite, spawn ALL agents in the SAME response.
+**BLOCKING REQUIREMENT**: After TodoWrite OR after identifying exploratory work, spawn ALL agents in the SAME response.
 
-### CORRECT (one response with parallel agents):
+### ✅ CORRECT Pattern 1: Implementation with TODOs
 ```
 TodoWrite([todo1, todo2, todo3])
 agent_spawn(agent_type="explore", prompt="TODO 1...")
@@ -64,14 +86,46 @@ agent_spawn(agent_type="explore", prompt="TODO 2...")
   → explore:gemini-3-flash('TODO 2...') task_id=agent_def456
 agent_spawn(agent_type="dewey", prompt="TODO 3...")
   → dewey:gemini-3-flash('TODO 3...') task_id=agent_ghi789
+# Continue in SAME response - collect results later
 ```
 
-### WRONG (sequential - defeats parallelism):
+### ✅ CORRECT Pattern 2: Exploratory (NO TodoWrite needed)
+```
+User: "Find auth flow and error handling"
+
+# IMMEDIATE parallel spawn (no TodoWrite):
+agent_spawn(agent_type="explore", prompt="Find auth flow...")
+  → explore:gemini-3-flash('Find auth flow...') task_id=agent_abc123
+agent_spawn(agent_type="explore", prompt="Find error handling...")
+  → explore:gemini-3-flash('Find error handling...') task_id=agent_def456
+# Continue in SAME response
+```
+
+### ❌ WRONG Pattern 1: Sequential (defeats parallelism)
 ```
 TodoWrite([todo1, todo2, todo3])
 # Response ends - WRONG!
-# Next: Mark todo1 in_progress - WRONG!
-# Next: Do work manually - WRONG!
+# Next response: Mark todo1 in_progress - WRONG!
+# Next response: Do work manually - WRONG!
+```
+
+### ❌ WRONG Pattern 2: Manual Work (when agents available)
+```
+User: "Find auth flow and error handling"
+
+# WRONG - doing it yourself:
+Read("src/auth.py")  # Should be agent_spawn(explore)
+Grep("error", "**/*.py")  # Should be agent_spawn(explore)
+```
+
+### Decision Tree: When to Spawn Agents
+
+```
+Is this exploratory (search, find, understand)?
+├─ YES → Spawn explore/dewey agents immediately (no TodoWrite)
+└─ NO → Is this implementation with 2+ steps?
+    ├─ YES → TodoWrite + spawn agents in SAME response
+    └─ NO → Single simple task, work directly (rare)
 ```
 
 ---
@@ -119,15 +173,33 @@ When using `agent_spawn`, include ALL 7 sections:
 
 | Domain | Delegate To | Trigger |
 |--------|-------------|---------|
+| **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 |
 
+### ULTRAWORK Mode Behavior
+
+When ULTRAWORK/UW/ULTRAWORK/ULW keywords detected:
+
+**MANDATORY:**
+- ✅ Spawn 2+ agents minimum (even for simple tasks)
+- ✅ Use explore for ALL code searches
+- ✅ Use dewey for ALL external research
+- ✅ Fire all agents in SAME response
+- ✅ NEVER use Read/Grep/Bash directly
+
+**FORBIDDEN:**
+- ❌ Working alone without agents
+- ❌ Sequential execution (spawn one, wait, spawn another)
+- ❌ Single agent for multi-part tasks
+- ❌ Direct tool usage (Read, Grep, Bash) when agents available
+
 ---
 
-## Execution Context (READ THIS FIRST)
+## Execution Context (READ THIS FUWT)
 
 **You are running as:** Stravinsky MCP Skill (via `/strav` command)
 

stravinsky-0.4.41/.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)