@aigentic/claude-flow 3.7.0-alpha.69

package/.claude/skills/browser/SKILL.md

@@ -0,0 +1,204 @@
+---
+name: browser
+description: Web browser automation with AI-optimized snapshots for claude-flow agents
+version: 1.0.0
+triggers:
+  - /browser
+  - browse
+  - web automation
+  - scrape
+  - navigate
+  - screenshot
+tools:
+  - browser/open
+  - browser/snapshot
+  - browser/click
+  - browser/fill
+  - browser/screenshot
+  - browser/close
+---
+
+# Browser Automation Skill
+
+Web browser automation using agent-browser with AI-optimized snapshots. Reduces context by 93% using element refs (@e1, @e2) instead of full DOM.
+
+## Core Workflow
+
+```bash
+# 1. Navigate to page
+agent-browser open <url>
+
+# 2. Get accessibility tree with element refs
+agent-browser snapshot -i    # -i = interactive elements only
+
+# 3. Interact using refs from snapshot
+agent-browser click @e2
+agent-browser fill @e3 "text"
+
+# 4. Re-snapshot after page changes
+agent-browser snapshot -i
+```
+
+## Quick Reference
+
+### Navigation
+| Command | Description |
+|---------|-------------|
+| `open <url>` | Navigate to URL |
+| `back` | Go back |
+| `forward` | Go forward |
+| `reload` | Reload page |
+| `close` | Close browser |
+
+### Snapshots (AI-Optimized)
+| Command | Description |
+|---------|-------------|
+| `snapshot` | Full accessibility tree |
+| `snapshot -i` | Interactive elements only (buttons, links, inputs) |
+| `snapshot -c` | Compact (remove empty elements) |
+| `snapshot -d 3` | Limit depth to 3 levels |
+| `screenshot [path]` | Capture screenshot (base64 if no path) |
+
+### Interaction
+| Command | Description |
+|---------|-------------|
+| `click <sel>` | Click element |
+| `fill <sel> <text>` | Clear and fill input |
+| `type <sel> <text>` | Type with key events |
+| `press <key>` | Press key (Enter, Tab, etc.) |
+| `hover <sel>` | Hover element |
+| `select <sel> <val>` | Select dropdown option |
+| `check/uncheck <sel>` | Toggle checkbox |
+| `scroll <dir> [px]` | Scroll page |
+
+### Get Info
+| Command | Description |
+|---------|-------------|
+| `get text <sel>` | Get text content |
+| `get html <sel>` | Get innerHTML |
+| `get value <sel>` | Get input value |
+| `get attr <sel> <attr>` | Get attribute |
+| `get title` | Get page title |
+| `get url` | Get current URL |
+
+### Wait
+| Command | Description |
+|---------|-------------|
+| `wait <selector>` | Wait for element |
+| `wait <ms>` | Wait milliseconds |
+| `wait --text "text"` | Wait for text |
+| `wait --url "pattern"` | Wait for URL |
+| `wait --load networkidle` | Wait for load state |
+
+### Sessions
+| Command | Description |
+|---------|-------------|
+| `--session <name>` | Use isolated session |
+| `session list` | List active sessions |
+
+## Selectors
+
+### Element Refs (Recommended)
+```bash
+# Get refs from snapshot
+agent-browser snapshot -i
+# Output: button "Submit" [ref=e2]
+
+# Use ref to interact
+agent-browser click @e2
+```
+
+### CSS Selectors
+```bash
+agent-browser click "#submit"
+agent-browser fill ".email-input" "test@test.com"
+```
+
+### Semantic Locators
+```bash
+agent-browser find role button click --name "Submit"
+agent-browser find label "Email" fill "test@test.com"
+agent-browser find testid "login-btn" click
+```
+
+## Examples
+
+### Login Flow
+```bash
+agent-browser open https://example.com/login
+agent-browser snapshot -i
+agent-browser fill @e2 "user@example.com"
+agent-browser fill @e3 "password123"
+agent-browser click @e4
+agent-browser wait --url "**/dashboard"
+```
+
+### Form Submission
+```bash
+agent-browser open https://example.com/contact
+agent-browser snapshot -i
+agent-browser fill @e1 "John Doe"
+agent-browser fill @e2 "john@example.com"
+agent-browser fill @e3 "Hello, this is my message"
+agent-browser click @e4
+agent-browser wait --text "Thank you"
+```
+
+### Data Extraction
+```bash
+agent-browser open https://example.com/products
+agent-browser snapshot -i
+# Iterate through product refs
+agent-browser get text @e1  # Product name
+agent-browser get text @e2  # Price
+agent-browser get attr @e3 href  # Link
+```
+
+### Multi-Session (Swarm)
+```bash
+# Session 1: Navigator
+agent-browser --session nav open https://example.com
+agent-browser --session nav state save auth.json
+
+# Session 2: Scraper (uses same auth)
+agent-browser --session scrape state load auth.json
+agent-browser --session scrape open https://example.com/data
+agent-browser --session scrape snapshot -i
+```
+
+## Integration with Claude Flow
+
+### MCP Tools
+All browser operations are available as MCP tools with `browser/` prefix:
+- `browser/open`
+- `browser/snapshot`
+- `browser/click`
+- `browser/fill`
+- `browser/screenshot`
+- etc.
+
+### Memory Integration
+```bash
+# Store successful patterns
+npx @claude-flow/cli memory store --namespace browser-patterns --key "login-flow" --value "snapshot->fill->click->wait"
+
+# Retrieve before similar task
+npx @claude-flow/cli memory search --query "login automation"
+```
+
+### Hooks
+```bash
+# Pre-browse hook (get context)
+npx @claude-flow/cli hooks pre-edit --file "browser-task.ts"
+
+# Post-browse hook (record success)
+npx @claude-flow/cli hooks post-task --task-id "browse-1" --success true
+```
+
+## Tips
+
+1. **Always use snapshots** - They're optimized for AI with refs
+2. **Prefer `-i` flag** - Gets only interactive elements, smaller output
+3. **Use refs, not selectors** - More reliable, deterministic
+4. **Re-snapshot after navigation** - Page state changes
+5. **Use sessions for parallel work** - Each session is isolated

package/.claude/skills/dual-mode/README.md

@@ -0,0 +1,71 @@
+# Dual-Mode Skills (Claude Code + Codex)
+
+Optional skills for orchestrating Claude Code and headless Codex workers together.
+
+## Available Skills
+
+| Skill | File | Purpose |
+|-------|------|---------|
+| `/dual-spawn` | dual-spawn.md | Spawn headless Codex workers from Claude Code |
+| `/dual-coordinate` | dual-coordinate.md | Coordinate hybrid Claude+Codex workflows |
+| `/dual-collect` | dual-collect.md | Collect results from headless workers |
+
+## Quick Start
+
+### Spawn Parallel Workers
+```
+/dual-spawn "Implement auth module" --workers 3
+```
+
+This spawns 3 headless Codex workers in background.
+
+### Collect Results
+```
+/dual-collect --namespace results
+```
+
+### Full Hybrid Workflow
+```
+/dual-coordinate --workflow hybrid_development --task "Build user API"
+```
+
+## Workflow Examples
+
+### Feature Implementation
+```bash
+# 1. Spawn implementation workers
+/dual-spawn "Implement user CRUD API" --workers 2 --type coder
+
+# 2. Spawn test writer
+/dual-spawn "Write tests for user API" --workers 1 --type tester
+
+# 3. Collect all results
+/dual-collect --format detailed
+```
+
+### Documentation Sprint
+```bash
+/dual-spawn "Document all API endpoints" --workers 4 --type docs
+/dual-collect --namespace results
+```
+
+## Related Agents
+
+See `.claude/agents/dual-mode/` for agent definitions:
+- `dual-orchestrator` - Hybrid workflow orchestration
+- `codex-coordinator` - Parallel worker coordination
+- `codex-worker` - Headless execution worker
+
+## How It Works
+
+1. **Skills** define the command interface (what you type)
+2. **Agents** define the behavior and capabilities
+3. **Memory** provides coordination between workers
+4. **MCP tools** handle the underlying operations
+
+All workers share memory via claude-flow MCP tools for seamless coordination.
+
+## Installation
+
+Skills are pre-installed in `.claude/skills/dual-mode/`.
+Invoke with `/skill-name` in Claude Code.

package/.claude/skills/dual-mode/dual-collect.md

@@ -0,0 +1,103 @@
+---
+name: dual-collect
+description: Collect results from headless Codex workers
+---
+
+# Dual Collect Skill
+
+Collect and aggregate results from headless Codex workers stored in shared memory.
+
+## Usage
+
+```
+/dual-collect [--namespace <namespace>] [--format <format>]
+```
+
+## Parameters
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `--namespace` | results | Memory namespace to search |
+| `--format` | summary | Output format: summary, detailed, json |
+| `--filter` | none | Filter by key pattern |
+
+## Examples
+
+### Collect All Results
+```
+/dual-collect
+```
+
+### Collect from Specific Namespace
+```
+/dual-collect --namespace patterns
+```
+
+### Detailed Output
+```
+/dual-collect --format detailed
+```
+
+### Filter by Worker
+```
+/dual-collect --filter "worker-auth-*"
+```
+
+## How It Works
+
+1. Queries the memory system for entries in specified namespace
+2. Aggregates results from all workers
+3. Formats output according to specified format
+4. Displays summary of completed/failed workers
+
+## Generated Commands
+
+```bash
+# List all results
+npx claude-flow@v3alpha memory list --namespace {{namespace}}
+
+# Search for specific patterns
+npx claude-flow@v3alpha memory search -q "{{filter}}" -n {{namespace}}
+
+# Get detailed entries
+{{#each results}}
+npx claude-flow@v3alpha memory get -k "{{this.key}}" -n {{namespace}}
+{{/each}}
+```
+
+## Output Formats
+
+### Summary (default)
+```
+Workers Completed: 4/4
+├─ worker-auth-core: ✅ Complete (auth.service.ts)
+├─ worker-auth-api: ✅ Complete (auth.controller.ts)
+├─ worker-tests: ✅ Complete (15 tests passing)
+└─ worker-docs: ✅ Complete (API.md updated)
+```
+
+### Detailed
+```
+┌─────────────────────────────────────────────────┐
+│ Worker: worker-auth-core                        │
+│ Status: Complete                                │
+│ Duration: 45s                                   │
+│ Files: auth.service.ts, auth.types.ts           │
+│ Result: Implemented JWT authentication          │
+└─────────────────────────────────────────────────┘
+```
+
+### JSON
+```json
+{
+  "workers": [
+    {"id": "worker-auth-core", "status": "complete", "result": "..."}
+  ],
+  "summary": {"total": 4, "completed": 4, "failed": 0}
+}
+```
+
+## Related Skills
+
+- `/dual-spawn` - Spawn headless workers
+- `/dual-coordinate` - Full hybrid workflow

package/.claude/skills/dual-mode/dual-coordinate.md

@@ -0,0 +1,85 @@
+---
+name: dual-coordinate
+description: Coordinate hybrid Claude Code + Codex workflows
+---
+
+# Dual Coordinate Skill
+
+Coordinate hybrid workflows that use Claude Code for interactive reasoning and Codex for parallel background execution.
+
+## Usage
+
+```
+/dual-coordinate --workflow <workflow-name> --task "<task-description>"
+```
+
+## Parameters
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `--workflow` | hybrid_development | Workflow template to use |
+| `--task` | required | Task description |
+| `--interactive-first` | true | Start with interactive phase |
+
+## Available Workflows
+
+### hybrid_development
+Design interactively, implement in parallel, review interactively.
+
+```
+/dual-coordinate --workflow hybrid_development --task "Build user authentication"
+```
+
+### parallel_feature
+Spawn multiple Codex workers for parallel implementation.
+
+```
+/dual-coordinate --workflow parallel_feature --task "Implement REST API"
+```
+
+### design_and_execute
+Interactive design phase, then batch execution.
+
+```
+/dual-coordinate --workflow design_and_execute --task "Refactor auth module"
+```
+
+## How It Works
+
+1. **Routing Decision**: Analyzes task to determine optimal platform split
+2. **Interactive Phase**: Complex reasoning in Claude Code
+3. **Parallel Phase**: Spawns Codex workers for execution
+4. **Review Phase**: Returns to Claude Code for quality review
+5. **Result Collection**: Aggregates worker results from memory
+
+## Generated Commands
+
+```bash
+# Phase 1: Interactive (Claude Code)
+# [Current session handles design/planning]
+
+# Phase 2: Parallel (Codex)
+{{#each workers}}
+claude -p "{{this.task}}" --session-id {{this.id}} &
+{{/each}}
+wait
+
+# Phase 3: Review (Claude Code)
+npx claude-flow@v3alpha memory list --namespace results
+```
+
+## Example: Full Hybrid Workflow
+
+```
+/dual-coordinate --workflow hybrid_development --task "Build user profile API"
+```
+
+This will:
+1. **Design Phase** (Interactive): Discuss requirements, design endpoints, plan implementation
+2. **Implement Phase** (Headless): Spawn coders, testers, docs writers in parallel
+3. **Review Phase** (Interactive): Review implementation, discuss improvements
+
+## Related Skills
+
+- `/dual-spawn` - Spawn headless workers only
+- `/dual-collect` - Collect results from workers

package/.claude/skills/dual-mode/dual-spawn.md

@@ -0,0 +1,81 @@
+---
+name: dual-spawn
+description: Spawn headless Codex workers from Claude Code for parallel execution
+---
+
+# Dual Spawn Skill
+
+Spawn multiple headless Codex workers to run tasks in parallel while you continue working interactively.
+
+## Usage
+
+```
+/dual-spawn "<task>" --workers <count> [--type <worker-type>]
+```
+
+## Parameters
+
+| Parameter | Default | Description |
+|-----------|---------|-------------|
+| `task` | required | Task description for workers |
+| `--workers` | 3 | Number of parallel workers |
+| `--type` | coder | Worker type: coder, tester, docs, reviewer |
+| `--wait` | false | Wait for completion |
+
+## Examples
+
+### Spawn Implementation Workers
+```
+/dual-spawn "Implement user authentication" --workers 2 --type coder
+```
+
+### Spawn Test Writers
+```
+/dual-spawn "Write comprehensive tests for auth module" --workers 2 --type tester
+```
+
+### Spawn Documentation Workers
+```
+/dual-spawn "Document all API endpoints" --workers 1 --type docs
+```
+
+## How It Works
+
+1. Initializes shared swarm coordination
+2. Spawns headless Codex workers with `claude -p`
+3. Each worker searches memory for relevant patterns
+4. Workers execute in parallel
+5. Results stored in shared memory
+
+## Generated Commands
+
+```bash
+# Initialize coordination
+npx claude-flow swarm init --topology hierarchical --max-agents {{workers}}
+
+# Spawn workers
+{{#each workers}}
+claude -p "
+You are worker-{{@index}}.
+TASK: {{task}}
+
+1. Search: memory_search(query='{{task_keywords}}')
+2. Execute your assigned work
+3. Store: memory_store(key='result-{{@index}}', namespace='results', upsert=true)
+" --session-id task-{{@index}} &
+{{/each}}
+
+echo "Spawned {{workers}} headless workers"
+```
+
+## After Spawning
+
+Use `/dual-collect` to gather results:
+```
+/dual-collect --namespace results
+```
+
+Or check manually:
+```bash
+npx claude-flow memory list --namespace results
+```