aigroup-workflow 1.0.1 → 1.1.0

package/skills/jarvis/engineering-team/docs/skills/engineering/agent-designer.md

@@ -1,290 +0,0 @@
----
-title: "Agent Designer - Multi-Agent System Architecture — Agent Skill for Codex & OpenClaw"
-description: "Agent Designer - Multi-Agent System Architecture. Agent skill for Claude Code, Codex CLI, Gemini CLI, OpenClaw."
----
-
-# Agent Designer - Multi-Agent System Architecture
-
-<div class="page-meta" markdown>
-<span class="meta-badge">:material-rocket-launch: Engineering - POWERFUL</span>
-<span class="meta-badge">:material-identifier: `agent-designer`</span>
-<span class="meta-badge">:material-github: <a href="https://github.com/alirezarezvani/claude-skills/tree/main/engineering/agent-designer/SKILL.md">Source</a></span>
-</div>
-
-<div class="install-banner" markdown>
-<span class="install-label">Install:</span> <code>claude /plugin install engineering-advanced-skills</code>
-</div>
-
-
-**Tier:** POWERFUL  
-**Category:** Engineering  
-**Tags:** AI agents, architecture, system design, orchestration, multi-agent systems
-
-## Overview
-
-Agent Designer is a comprehensive toolkit for designing, architecting, and evaluating multi-agent systems. It provides structured approaches to agent architecture patterns, tool design principles, communication strategies, and performance evaluation frameworks for building robust, scalable AI agent systems.
-
-## Core Capabilities
-
-### 1. Agent Architecture Patterns
-
-#### Single Agent Pattern
-- **Use Case:** Simple, focused tasks with clear boundaries
-- **Pros:** Minimal complexity, easy debugging, predictable behavior
-- **Cons:** Limited scalability, single point of failure
-- **Implementation:** Direct user-agent interaction with comprehensive tool access
-
-#### Supervisor Pattern
-- **Use Case:** Hierarchical task decomposition with centralized control
-- **Architecture:** One supervisor agent coordinating multiple specialist agents
-- **Pros:** Clear command structure, centralized decision making
-- **Cons:** Supervisor bottleneck, complex coordination logic
-- **Implementation:** Supervisor receives tasks, delegates to specialists, aggregates results
-
-#### Swarm Pattern
-- **Use Case:** Distributed problem solving with peer-to-peer collaboration
-- **Architecture:** Multiple autonomous agents with shared objectives
-- **Pros:** High parallelism, fault tolerance, emergent intelligence
-- **Cons:** Complex coordination, potential conflicts, harder to predict
-- **Implementation:** Agent discovery, consensus mechanisms, distributed task allocation
-
-#### Hierarchical Pattern
-- **Use Case:** Complex systems with multiple organizational layers
-- **Architecture:** Tree structure with managers and workers at different levels
-- **Pros:** Natural organizational mapping, clear responsibilities
-- **Cons:** Communication overhead, potential bottlenecks at each level
-- **Implementation:** Multi-level delegation with feedback loops
-
-#### Pipeline Pattern
-- **Use Case:** Sequential processing with specialized stages
-- **Architecture:** Agents arranged in processing pipeline
-- **Pros:** Clear data flow, specialized optimization per stage
-- **Cons:** Sequential bottlenecks, rigid processing order
-- **Implementation:** Message queues between stages, state handoffs
-
-### 2. Agent Role Definition
-
-#### Role Specification Framework
-- **Identity:** Name, purpose statement, core competencies
-- **Responsibilities:** Primary tasks, decision boundaries, success criteria
-- **Capabilities:** Required tools, knowledge domains, processing limits
-- **Interfaces:** Input/output formats, communication protocols
-- **Constraints:** Security boundaries, resource limits, operational guidelines
-
-#### Common Agent Archetypes
-
-**Coordinator Agent**
-- Orchestrates multi-agent workflows
-- Makes high-level decisions and resource allocation
-- Monitors system health and performance
-- Handles escalations and conflict resolution
-
-**Specialist Agent**
-- Deep expertise in specific domain (code, data, research)
-- Optimized tools and knowledge for specialized tasks
-- High-quality output within narrow scope
-- Clear handoff protocols for out-of-scope requests
-
-**Interface Agent**
-- Handles external interactions (users, APIs, systems)
-- Protocol translation and format conversion
-- Authentication and authorization management
-- User experience optimization
-
-**Monitor Agent**
-- System health monitoring and alerting
-- Performance metrics collection and analysis
-- Anomaly detection and reporting
-- Compliance and audit trail maintenance
-
-### 3. Tool Design Principles
-
-#### Schema Design
-- **Input Validation:** Strong typing, required vs optional parameters
-- **Output Consistency:** Standardized response formats, error handling
-- **Documentation:** Clear descriptions, usage examples, edge cases
-- **Versioning:** Backward compatibility, migration paths
-
-#### Error Handling Patterns
-- **Graceful Degradation:** Partial functionality when dependencies fail
-- **Retry Logic:** Exponential backoff, circuit breakers, max attempts
-- **Error Propagation:** Structured error responses, error classification
-- **Recovery Strategies:** Fallback methods, alternative approaches
-
-#### Idempotency Requirements
-- **Safe Operations:** Read operations with no side effects
-- **Idempotent Writes:** Same operation can be safely repeated
-- **State Management:** Version tracking, conflict resolution
-- **Atomicity:** All-or-nothing operation completion
-
-### 4. Communication Patterns
-
-#### Message Passing
-- **Asynchronous Messaging:** Decoupled agents, message queues
-- **Message Format:** Structured payloads with metadata
-- **Delivery Guarantees:** At-least-once, exactly-once semantics
-- **Routing:** Direct messaging, publish-subscribe, broadcast
-
-#### Shared State
-- **State Stores:** Centralized data repositories
-- **Consistency Models:** Strong, eventual, weak consistency
-- **Access Patterns:** Read-heavy, write-heavy, mixed workloads
-- **Conflict Resolution:** Last-writer-wins, merge strategies
-
-#### Event-Driven Architecture
-- **Event Sourcing:** Immutable event logs, state reconstruction
-- **Event Types:** Domain events, system events, integration events
-- **Event Processing:** Real-time, batch, stream processing
-- **Event Schema:** Versioned event formats, backward compatibility
-
-### 5. Guardrails and Safety
-
-#### Input Validation
-- **Schema Enforcement:** Required fields, type checking, format validation
-- **Content Filtering:** Harmful content detection, PII scrubbing
-- **Rate Limiting:** Request throttling, resource quotas
-- **Authentication:** Identity verification, authorization checks
-
-#### Output Filtering
-- **Content Moderation:** Harmful content removal, quality checks
-- **Consistency Validation:** Logic checks, constraint verification
-- **Formatting:** Standardized output formats, clean presentation
-- **Audit Logging:** Decision trails, compliance records
-
-#### Human-in-the-Loop
-- **Approval Workflows:** Critical decision checkpoints
-- **Escalation Triggers:** Confidence thresholds, risk assessment
-- **Override Mechanisms:** Human judgment precedence
-- **Feedback Loops:** Human corrections improve system behavior
-
-### 6. Evaluation Frameworks
-
-#### Task Completion Metrics
-- **Success Rate:** Percentage of tasks completed successfully
-- **Partial Completion:** Progress measurement for complex tasks
-- **Task Classification:** Success criteria by task type
-- **Failure Analysis:** Root cause identification and categorization
-
-#### Quality Assessment
-- **Output Quality:** Accuracy, relevance, completeness measures
-- **Consistency:** Response variability across similar inputs
-- **Coherence:** Logical flow and internal consistency
-- **User Satisfaction:** Feedback scores, usage patterns
-
-#### Cost Analysis
-- **Token Usage:** Input/output token consumption per task
-- **API Costs:** External service usage and charges
-- **Compute Resources:** CPU, memory, storage utilization
-- **Time-to-Value:** Cost per successful task completion
-
-#### Latency Distribution
-- **Response Time:** End-to-end task completion time
-- **Processing Stages:** Bottleneck identification per stage
-- **Queue Times:** Wait times in processing pipelines
-- **Resource Contention:** Impact of concurrent operations
-
-### 7. Orchestration Strategies
-
-#### Centralized Orchestration
-- **Workflow Engine:** Central coordinator manages all agents
-- **State Management:** Centralized workflow state tracking
-- **Decision Logic:** Complex routing and branching rules
-- **Monitoring:** Comprehensive visibility into all operations
-
-#### Decentralized Orchestration
-- **Peer-to-Peer:** Agents coordinate directly with each other
-- **Service Discovery:** Dynamic agent registration and lookup
-- **Consensus Protocols:** Distributed decision making
-- **Fault Tolerance:** No single point of failure
-
-#### Hybrid Approaches
-- **Domain Boundaries:** Centralized within domains, federated across
-- **Hierarchical Coordination:** Multiple orchestration levels
-- **Context-Dependent:** Strategy selection based on task type
-- **Load Balancing:** Distribute coordination responsibility
-
-### 8. Memory Patterns
-
-#### Short-Term Memory
-- **Context Windows:** Working memory for current tasks
-- **Session State:** Temporary data for ongoing interactions
-- **Cache Management:** Performance optimization strategies
-- **Memory Pressure:** Handling capacity constraints
-
-#### Long-Term Memory
-- **Persistent Storage:** Durable data across sessions
-- **Knowledge Base:** Accumulated domain knowledge
-- **Experience Replay:** Learning from past interactions
-- **Memory Consolidation:** Transferring from short to long-term
-
-#### Shared Memory
-- **Collaborative Knowledge:** Shared learning across agents
-- **Synchronization:** Consistency maintenance strategies
-- **Access Control:** Permission-based memory access
-- **Memory Partitioning:** Isolation between agent groups
-
-### 9. Scaling Considerations
-
-#### Horizontal Scaling
-- **Agent Replication:** Multiple instances of same agent type
-- **Load Distribution:** Request routing across agent instances
-- **Resource Pooling:** Shared compute and storage resources
-- **Geographic Distribution:** Multi-region deployments
-
-#### Vertical Scaling
-- **Capability Enhancement:** More powerful individual agents
-- **Tool Expansion:** Broader tool access per agent
-- **Context Expansion:** Larger working memory capacity
-- **Processing Power:** Higher throughput per agent
-
-#### Performance Optimization
-- **Caching Strategies:** Response caching, tool result caching
-- **Parallel Processing:** Concurrent task execution
-- **Resource Optimization:** Efficient resource utilization
-- **Bottleneck Elimination:** Systematic performance tuning
-
-### 10. Failure Handling
-
-#### Retry Mechanisms
-- **Exponential Backoff:** Increasing delays between retries
-- **Jitter:** Random delay variation to prevent thundering herd
-- **Maximum Attempts:** Bounded retry behavior
-- **Retry Conditions:** Transient vs permanent failure classification
-
-#### Fallback Strategies
-- **Graceful Degradation:** Reduced functionality when systems fail
-- **Alternative Approaches:** Different methods for same goals
-- **Default Responses:** Safe fallback behaviors
-- **User Communication:** Clear failure messaging
-
-#### Circuit Breakers
-- **Failure Detection:** Monitoring failure rates and response times
-- **State Management:** Open, closed, half-open circuit states
-- **Recovery Testing:** Gradual return to normal operation
-- **Cascading Failure Prevention:** Protecting upstream systems
-
-## Implementation Guidelines
-
-### Architecture Decision Process
-1. **Requirements Analysis:** Understand system goals, constraints, scale
-2. **Pattern Selection:** Choose appropriate architecture pattern
-3. **Agent Design:** Define roles, responsibilities, interfaces
-4. **Tool Architecture:** Design tool schemas and error handling
-5. **Communication Design:** Select message patterns and protocols
-6. **Safety Implementation:** Build guardrails and validation
-7. **Evaluation Planning:** Define success metrics and monitoring
-8. **Deployment Strategy:** Plan scaling and failure handling
-
-### Quality Assurance
-- **Testing Strategy:** Unit, integration, and system testing approaches
-- **Monitoring:** Real-time system health and performance tracking
-- **Documentation:** Architecture documentation and runbooks
-- **Security Review:** Threat modeling and security assessments
-
-### Continuous Improvement
-- **Performance Monitoring:** Ongoing system performance analysis
-- **User Feedback:** Incorporating user experience improvements
-- **A/B Testing:** Controlled experiments for system improvements
-- **Knowledge Base Updates:** Continuous learning and adaptation
-
-This skill provides the foundation for designing robust, scalable multi-agent systems that can handle complex tasks while maintaining safety, reliability, and performance at scale.

package/skills/jarvis/engineering-team/docs/skills/engineering/agent-workflow-designer.md

@@ -1,94 +0,0 @@
----
-title: "Agent Workflow Designer — Agent Skill for Codex & OpenClaw"
-description: "Agent Workflow Designer. Agent skill for Claude Code, Codex CLI, Gemini CLI, OpenClaw."
----
-
-# Agent Workflow Designer
-
-<div class="page-meta" markdown>
-<span class="meta-badge">:material-rocket-launch: Engineering - POWERFUL</span>
-<span class="meta-badge">:material-identifier: `agent-workflow-designer`</span>
-<span class="meta-badge">:material-github: <a href="https://github.com/alirezarezvani/claude-skills/tree/main/engineering/agent-workflow-designer/SKILL.md">Source</a></span>
-</div>
-
-<div class="install-banner" markdown>
-<span class="install-label">Install:</span> <code>claude /plugin install engineering-advanced-skills</code>
-</div>
-
-
-**Tier:** POWERFUL  
-**Category:** Engineering  
-**Domain:** Multi-Agent Systems / AI Orchestration
-
----
-
-## Overview
-
-Design production-grade multi-agent workflows with clear pattern choice, handoff contracts, failure handling, and cost/context controls.
-
-## Core Capabilities
-
-- Workflow pattern selection for multi-step agent systems
-- Skeleton config generation for fast workflow bootstrapping
-- Context and cost discipline across long-running flows
-- Error recovery and retry strategy scaffolding
-- Documentation pointers for operational pattern tradeoffs
-
----
-
-## When to Use
-
-- A single prompt is insufficient for task complexity
-- You need specialist agents with explicit boundaries
-- You want deterministic workflow structure before implementation
-- You need validation loops for quality or safety gates
-
----
-
-## Quick Start
-
-```bash
-# Generate a sequential workflow skeleton
-python3 scripts/workflow_scaffolder.py sequential --name content-pipeline
-
-# Generate an orchestrator workflow and save it
-python3 scripts/workflow_scaffolder.py orchestrator --name incident-triage --output workflows/incident-triage.json
-```
-
----
-
-## Pattern Map
-
-- `sequential`: strict step-by-step dependency chain
-- `parallel`: fan-out/fan-in for independent subtasks
-- `router`: dispatch by intent/type with fallback
-- `orchestrator`: planner coordinates specialists with dependencies
-- `evaluator`: generator + quality gate loop
-
-Detailed templates: `references/workflow-patterns.md`
-
----
-
-## Recommended Workflow
-
-1. Select pattern based on dependency shape and risk profile.
-2. Scaffold config via `scripts/workflow_scaffolder.py`.
-3. Define handoff contract fields for every edge.
-4. Add retry/timeouts and output validation gates.
-5. Dry-run with small context budgets before scaling.
-
----
-
-## Common Pitfalls
-
-- Over-orchestrating tasks solvable by one well-structured prompt
-- Missing timeout/retry policies for external-model calls
-- Passing full upstream context instead of targeted artifacts
-- Ignoring per-step cost accumulation
-
-## Best Practices
-
-1. Start with the smallest pattern that can satisfy requirements.
-2. Keep handoff payloads explicit and bounded.
-3. Validate intermediate outputs before fan-in synthesis.
-4. Enforce budget and timeout limits in every step.

package/skills/jarvis/engineering-team/docs/skills/engineering/agenthub-board.md

@@ -1,116 +0,0 @@
----
-title: "/hub:board — Message Board — Agent Skill for Codex & OpenClaw"
-description: "Read, write, and browse the AgentHub message board for agent coordination. Agent skill for Claude Code, Codex CLI, Gemini CLI, OpenClaw."
----
-
-# /hub:board — Message Board
-
-<div class="page-meta" markdown>
-<span class="meta-badge">:material-rocket-launch: Engineering - POWERFUL</span>
-<span class="meta-badge">:material-identifier: `board`</span>
-<span class="meta-badge">:material-github: <a href="https://github.com/alirezarezvani/claude-skills/tree/main/engineering/agenthub/skills/board/SKILL.md">Source</a></span>
-</div>
-
-<div class="install-banner" markdown>
-<span class="install-label">Install:</span> <code>claude /plugin install engineering-advanced-skills</code>
-</div>
-
-
-Interface for the AgentHub message board. Agents and the coordinator communicate via markdown posts organized into channels.
-
-## Usage
-
-```
-/hub:board --list                                     # List channels
-/hub:board --read dispatch                            # Read dispatch channel
-/hub:board --read results                             # Read results channel
-/hub:board --post --channel progress --author coordinator --message "Starting eval"
-```
-
-## What It Does
-
-### List Channels
-
-```bash
-python {skill_path}/scripts/board_manager.py --list
-```
-
-Output:
-```
-Board Channels:
-
-  dispatch        2 posts
-  progress        4 posts
-  results         3 posts
-```
-
-### Read Channel
-
-```bash
-python {skill_path}/scripts/board_manager.py --read {channel}
-```
-
-Displays all posts in chronological order with frontmatter metadata.
-
-### Post Message
-
-```bash
-python {skill_path}/scripts/board_manager.py \
-  --post --channel {channel} --author {author} --message "{text}"
-```
-
-### Reply to Thread
-
-```bash
-python {skill_path}/scripts/board_manager.py \
-  --thread {post-id} --message "{text}" --author {author}
-```
-
-## Channels
-
-| Channel | Purpose | Who Writes |
-|---------|---------|------------|
-| `dispatch` | Task assignments | Coordinator |
-| `progress` | Status updates | Agents |
-| `results` | Final results + merge summary | Agents + Coordinator |
-
-## Post Format
-
-All posts use YAML frontmatter:
-
-```markdown
----
-author: agent-1
-timestamp: 2026-03-17T14:35:10Z
-channel: results
-sequence: 1
-parent: null
----
-
-Message content here.
-```
-
-Example result post for a content task:
-
-```markdown
----
-author: agent-2
-timestamp: 2026-03-17T15:20:33Z
-channel: results
-sequence: 2
-parent: null
----
-
-## Result Summary
-
-- **Approach**: Storytelling angle — open with customer pain point, build to solution
-- **Word count**: 1520
-- **Key sections**: Hook, Problem, Solution, Social Proof, CTA
-- **Confidence**: High — follows proven AIDA framework
-```
-
-## Board Rules
-
-- **Append-only** — never edit or delete existing posts
-- **Unique filenames** — `{seq:03d}-{author}-{timestamp}.md`
-- **Frontmatter required** — every post has author, timestamp, channel

package/skills/jarvis/engineering-team/docs/skills/engineering/agenthub-eval.md

@@ -1,90 +0,0 @@
----
-title: "/hub:eval — Evaluate Agent Results — Agent Skill for Codex & OpenClaw"
-description: "Evaluate and rank agent results by metric or LLM judge for an AgentHub session. Agent skill for Claude Code, Codex CLI, Gemini CLI, OpenClaw."
----
-
-# /hub:eval — Evaluate Agent Results
-
-<div class="page-meta" markdown>
-<span class="meta-badge">:material-rocket-launch: Engineering - POWERFUL</span>
-<span class="meta-badge">:material-identifier: `eval`</span>
-<span class="meta-badge">:material-github: <a href="https://github.com/alirezarezvani/claude-skills/tree/main/engineering/agenthub/skills/eval/SKILL.md">Source</a></span>
-</div>
-
-<div class="install-banner" markdown>
-<span class="install-label">Install:</span> <code>claude /plugin install engineering-advanced-skills</code>
-</div>
-
-
-Rank all agent results for a session. Supports metric-based evaluation (run a command), LLM judge (compare diffs), or hybrid.
-
-## Usage
-
-```
-/hub:eval                           # Eval latest session using configured criteria
-/hub:eval 20260317-143022           # Eval specific session
-/hub:eval --judge                   # Force LLM judge mode (ignore metric config)
-```
-
-## What It Does
-
-### Metric Mode (eval command configured)
-
-Run the evaluation command in each agent's worktree:
-
-```bash
-python {skill_path}/scripts/result_ranker.py \
-  --session {session-id} \
-  --eval-cmd "{eval_cmd}" \
-  --metric {metric} --direction {direction}
-```
-
-Output:
-```
-RANK  AGENT       METRIC      DELTA      FILES
-1     agent-2     142ms       -38ms      2
-2     agent-1     165ms       -15ms      3
-3     agent-3     190ms       +10ms      1
-
-Winner: agent-2 (142ms)
-```
-
-### LLM Judge Mode (no eval command, or --judge flag)
-
-For each agent:
-1. Get the diff: `git diff {base_branch}...{agent_branch}`
-2. Read the agent's result post from `.agenthub/board/results/agent-{i}-result.md`
-3. Compare all diffs and rank by:
-   - **Correctness** — Does it solve the task?
-   - **Simplicity** — Fewer lines changed is better (when equal correctness)
-   - **Quality** — Clean execution, good structure, no regressions
-
-Present rankings with justification.
-
-Example LLM judge output for a content task:
-```
-RANK  AGENT    VERDICT                               WORD COUNT
-1     agent-1  Strong narrative, clear CTA            1480
-2     agent-3  Good data points, weak intro           1520
-3     agent-2  Generic tone, no differentiation       1350
-
-Winner: agent-1 (strongest narrative arc and call-to-action)
-```
-
-### Hybrid Mode
-
-1. Run metric evaluation first
-2. If top agents are within 10% of each other, use LLM judge to break ties
-3. Present both metric and qualitative rankings
-
-## After Eval
-
-1. Update session state:
-```bash
-python {skill_path}/scripts/session_manager.py --update {session-id} --state evaluating
-```
-
-2. Tell the user:
-   - Ranked results with winner highlighted
-   - Next step: `/hub:merge` to merge the winner
-   - Or `/hub:merge {session-id} --agent {winner}` to be explicit

package/skills/jarvis/engineering-team/docs/skills/engineering/agenthub-init.md

@@ -1,99 +0,0 @@
----
-title: "/hub:init — Create New Session — Agent Skill for Codex & OpenClaw"
-description: "Create a new AgentHub collaboration session with task, agent count, and evaluation criteria. Agent skill for Claude Code, Codex CLI, Gemini CLI, OpenClaw."
----
-
-# /hub:init — Create New Session
-
-<div class="page-meta" markdown>
-<span class="meta-badge">:material-rocket-launch: Engineering - POWERFUL</span>
-<span class="meta-badge">:material-identifier: `init`</span>
-<span class="meta-badge">:material-github: <a href="https://github.com/alirezarezvani/claude-skills/tree/main/engineering/agenthub/skills/init/SKILL.md">Source</a></span>
-</div>
-
-<div class="install-banner" markdown>
-<span class="install-label">Install:</span> <code>claude /plugin install engineering-advanced-skills</code>
-</div>
-
-
-Initialize an AgentHub collaboration session. Creates the `.agenthub/` directory structure, generates a session ID, and configures evaluation criteria.
-
-## Usage
-
-```
-/hub:init                                                    # Interactive mode
-/hub:init --task "Optimize API" --agents 3 --eval "pytest bench.py" --metric p50_ms --direction lower
-/hub:init --task "Refactor auth" --agents 2                  # No eval (LLM judge mode)
-```
-
-## What It Does
-
-### If arguments provided
-
-Pass them to the init script:
-
-```bash
-python {skill_path}/scripts/hub_init.py \
-  --task "{task}" --agents {N} \
-  [--eval "{eval_cmd}"] [--metric {metric}] [--direction {direction}] \
-  [--base-branch {branch}]
-```
-
-### If no arguments (interactive mode)
-
-Collect each parameter:
-
-1. **Task** — What should the agents do? (required)
-2. **Agent count** — How many parallel agents? (default: 3)
-3. **Eval command** — Command to measure results (optional — skip for LLM judge mode)
-4. **Metric name** — What metric to extract from eval output (required if eval command given)
-5. **Direction** — Is lower or higher better? (required if metric given)
-6. **Base branch** — Branch to fork from (default: current branch)
-
-### Output
-
-```
-AgentHub session initialized
-  Session ID: 20260317-143022
-  Task: Optimize API response time below 100ms
-  Agents: 3
-  Eval: pytest bench.py --json
-  Metric: p50_ms (lower is better)
-  Base branch: dev
-  State: init
-
-Next step: Run /hub:spawn to launch 3 agents
-```
-
-For content or research tasks (no eval command → LLM judge mode):
-
-```
-AgentHub session initialized
-  Session ID: 20260317-151200
-  Task: Draft 3 competing taglines for product launch
-  Agents: 3
-  Eval: LLM judge (no eval command)
-  Base branch: dev
-  State: init
-
-Next step: Run /hub:spawn to launch 3 agents
-```
-
-## Baseline Capture
-
-If `--eval` was provided, capture a baseline measurement after session creation:
-
-1. Run the eval command in the current working directory
-2. Extract the metric value from stdout
-3. Append `baseline: {value}` to `.agenthub/sessions/{session-id}/config.yaml`
-4. Display: `Baseline captured: {metric} = {value}`
-
-This baseline is used by `result_ranker.py --baseline` during evaluation to show deltas. If the eval command fails at this stage, warn the user but continue — baseline is optional.
-
-## After Init
-
-Tell the user:
-- Session created with ID `{session-id}`
-- Baseline metric (if captured)
-- Next step: `/hub:spawn` to launch agents
-- Or `/hub:spawn {session-id}` if multiple sessions exist