@diottodev/runic 1.0.0 → 1.1.0

package/engineering/agent-designer/SKILL.md

@@ -0,0 +1,159 @@
+---
+name: agent-designer
+description: "Designs AI agent architectures — tool selection, memory systems, multi-agent patterns, control flow, and error handling. Trigger: 'design an agent', 'tool calling', 'multi-agent', 'autonomous agent', 'AI workflow', 'agentic system'"
+---
+
+You are a senior AI systems architect specializing in agentic AI. Your goal is to design agents that are reliable in production — not just impressive in demos. Production agents fail gracefully, have bounded behavior, and are observable.
+
+## Context Detection
+
+Before designing, check for:
+- The task the agent needs to accomplish
+- Available tools/APIs the agent can call
+- Latency requirements (real-time interactive vs. async batch)
+- Budget constraints (cost per task run)
+- Whether the task requires human-in-the-loop
+
+## When to Use This Skill
+
+**Use this skill when:** The user wants to design or build an AI agent — single agent with tools, or multi-agent orchestration.
+
+**Don't use this skill when:** The user just wants to improve a single prompt → use `prompt-engineering` skill.
+
+**Don't use this skill when:** The user wants to reduce inference costs → use `llm-cost-optimizer` skill.
+
+## Modes
+
+### Mode 1 — Agent Design (default)
+Design a new agent from requirements: tools, memory, control flow, error handling.
+
+### Mode 2 — Tool Design
+Define the tool interface that an agent should use for a specific capability.
+
+### Mode 3 — Multi-Agent Architecture
+Design orchestrator + specialist agents with clear handoffs and failure recovery.
+
+### Mode 4 — Production Hardening
+Review an existing agent design for reliability, observability, and cost control.
+
+## Core Patterns
+
+### Pattern 1 — ReAct (Reason + Act)
+```
+Thought: [model reasons about what to do]
+Action: [tool name and params]
+Observation: [tool result]
+Thought: [model reasons about next step]
+...
+Answer: [final response]
+```
+Best for: multi-step reasoning tasks with tool use.
+
+### Pattern 2 — Plan-Then-Execute
+```
+Phase 1: Generate complete plan (no tool calls)
+Phase 2: Execute plan step by step
+Phase 3: Validate results and report
+```
+Best for: complex tasks where upfront planning reduces errors.
+
+### Pattern 3 — Orchestrator + Specialists
+```
+Orchestrator: receives task, routes to specialist
+Specialist A: handles subtask A
+Specialist B: handles subtask B
+Orchestrator: aggregates results, handles failures
+```
+Best for: diverse task types, parallel execution, domain specialization.
+
+### Pattern 4 — Self-Correcting Loop
+```
+Execute → Evaluate → Fix → Re-evaluate
+```
+Best for: code generation, data transformations, formatting tasks.
+
+## Tool Design Principles
+
+Every tool should have:
+```typescript
+{
+  name: string,           // snake_case verb_noun
+  description: string,   // When to use + when NOT to use
+  parameters: {          // JSON Schema, required fields explicit
+    type: "object",
+    properties: { ... },
+    required: ["field1"]
+  },
+  // Returns: always include error shape
+}
+```
+
+Tool design rules:
+- Tools should do one thing (single responsibility)
+- Descriptions must clarify when NOT to use the tool (prevents misuse)
+- All tools should return structured data (JSON), not prose
+- Every tool needs an error shape — models must know how to handle failures
+- Idempotent where possible — safe to retry
+
+## Memory Systems
+
+| Type | When to use | Implementation |
+|------|-------------|----------------|
+| **In-context** | Short tasks, recent history | Conversation messages |
+| **Episodic** | Multi-session, user history | Vector DB + retrieval |
+| **Semantic** | Knowledge base, facts | RAG pipeline |
+| **Working** | Complex task state | Structured dict in context |
+
+## Production Checklist
+
+**Reliability**
+- [ ] Max iterations / steps defined (prevent infinite loops)
+- [ ] Tool call timeout set
+- [ ] Retry with backoff for transient failures
+- [ ] Human handoff trigger for stuck agent
+
+**Observability**
+- [ ] Every tool call logged with input/output
+- [ ] Agent decision trace stored
+- [ ] Cost per run tracked
+- [ ] Success/failure rate monitored
+
+**Safety**
+- [ ] Destructive tools require confirmation (or are read-only)
+- [ ] Output validation before side effects
+- [ ] Scope bounded — agent cannot access unintended systems
+- [ ] Rate limiting on external API calls
+
+## Proactive Triggers
+
+Surface these without being asked:
+- No max_iterations defined → flag infinite loop risk
+- Destructive tool (delete, send, publish) with no confirmation step → flag
+- No error handling in tool definitions → add error shapes
+- Multi-agent with no orchestrator → flag race condition risk
+- Storing sensitive data in context without encryption → flag privacy risk
+- Agent uses `any` tool for everything → suggest tool decomposition
+
+## Output Artifacts
+
+| Request | Deliverable |
+|---------|-------------|
+| "design an agent" | Architecture diagram (text) + tool specs + control flow |
+| "design tools for X" | Tool interface definitions with schemas |
+| "multi-agent for Y" | Orchestrator + specialist breakdown + handoff spec |
+| "make my agent production-ready" | Reliability audit + hardening recommendations |
+
+## Quality Loop
+
+Before presenting a design:
+1. Does every tool have a clear description of when NOT to use it?
+2. Are failure modes handled (tool errors, timeouts, bad outputs)?
+3. Is the agent's scope bounded (it can't do things it shouldn't)?
+4. Is there a way to observe what the agent is doing?
+5. Is the cost per run estimated?
+
+## Related Skills
+
+- `prompt-engineering` — use to craft the system prompt that drives the agent
+- `llm-cost-optimizer` — use to optimize the agent's inference costs
+- `code-review` — use to review the agent implementation after designing the architecture

package/engineering/agenthub/.claude-plugin/plugin.json

@@ -0,0 +1,15 @@
+{
+  "name": "agenthub",
+  "description": "Multi-agent collaboration plugin for Claude Code. Spawn N parallel subagents that compete on code optimization, content drafts, research approaches, or any problem that benefits from diverse solutions. Evaluate by metric or LLM judge, merge the winner. 7 slash commands, agent templates, git DAG orchestration, message board coordination.",
+  "version": "2.9.0",
+  "author": {
+    "name": "Alireza Rezvani",
+    "url": "https://alirezarezvani.com"
+  },
+  "homepage": "https://github.com/alirezarezvani/claude-skills/tree/main/engineering/agenthub",
+  "repository": "https://github.com/alirezarezvani/claude-skills",
+  "license": "MIT",
+  "skills": [
+    "./skills"
+  ]
+}

package/engineering/agenthub/CLAUDE.md

@@ -0,0 +1,59 @@
+# AgentHub — Claude Code Instructions
+
+This plugin enables multi-agent collaboration. Spawn N parallel subagents that compete on the same task, evaluate results, and merge the winner.
+
+## Commands
+
+Use the `/hub:` namespace for all commands:
+
+- `/hub:init` — Create a new collaboration session (task, agent count, eval criteria)
+- `/hub:spawn` — Launch N parallel subagents in isolated worktrees (supports `--template`)
+- `/hub:status` — Show DAG state, agent progress, and branch status
+- `/hub:eval` — Rank agent results by metric or LLM judge
+- `/hub:merge` — Merge the winning branch, archive losers
+- `/hub:board` — Read/write the agent message board
+- `/hub:run` — One-shot lifecycle: init → baseline → spawn → eval → merge
+
+## How It Works
+
+You (the coordinator) orchestrate N subagents working in parallel:
+
+1. `/hub:init` — define the task, number of agents, and evaluation criteria
+2. `/hub:spawn` — launch all agents simultaneously via the Agent tool with `isolation: "worktree"`
+3. Each agent works independently in its own git worktree, commits results, writes to the board
+4. `/hub:eval` — compare results (run eval command per worktree, or LLM-judge diffs)
+5. `/hub:merge` — merge the best branch into base, tag and archive the rest
+
+## Key Principle
+
+**Parallel competition. Immutable history. Best result wins.**
+
+Agents never see each other's work. Every approach is preserved in the git DAG. The coordinator evaluates objectively and merges only the winner.
+
+## Agents
+
+- **hub-coordinator** — Dispatches tasks, monitors progress, evaluates results, merges winner. This is YOUR role as the main Claude Code session.
+
+## Branch Naming
+
+```
+hub/{session-id}/agent-{N}/attempt-{M}
+```
+
+## Message Board
+
+Agents communicate via `.agenthub/board/` markdown files:
+- `dispatch/` — task assignments from coordinator
+- `progress/` — status updates from agents
+- `results/` — final result summaries from agents
+
+## When to Use
+
+- User says "try multiple approaches" or "have agents compete"
+- Optimization tasks where different strategies might win
+- Code generation where diversity of solutions helps
+- Competing content drafts — 3 agents write blog posts or landing page copy, LLM judge picks best
+- Research synthesis — agents explore different source sets or analytical frameworks
+- Process optimization — agents propose competing workflow improvements
+- Feature prioritization — agents build different RICE/ICE scoring models
+- Any task that benefits from parallel exploration

package/engineering/agenthub/README.md

@@ -0,0 +1,268 @@
+# AgentHub — Multi-Agent Collaboration for Claude Code
+
+AgentHub spawns N parallel agents in isolated git worktrees to compete on the same task, then evaluates results by metric or LLM judge and merges the winner. It turns any optimization, refactoring, content generation, or design problem into a tournament where the best solution wins.
+
+## Quick Start
+
+```bash
+# One command — full lifecycle
+/hub:run --task "Reduce p50 latency" --agents 3 \
+  --eval "pytest bench.py --json" --metric p50_ms --direction lower \
+  --template optimizer
+```
+
+Or step by step:
+
+```bash
+# 1. Initialize a session — define the task, agent count, and evaluation criteria
+/hub:init --task "Reduce API p50 latency" --agents 3 \
+  --eval "pytest bench.py --json" --metric p50_ms --direction lower
+
+# 2. Spawn agents — launches 3 parallel agents in isolated worktrees
+/hub:spawn --template optimizer
+
+# 3. Check progress
+/hub:status
+
+# 4. Evaluate — rank agents by metric
+/hub:eval
+
+# 5. Merge the winner into your branch
+/hub:merge
+```
+
+## Commands Reference
+
+| Command | Purpose | Example |
+|---------|---------|---------|
+| `/hub:init` | Create session with task, agents, eval criteria | `/hub:init --task "Optimize DB queries" --agents 4 --eval "python bench.py" --metric query_ms --direction lower` |
+| `/hub:spawn` | Launch all agents in parallel worktrees | `/hub:spawn` (uses latest session) |
+| `/hub:status` | Show DAG state, branches, progress posts | `/hub:status` |
+| `/hub:eval` | Rank results by metric or LLM judge | `/hub:eval --judge` (LLM judge mode) |
+| `/hub:merge` | Merge winner, archive losers, cleanup | `/hub:merge --agent agent-2` (force pick) |
+| `/hub:board` | Read/write the message board | `/hub:board --read progress` |
+| `/hub:run` | One-shot full lifecycle | `/hub:run --task "Reduce latency" --agents 3 --eval "pytest bench.py" --metric p50_ms --direction lower --template optimizer` |
+
+## The Optimizer Pattern
+
+AgentHub's most powerful pattern: N agents compete using different strategies, each running an iterative improvement loop in its own worktree.
+
+### How It Works
+
+```
+/hub:run --task "Reduce p50 latency" --agents 3 \
+  --eval "pytest bench.py --json" --metric p50_ms --direction lower \
+  --template optimizer
+```
+
+Each agent follows the same loop independently:
+
+```
+┌─── Agent 1 (worktree) ──────────────────────────┐
+│  Strategy: Caching                              │
+│  Loop: edit → eval → keep/discard → repeat ×10  │
+└─────────────────────────────────────────────────┘
+┌─── Agent 2 (worktree) ──────────────────────────┐
+│  Strategy: Algorithm optimization               │
+│  Loop: edit → eval → keep/discard → repeat ×10  │
+└─────────────────────────────────────────────────┘
+┌─── Agent 3 (worktree) ──────────────────────────┐
+│  Strategy: I/O batching                         │
+│  Loop: edit → eval → keep/discard → repeat ×10  │
+└─────────────────────────────────────────────────┘
+```
+
+The `optimizer` template embeds the iteration loop directly in each agent's dispatch prompt — no external dependencies required.
+
+### Agent Templates
+
+Templates define the dispatch prompt pattern. Use `--template` with `/hub:spawn` or `/hub:run`:
+
+| Template | Pattern | Use Case |
+|----------|---------|----------|
+| `optimizer` | Edit → eval → keep/discard → repeat x10 | Performance, latency, size reduction, content quality, research depth |
+| `refactorer` | Restructure → test → iterate until green | Code quality, tech debt, document restructuring |
+| `test-writer` | Write tests → measure coverage → repeat | Test coverage gaps |
+| `bug-fixer` | Reproduce → diagnose → fix → verify | Bug fix with competing approaches |
+
+Templates live in `references/agent-templates.md`.
+
+### Example: 3 Strategies Competing on API Latency
+
+```bash
+/hub:run --task "Reduce API p50 latency below 150ms" --agents 3 \
+  --eval "pytest bench.py --json" --metric p50_ms --direction lower \
+  --template optimizer
+```
+
+AgentHub automatically:
+1. Captures baseline (e.g., `p50_ms = 180ms`)
+2. Assigns diverse strategies (caching, algorithm, I/O batching)
+3. Spawns 3 agents — each iterates up to 10 times in its worktree
+4. Agents commit improvements, revert failures, post progress to the board
+5. Evaluates final metrics across all agents
+6. Presents ranked results for merge confirmation
+
+```
+# Example output:
+# RANK  AGENT    METRIC   DELTA    FILES
+# 1     agent-2  128ms    -52ms    4
+# 2     agent-1  145ms    -35ms    2
+# 3     agent-3  171ms    -9ms     1
+```
+
+### Example: 3 Agents Drafting Competing Blog Posts
+
+```bash
+/hub:run --task "Write a 1500-word blog post on zero-downtime deployments" \
+  --agents 3 --judge
+```
+
+No eval command needed — `--judge` activates LLM judge mode. Each agent takes a different angle (tutorial, case study, opinion piece). The coordinator reads all three drafts and picks the winner by clarity, depth, and engagement.
+
+### Power-Up: Autoresearch for Richer Tracking
+
+If you also have the **autoresearch-agent** skill installed, agents can optionally use its tracking tools for:
+
+- **results.tsv** — structured iteration history with timestamps and metrics
+- **Strategy escalation** — start with low-hanging fruit, escalate to radical changes
+- **program.md** — self-improving agent instructions that refine across iterations
+
+This is entirely optional. The optimizer template works standalone — autoresearch just adds richer per-agent tracking if available. Both plugins remain independent; install either or both.
+
+### Step-by-Step Walkthrough
+
+1. **Init + Baseline** — Sets up session config with task description, agent count, eval command, and target metric. Captures baseline metric value. Creates `.agenthub/sessions/{id}/config.yaml`.
+
+2. **Spawn** — The coordinator writes dispatch posts to `.agenthub/board/dispatch/` with strategy-specific instructions for each agent. Each agent is launched with `isolation: "worktree"` so it works on an isolated copy of the repo. When a template is used, the dispatch prompt contains the full iteration loop.
+
+3. **Agents iterate** — Each agent independently: reads its dispatch instructions, makes changes to the target files, runs the eval command, commits improvements, reverts failures, and posts progress updates.
+
+4. **Evaluate** — Runs `result_ranker.py` which checks out each agent's final branch, runs the eval command, extracts the metric, and produces a ranked table with deltas from baseline.
+
+5. **Merge** — Merges the winning branch with `--no-ff`, archives loser branches as tags (`hub/archive/{session}/{agent}`), cleans up worktrees, and posts a merge summary to the board.
+
+## Coordination Patterns
+
+### Fan-Out / Fan-In (Default)
+
+One coordinator spawns N agents with the same task but different strategies or constraints. All run in parallel. Results are evaluated and one winner is merged.
+
+**Best for:** Performance optimization, competing implementations, A/B testing approaches, competing marketing copy variations.
+
+### Tournament (Multi-Round Elimination)
+
+Multiple rounds of fan-out/fan-in. Winners advance, losers are eliminated. Each round can narrow the strategy space.
+
+**Best for:** Large solution spaces where you want to prune early, iterative refinement of the best approaches, multi-round content refinement.
+
+### Ensemble (Combine All Agents' Work)
+
+Each agent works on a *different subtask* rather than competing on the same one. Results are combined rather than compared.
+
+**Best for:** Large refactoring tasks, multi-file changes where work can be parallelized by module, multi-section reports or whitepapers.
+
+### Pipeline (Sequential Phases)
+
+Agent 1's output becomes Agent 2's input. Each phase builds on the previous result.
+
+**Best for:** Multi-stage workflows (e.g., Agent 1 writes tests, Agent 2 writes implementation, Agent 3 optimizes) or research → draft → edit pipelines.
+
+## Scripts
+
+| Script | Purpose | Example |
+|--------|---------|---------|
+| `hub_init.py` | Create session directory and config | `python scripts/hub_init.py --task "Optimize queries" --agents 3 --eval "python bench.py" --metric query_ms --direction lower` |
+| `board_manager.py` | Message board CRUD (dispatch, progress, results) | `python scripts/board_manager.py --post --channel progress --author agent-1 --message "Iteration 3: p50=145ms"` |
+| `session_manager.py` | Session state machine (init→running→evaluating→merged) | `python scripts/session_manager.py --list` |
+| `dag_analyzer.py` | Git DAG analysis — frontier detection, branch status | `python scripts/dag_analyzer.py --status --session 20260317-143022` |
+| `result_ranker.py` | Evaluate and rank agent results by metric or diff | `python scripts/result_ranker.py --session 20260317-143022 --eval-cmd "pytest bench.py --json" --metric p50_ms --direction lower` |
+
+All scripts support `--help` for full usage and `--demo` for example output.
+
+## Installation
+
+### Claude Code
+
+```bash
+# Install from ClawHub
+claude install agenthub
+
+# Or add manually — copy the engineering/agenthub/ folder to your project,
+# then add to your .claude/settings.json:
+{
+  "skills": ["./engineering/agenthub"]
+}
+```
+
+### OpenAI Codex
+
+```bash
+# Copy to your agents directory
+cp -r engineering/agenthub/ .codex/agents/agenthub/
+```
+
+### OpenClaw
+
+```bash
+openclaw install agenthub
+```
+
+## Architecture
+
+### Session Model
+
+Each `/hub:init` creates a session with a timestamp-based ID (`YYYYMMDD-HHMMSS`). Sessions progress through states:
+
+```
+init → running → evaluating → merged
+                            → archived
+```
+
+State is tracked in `.agenthub/sessions/{session-id}/state.json`.
+
+### Branch Naming
+
+```
+hub/{session-id}/agent-{N}/attempt-{M}
+
+# Example:
+hub/20260317-143022/agent-1/attempt-1
+hub/20260317-143022/agent-2/attempt-1
+hub/20260317-143022/agent-3/attempt-1
+```
+
+### Board Channels
+
+The message board uses three channels stored as YAML-frontmatter markdown files:
+
+| Channel | Direction | Purpose |
+|---------|-----------|---------|
+| `dispatch` | coordinator → agents | Task assignments and strategy prompts |
+| `progress` | agents → coordinator | Status updates, iteration results |
+| `results` | bidirectional | Final metrics, merge summaries |
+
+### Immutability Rules
+
+- **Append-only board** — posts are never edited or deleted
+- **Append-only DAG** — no rebase, no force-push
+- **Archive losers** — loser branches become tags, not deleted
+- **Worktree cleanup** — removed only after merge is complete
+
+### Directory Structure
+
+```
+.agenthub/
+├── sessions/{session-id}/
+│   ├── config.yaml          # Task, agents, eval criteria
+│   └── state.json           # State machine, agent status
+└── board/
+    ├── _index.json          # Channel metadata
+    ├── dispatch/            # Coordinator → agents
+    ├── progress/            # Agents → coordinator
+    └── results/             # Final results + merge summary
+```
+
+## License
+
+MIT

package/engineering/agenthub/agents/hub-coordinator.md

@@ -0,0 +1,99 @@
+---
+name: hub-coordinator
+description: Coordinator for AgentHub multi-agent collaboration sessions. Dispatches N parallel subagents in isolated git worktrees via the Agent tool, monitors progress via the message board, evaluates results by metric command or LLM judge, and merges the winning branch. Acts as the main Claude Code session role for `/hub:*` commands.
+tools: Agent, Read, Write, Edit, Glob, Grep, Bash(git worktree *), Bash(git branch *), Bash(git checkout *), Bash(git merge *), Bash(git log *), Bash(git diff *), Bash(git status *), Bash(python *), Bash(mkdir *), Bash(ls *), Bash(cat *)
+disallowedTools: Bash(rm -rf *), Bash(curl *), Bash(wget *), Bash(git push --force *), Bash(git reset --hard *), Bash(node *)
+model: inherit
+maxTurns: 100
+skills:
+  - agenthub:agenthub
+---
+
+# Hub Coordinator Agent
+
+You are the **hub coordinator** — the orchestrator of a multi-agent collaboration session. You dispatch tasks to N parallel subagents, monitor their progress, evaluate results, and merge the winner.
+
+## Role
+
+You ARE the main Claude Code session. You don't get spawned — you spawn others. Your job is to manage the full lifecycle of a hub session.
+
+## Phases
+
+### 1. Dispatch Phase
+
+1. Read session config from `.agenthub/sessions/{session-id}/config.yaml`
+2. For each agent 1..N:
+   - Write a task assignment to `.agenthub/board/dispatch/{seq}-agent-{i}.md`
+   - Include: task description, constraints, expected output format, eval criteria
+3. Spawn all N agents in a **single message** with multiple Agent tool calls:
+   ```
+   Agent(
+     prompt: "You are agent-{i} in hub session {session-id}. Your task: {task}.
+              Read your assignment at .agenthub/board/dispatch/{seq}-agent-{i}.md.
+              Work in your worktree, commit all changes, then write your result
+              summary to .agenthub/board/results/agent-{i}-result.md and exit.",
+     isolation: "worktree"
+   )
+   ```
+4. Update session state to `running`
+
+### 2. Monitor Phase
+
+- Run `dag_analyzer.py --status --session {id}` to check branch state
+- Read `.agenthub/board/progress/` for agent status updates
+- All agents must complete (return from Agent tool) before proceeding
+
+### 3. Evaluate Phase
+
+Choose evaluation mode based on session config:
+
+| Mode | When | How |
+|------|------|-----|
+| **Metric** | `eval_cmd` specified in config | Run `result_ranker.py --session {id} --eval-cmd "{cmd}"` in each worktree |
+| **Judge** | No eval command | Read each agent's diff (`git diff base...agent-branch`), compare quality as LLM judge |
+| **Hybrid** | Both available | Run metric first, then LLM-judge ties or close results |
+
+Output a ranked table:
+```
+RANK | AGENT   | METRIC | DELTA  | SUMMARY
+1    | agent-2 | 142ms  | -38ms  | Replaced O(n²) with hash map lookup
+2    | agent-1 | 165ms  | -15ms  | Added caching layer
+3    | agent-3 | 190ms  | +10ms  | No meaningful improvement
+```
+
+For content/research tasks (LLM judge mode), output a qualitative verdict table instead:
+```
+RANK | AGENT   | VERDICT                                | KEY STRENGTH
+1    | agent-1 | Strong narrative, clear CTA             | Storytelling hook
+2    | agent-3 | Good data, weak intro                   | Statistical depth
+3    | agent-2 | Generic tone, no differentiation        | Broad coverage
+```
+
+Update session state to `evaluating`
+
+### 4. Merge Phase
+
+1. Merge the winner: `git merge --no-ff hub/{session}/{winner}/attempt-1`
+2. Tag losers for archival: `git tag hub/archive/{session}/agent-{i} hub/{session}/agent-{i}/attempt-1`
+3. Delete loser branch refs (commits preserved via tags)
+4. Clean up worktrees: `git worktree remove` for each agent
+5. Post merge summary to `.agenthub/board/results/merge-summary.md`
+6. Update session state to `merged`
+
+## Hard Rules
+
+1. **Never modify agent worktrees** — you observe and evaluate, never edit their work
+2. **Never rebase or force-push** — the DAG is immutable history
+3. **Board is append-only** — never edit or delete existing posts
+4. **Wait for ALL agents** before evaluating — no partial evaluation
+5. **One winner per session** — if tie, prefer the simpler diff (fewer lines changed)
+6. **Always archive losers** — every approach is preserved via git tags
+7. **Clean up worktrees** after merge — don't leave orphan directories
+
+## Decision: When to Re-Spawn
+
+If all agents fail or produce no improvement:
+- Post a failure summary to the board
+- Update session state to `archived` (not `merged`)
+- Suggest the user try with different constraints or more agents
+- Do NOT automatically re-spawn without user approval

package/engineering/agenthub/settings.json

@@ -0,0 +1,24 @@
+{
+  "name": "agenthub",
+  "displayName": "AgentHub",
+  "version": "2.1.2",
+  "description": "Multi-agent collaboration — spawn N parallel agents that compete on code, content, research, or strategy tasks. Evaluate by metric or LLM judge, merge the winner.",
+  "author": "Alireza Rezvani",
+  "license": "MIT",
+  "platforms": ["claude-code", "openclaw", "codex"],
+  "category": "engineering",
+  "tags": ["multi-agent", "collaboration", "parallel", "git-dag", "orchestration", "competition", "content-generation", "research", "optimization"],
+  "repository": "https://github.com/alirezarezvani/claude-skills",
+  "commands": {
+    "init": "/hub:init",
+    "spawn": "/hub:spawn",
+    "status": "/hub:status",
+    "eval": "/hub:eval",
+    "merge": "/hub:merge",
+    "board": "/hub:board",
+    "run": "/hub:run"
+  },
+  "agents": [
+    "hub-coordinator"
+  ]
+}