agentic-qe 3.13.2 → 3.13.4

package/.agents/skills/aqe-plan-work/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: aqe-plan-work
+description: Build dependency-aware execution plans for complex Agentic QE, Ruflo, integration, migration, or multi-stream engineering programs. Use when Codex must turn research or requirements into phased work, select a small AQE fleet, map critical paths and parallel streams, define acceptance gates, or sequence risky changes. Use aqe-plan-quality instead when the primary output is only a test or quality plan.
+---
+
+# Plan AQE Work
+
+1. Read `AGENTS.md`, the objective, relevant research, affected implementation,
+   tests, configuration, and public boundaries.
+2. Define observable outcomes, non-goals, constraints, assumptions, and decisions
+   that require human approval.
+3. Decompose work into independently verifiable deliverables. Map dependencies,
+   consumers, migrations, compatibility boundaries, and rollback points.
+4. Select the smallest useful specialist fleet with
+   [references/planning-framework.md](references/planning-framework.md). Give
+   every selected specialty a concrete output; do not summon the whole fleet.
+5. Arrange phases so contracts, safety controls, and durable tests precede or
+   accompany implementation. Check CLI/MCP and Claude/Codex parity when shared
+   capabilities cross those surfaces.
+6. Identify work that can run in parallel and a clear critical path. Do not use
+   unsupported precision for time estimates; size work by risk and dependency.
+7. Attach acceptance criteria and the narrowest verification command to each
+   deliverable. Include security, resilience, performance, accessibility, or
+   data-integrity gates only when triggered by the actual scope.
+8. End with prioritized milestones, risks and mitigations, open decisions, and
+   a recommended first vertical slice.
+
+Use Ruflo for persistent memory, learned routing, hooks, or multi-agent
+coordination only when its operational benefit exceeds its setup overhead.
+Treat Claude agent definitions as domain references; translate their workflows
+into available Codex actions rather than copying Claude-only tool syntax.

package/.agents/skills/aqe-plan-work/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "AQE Plan Work"
+  short_description: "Dependency-aware plans for AQE programs"
+  default_prompt: "Use $aqe-plan-work to turn this objective into a dependency-aware execution and verification plan."

package/.agents/skills/aqe-plan-work/references/planning-framework.md

@@ -0,0 +1,39 @@
+# Planning Framework
+
+## Deliverable fields
+
+For each deliverable record:
+
+- outcome and owner/specialty;
+- dependencies and downstream consumers;
+- affected files or boundaries;
+- failure modes and rollback;
+- acceptance criteria;
+- focused verification;
+- size: `S`, `M`, or `L`, plus confidence.
+
+## Fleet selection
+
+Start with one coordinator only for genuinely cross-domain work. Add specialists
+by triggered risk:
+
+| Trigger | AQE specialty |
+| --- | --- |
+| Ambiguous requirements or low testability | `qe-requirements-validator`, `qe-test-architect` |
+| Broad code or dependency impact | `qe-code-intelligence`, `qe-impact-analyzer` |
+| Security or trust boundaries | `qe-security-auditor` |
+| Contracts or CLI/MCP parity | `qe-contract-validator`, `qe-integration-tester` |
+| Performance or failure recovery | `qe-performance-tester`, `qe-chaos-engineer` |
+| Release decision | `qe-risk-assessor`, `qe-quality-gate` |
+| Learning and routing feedback | `qe-pattern-learner`, `qe-learning-coordinator` |
+
+Use `qe-fleet-commander` or `qe-queen-coordinator` only when at least three
+independent specialties need coordinated handoffs.
+
+## Phase gates
+
+1. Evidence gate: current behavior and upstream assumptions are verified.
+2. Contract gate: schemas, configuration, and compatibility are explicit.
+3. Vertical-slice gate: one end-to-end path proves the architecture.
+4. Expansion gate: broader fleet, hooks, or automation has measured value.
+5. Release gate: parity, invariants, rollback, and user-facing docs pass.

package/.agents/skills/aqe-research/SKILL.md

@@ -0,0 +1,31 @@
+---
+name: aqe-research
+description: Conduct evidence-first technical research for Agentic QE, Ruflo, related ruvnet projects, or external tools. Use when Codex must investigate a repository, compare current upstream changes, trace dependencies and history, distinguish verified facts from inference, or synthesize findings into actionable engineering recommendations. Do not use for a simple known-answer lookup or an implementation-only task.
+---
+
+# Research AQE Systems
+
+1. Read `AGENTS.md`, the question, and any user-supplied artifacts completely.
+2. Define the decision the research must support, its scope, and freshness needs.
+3. Search local evidence broad-to-narrow with `rg --files`, `rg`, code navigation,
+   tests, configuration, documentation, and git history.
+4. For current external claims, inspect primary sources: upstream repositories,
+   releases, commits, issues, pull requests, and official documentation. Record
+   dates, versions, commit identifiers, and links.
+5. Trace definitions to usages and public boundaries. Map dependencies, data
+   flow, CLI/MCP parity, configuration generation, and tests when relevant.
+6. Classify each material statement using
+   [references/evidence-rules.md](references/evidence-rules.md). Never repeat a
+   benchmark, capability, or roadmap claim as fact without direct evidence.
+7. Synthesize only after gathering evidence. State contradictions, uncertainty,
+   missing access, and stale documentation explicitly.
+8. Return:
+   - the decision-oriented summary;
+   - verified findings with source locations;
+   - inferences and their supporting evidence;
+   - gaps and risks;
+   - prioritized recommendations and the smallest useful next validation.
+
+Use parallel agents only when the user requests delegation or repository
+instructions explicitly permit it. Treat Claude agent definitions as domain
+references; do not copy or execute their Claude-only hooks or tool syntax.

package/.agents/skills/aqe-research/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "AQE Research"
+  short_description: "Evidence-first research for AQE technical work"
+  default_prompt: "Use $aqe-research to investigate this technical question and synthesize evidence-backed recommendations."

package/.agents/skills/aqe-research/references/evidence-rules.md

@@ -0,0 +1,21 @@
+# Evidence Rules
+
+| Label | Meaning | Required support |
+| --- | --- | --- |
+| Verified | Directly observed and reproducible | File and line, command output, test, official page, release, or commit |
+| Upstream claim | Asserted by a maintainer or project | Primary-source link and date; preserve attribution |
+| Inference | Conclusion derived from evidence | Name the evidence and reasoning; do not present as shipped behavior |
+| Proposal | Recommended future action | State expected benefit, cost, risk, and validation |
+| Unknown | Evidence is absent or conflicting | Identify what would resolve it |
+
+## Source priority
+
+1. Executable behavior and focused tests.
+2. Current source code and configuration.
+3. Release tags, commit history, merged pull requests, and ADRs.
+4. Official documentation.
+5. Maintainer-authored design notes.
+6. Secondary commentary only when primary evidence is unavailable.
+
+Compare dates and commits before calling anything "latest." Separate what a
+design document describes, what code implements, and what field evidence proves.

package/.agents/skills/aqe-ruflo/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: aqe-ruflo
+description: Add optional Ruflo development-time orchestration to an Agentic QE workflow. Use when a task benefits from coordinated swarms, persistent cross-session memory, routing, or Ruflo hooks. Do not use for a one-shot edit, and never add Ruflo to shipped AQE runtime dependencies.
+---
+
+# Orchestrate AQE with Ruflo
+
+Keep the ownership boundary explicit:
+
+- AQE owns quality specialization, test evidence, gates, and verdicts.
+- Ruflo owns development-time task coordination, handoffs, hooks, routing, and
+  cross-session orchestration memory.
+- Never import Ruflo from product code or add `ruflo`, `claude-flow`, or
+  `@claude-flow/cli` as an AQE runtime dependency.
+
+Before using Ruflo, confirm that multi-agent coordination is worth its overhead.
+Prefer a small, risk-selected QE fleet over activating every agent.
+
+For projects that explicitly want Ruflo, initialize or inspect it through its
+external CLI:
+
+```bash
+npx ruflo doctor
+npx ruflo discover-plugins
+```
+
+Use the installed Ruflo MCP tools when available. Treat their absence as
+graceful degradation: AQE quality workflows must continue to work without
+Ruflo installed.

package/.claude/commands/pair/README.md

@@ -0,0 +1,261 @@
+# 👥 Pair Programming Command
+
+Collaborative development with real-time verification and AI assistance.
+
+## Overview
+
+The `pair` command enables collaborative pair programming between you and AI agents, with real-time verification, code review, and quality enforcement.
+
+## Usage
+
+```bash
+claude-flow pair [--start] [options]
+```
+
+## Quick Start
+
+```bash
+# Start pair programming session
+claude-flow pair --start
+
+# Start with specific agent
+claude-flow pair --start --agent senior-dev
+
+# Start with verification
+claude-flow pair --start --verify --threshold 0.98
+```
+
+## Options
+
+- `--start` - Start new pair programming session
+- `--agent <name>` - Specify AI pair partner (default: auto-select)
+- `--verify` - Enable real-time verification
+- `--threshold <0-1>` - Verification threshold (default: 0.95)
+- `--mode <type>` - Programming mode: driver, navigator, switch
+- `--focus <area>` - Focus area: refactor, test, debug, implement
+- `--language <lang>` - Primary language for session
+- `--review` - Enable continuous code review
+- `--test` - Run tests after each change
+
+## Modes
+
+### Driver Mode
+You write code, AI provides suggestions and reviews.
+```bash
+claude-flow pair --start --mode driver
+```
+
+### Navigator Mode
+AI writes code, you provide guidance and review.
+```bash
+claude-flow pair --start --mode navigator
+```
+
+### Switch Mode (Default)
+Alternate between driver and navigator roles.
+```bash
+claude-flow pair --start --mode switch --interval 10m
+```
+
+## Features
+
+### Real-Time Verification
+- Continuous truth checking (0.95 threshold)
+- Automatic rollback on verification failure
+- Quality gates before commits
+
+### Code Review
+- Instant feedback on code changes
+- Best practice suggestions
+- Security vulnerability detection
+- Performance optimization tips
+
+### Test Integration
+- Automatic test generation
+- Test-driven development support
+- Coverage monitoring
+- Integration test suggestions
+
+### Collaboration Tools
+- Shared context between you and AI
+- Session history and replay
+- Code explanation on demand
+- Learning from your preferences
+
+## Session Management
+
+### Start Session
+```bash
+# Basic start
+claude-flow pair --start
+
+# With configuration
+claude-flow pair --start \
+  --agent expert-coder \
+  --verify \
+  --test \
+  --focus refactor
+```
+
+### During Session
+```commands
+/help          - Show available commands
+/explain       - Explain current code
+/suggest       - Get improvement suggestions
+/test          - Run tests
+/verify        - Check verification score
+/switch        - Switch driver/navigator roles
+/focus <area>  - Change focus area
+/commit        - Commit with verification
+/pause         - Pause session
+/resume        - Resume session
+/end           - End session
+```
+
+### End Session
+```bash
+# End and save session
+claude-flow pair --end --save
+
+# End and generate report
+claude-flow pair --end --report
+```
+
+## Examples
+
+### Refactoring Session
+```bash
+claude-flow pair --start \
+  --focus refactor \
+  --verify \
+  --threshold 0.98
+```
+
+### Test-Driven Development
+```bash
+claude-flow pair --start \
+  --focus test \
+  --mode tdd \
+  --language javascript
+```
+
+### Bug Fixing
+```bash
+claude-flow pair --start \
+  --focus debug \
+  --agent debugger-expert \
+  --test
+```
+
+### Code Review Session
+```bash
+claude-flow pair --start \
+  --review \
+  --verify \
+  --agent senior-reviewer
+```
+
+## Integration
+
+### With Git
+```bash
+# Auto-commit with verification
+claude-flow pair --start --git --auto-commit
+
+# Review before commit
+claude-flow pair --start --git --review-commit
+```
+
+### With Testing Frameworks
+```bash
+# Jest integration
+claude-flow pair --start --test-framework jest
+
+# Pytest integration
+claude-flow pair --start --test-framework pytest
+```
+
+### With CI/CD
+```bash
+# CI-friendly mode
+claude-flow pair --start --ci --non-interactive
+```
+
+## Session Output
+
+```
+👥 Pair Programming Session Started
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Partner: expert-coder
+Mode: Switch (10m intervals)
+Focus: Implementation
+Verification: ✅ Enabled (0.95)
+Testing: ✅ Auto-run
+
+Current Role: DRIVER (you)
+Navigator: expert-coder is reviewing...
+
+📝 Working on: src/auth/login.js
+Truth Score: 0.972 ✅
+Test Coverage: 84% 📈
+
+💡 Suggestion: Consider adding input validation for email field
+🔍 Review: Line 23 - Potential SQL injection vulnerability
+
+Type /help for commands or start coding...
+```
+
+## Quality Metrics
+
+- **Session Duration**: Total pair programming time
+- **Code Quality**: Average truth score during session
+- **Productivity**: Lines changed, features completed
+- **Learning**: Patterns learned from collaboration
+- **Test Coverage**: Coverage improvement during session
+
+## Configuration
+
+Configure pair programming in `.claude-flow/config.json`:
+
+```json
+{
+  "pair": {
+    "defaultAgent": "expert-coder",
+    "defaultMode": "switch",
+    "switchInterval": "10m",
+    "verification": {
+      "enabled": true,
+      "threshold": 0.95,
+      "autoRollback": true
+    },
+    "testing": {
+      "autoRun": true,
+      "framework": "jest",
+      "coverage": {
+        "minimum": 80,
+        "enforce": true
+      }
+    },
+    "review": {
+      "continuous": true,
+      "preCommit": true
+    }
+  }
+}
+```
+
+## Best Practices
+
+1. **Start with Clear Goals**: Define what you want to accomplish
+2. **Use Verification**: Enable verification for critical code
+3. **Test Frequently**: Run tests after significant changes
+4. **Review Together**: Use review features for learning
+5. **Document Decisions**: AI will help document why choices were made
+
+## Related Commands
+
+- `verify` - Standalone verification
+- `truth` - View quality metrics
+- `test` - Run test suites
+- `review` - Code review tools