ruflo

Agent skill for analyze-code-quality - invoke with $agent-analyze-code-quality

Agent skill for app-store - invoke with $agent-app-store

Agent skill for arch-system-design - invoke with $agent-arch-system-design

Agent skill for architecture - invoke with $agent-architecture

Agent skill for authentication - invoke with $agent-authentication

Agent skill for mesh-coordinator - invoke with $agent-mesh-coordinator

Agent skill for automation-smart-agent - invoke with $agent-automation-smart-agent

Agent skill for migration-plan - invoke with $agent-migration-plan

Agent skill for multi-repo-swarm - invoke with $agent-multi-repo-swarm

Agent skill for neural-network - invoke with $agent-neural-network

Agent skill for base-template-generator - invoke with $agent-base-template-generator

Agent skill for benchmark-suite - invoke with $agent-benchmark-suite

Agent skill for byzantine-coordinator - invoke with $agent-byzantine-coordinator

Agent skill for challenges - invoke with $agent-challenges

Agent skill for code-analyzer - invoke with $agent-code-analyzer

Agent skill for code-goal-planner - invoke with $agent-code-goal-planner

Agent skill for code-review-swarm - invoke with $agent-code-review-swarm

Agent skill for coder - invoke with $agent-coder

Agent skill for github-pr-manager - invoke with $agent-github-pr-manager

Build or rebuild the ADR index + dependency graph by running scripts/import.mjs (handles v3-style and plugin-style ADR formats; one Bash call vs hundreds of MCP round-trips)

Agent skill for goal-planner - invoke with $agent-goal-planner

Agent skill for gossip-coordinator - invoke with $agent-gossip-coordinator

Agent skill for ops-cicd-github - invoke with $agent-ops-cicd-github

Agent skill for hierarchical-coordinator - invoke with $agent-hierarchical-coordinator

Agent skill for orchestrator-task - invoke with $agent-orchestrator-task

Agent skill for reviewer - invoke with $agent-reviewer

Agent skill for implementer-sparc-coder - invoke with $agent-implementer-sparc-coder

Agent skill for issue-tracker - invoke with $agent-issue-tracker

Agent skill for load-balancer - invoke with $agent-load-balancer

Agent skill for safla-neural - invoke with $agent-safla-neural

Agent skill for matrix-optimizer - invoke with $agent-matrix-optimizer

Agent skill for memory-coordinator - invoke with $agent-memory-coordinator

Agent skill for sandbox - invoke with $agent-sandbox

Reconcile the ADR index against a DELETED ADR file or relation line by dropping and rebuilding adr-patterns + adr-edges from scratch (scripts/reindex.mjs). Use when adr-index alone leaves stale rows behind.

Review code changes against accepted ADRs for compliance violations

Read back adr-patterns + adr-edges namespaces, surface dangling refs / supersede cycles / status mismatches; exit 1 on cycles

Agent skill for adaptive-coordinator - invoke with $agent-adaptive-coordinator

Agent skill for agent - invoke with $agent-agent

Agent skill for agentic-payments - invoke with $agent-agentic-payments

Create a new Architecture Decision Record with sequential numbering and AgentDB registration

Agent skill for collective-intelligence-coordinator - invoke with $agent-collective-intelligence-coordinator

Agent skill for consensus-coordinator - invoke with $agent-consensus-coordinator

Agent spawning, lifecycle management, and coordination patterns. Manages 60+ agent types with specialized capabilities. Use when: spawning agents, coordinating multi-agent tasks, managing agent pools. Skip when: single-agent work, no coordination needed.

Agent skill for coordinator-swarm-init - invoke with $agent-coordinator-swarm-init

Agent skill for crdt-synchronizer - invoke with $agent-crdt-synchronizer

Agent skill for data-ml-model - invoke with $agent-data-ml-model

Agent skill for dev-backend-api - invoke with $agent-dev-backend-api

Agent skill for docs-api-openapi - invoke with $agent-docs-api-openapi

Agent skill for github-modes - invoke with $agent-github-modes

Agent skill for pagerank-analyzer - invoke with $agent-pagerank-analyzer

Agent skill for payments - invoke with $agent-payments

Agent skill for performance-analyzer - invoke with $agent-performance-analyzer

Agent skill for performance-benchmarker - invoke with $agent-performance-benchmarker

Agent skill for performance-monitor - invoke with $agent-performance-monitor

Agent skill for performance-optimizer - invoke with $agent-performance-optimizer

Agent skill for planner - invoke with $agent-planner

Agent skill for pr-manager - invoke with $agent-pr-manager

Agent skill for production-validator - invoke with $agent-production-validator

Agent skill for project-board-sync - invoke with $agent-project-board-sync

Agent skill for pseudocode - invoke with $agent-pseudocode

Agent skill for queen-coordinator - invoke with $agent-queen-coordinator

Agent skill for quorum-manager - invoke with $agent-quorum-manager

Agent skill for raft-manager - invoke with $agent-raft-manager

Agent skill for refinement - invoke with $agent-refinement

Agent skill for release-manager - invoke with $agent-release-manager

Agent skill for release-swarm - invoke with $agent-release-swarm

Agent skill for repo-architect - invoke with $agent-repo-architect

Agent skill for researcher - invoke with $agent-researcher

Agent skill for resource-allocator - invoke with $agent-resource-allocator

Agent skill for scout-explorer - invoke with $agent-scout-explorer

Agent skill for security-manager - invoke with $agent-security-manager

Agent skill for sona-learning-optimizer - invoke with $agent-sona-learning-optimizer

Agent skill for sparc-coordinator - invoke with $agent-sparc-coordinator

Agent skill for spec-mobile-react-native - invoke with $agent-spec-mobile-react-native

Agent skill for specification - invoke with $agent-specification

Agent skill for swarm - invoke with $agent-swarm

Agent skill for swarm-issue - invoke with $agent-swarm-issue

Agent skill for swarm-memory-manager - invoke with $agent-swarm-memory-manager

Agent skill for swarm-pr - invoke with $agent-swarm-pr

Agent skill for sync-coordinator - invoke with $agent-sync-coordinator

Agent skill for tdd-london-swarm - invoke with $agent-tdd-london-swarm

Agent skill for test-long-runner - invoke with $agent-test-long-runner

Agent skill for tester - invoke with $agent-tester

Agent skill for topology-optimizer - invoke with $agent-topology-optimizer

Agent skill for trading-predictor - invoke with $agent-trading-predictor

Agent skill for user-tools - invoke with $agent-user-tools

Agent skill for v3-integration-architect - invoke with $agent-v3-integration-architect

Agent skill for v3-memory-specialist - invoke with $agent-v3-memory-specialist

Agent skill for v3-performance-engineer - invoke with $agent-v3-performance-engineer

Agent skill for v3-queen-coordinator - invoke with $agent-v3-queen-coordinator

Agent skill for v3-security-architect - invoke with $agent-v3-security-architect

Agent skill for worker-specialist - invoke with $agent-worker-specialist

Agent skill for workflow - invoke with $agent-workflow

Agent skill for workflow-automation - invoke with $agent-workflow-automation

Master advanced AgentDB features including QUIC synchronization, multi-database management, custom distance metrics, hybrid search, and distributed systems integration. Use when building distributed AI systems, multi-agent coordination, or advanced vector search applications.

Create and train AI learning plugins with AgentDB's 9 reinforcement learning algorithms. Includes Decision Transformer, Q-Learning, SARSA, Actor-Critic, and more. Use when building self-learning agents, implementing RL, or optimizing agent behavior through experience.

Implement persistent memory patterns for AI agents using AgentDB. Includes session memory, long-term storage, pattern learning, and context management. Use when building stateful agents, chat systems, or intelligent assistants.

Optimize AgentDB performance with quantization (4-32x memory reduction), HNSW indexing (150x faster search), caching, and batch operations. Use when optimizing memory usage, improving search speed, or scaling to millions of vectors.

Query AgentDB through the controller bridge -- semantic routing, hierarchical recall, causal graphs, context synthesis, pattern store/search

Implement semantic vector search with AgentDB for intelligent document retrieval, similarity matching, and context-aware querying. Use when building RAG systems, semantic search engines, or intelligent knowledge bases.

Quantum-resistant, self-learning version control for AI agents with ReasoningBank intelligence and multi-agent coordination

Show AGNTCY/SLIM/CASA integration status — whether upstream AGNTCY packages are installed, which transport (local vs SLIM) is active, and whether CASA enforcement is enabled. Use when the user asks "is AGNTCY configured?", "show SLIM/CASA status", or "is AGNTCY/IOC integration active?".

Generate API documentation from source code with JSDoc and OpenAPI support

Run an autonomous /loop iteration -- check progress, work on next task, schedule next wake

Use learned patterns and current state to predict the optimal next action

Web browser automation with AI-optimized snapshots for claude-flow agents

Auto-capture per-session token usage from the Claude Code session jsonl and persist to the cost-tracking namespace

Probe a site's authentication flow for redirect leaks, missing CSRF, weak session cookies, and OAuth misconfiguration; produces an auth findings.md

Extract structured data via stored browser-templates or one-shot DOM queries, with mandatory AIDefence PII + prompt-injection gates before content reaches the model

Fill a web form by mapping field-name → value, with optional template lookup from browser-templates for known forms

Execute a natural-language browser intent via page-agent (browser_act) when the target is easier to describe than to select — degrades gracefully when page-agent or an OpenAI-compatible LLM provider isn't configured

Drive an authentication flow once, sanitize cookies through AIDefence, and vault a reusable cookie handle in browser-cookies for future sessions

Open a named, traced browser session into an RVF cognitive container with a ruvector trajectory recording every action

Replay a recorded session trajectory against the same URL or a mutated variant; uses browser-selectors embedding similarity to recover from DOM drift

DEPRECATED in v0.2.0 -- use browser-extract instead; this is a thin shim for backward compatibility, removed in v0.3.0

Visual + DOM diff between two recorded sessions at matching trajectory step ids; used for visual regression and replay verification

UI test recipe -- composes browser-record (capture) + browser-replay (verify) so every test produces a replayable RVF artifact, not an ephemeral run

Format prompts for different LLM providers with chat templates and HNSW-powered context retrieval

Claims-based authorization for agents and operations. Grant, revoke, and verify permissions for secure multi-agent coordination. Use when: permission management, access control, secure operations, authorization checks. Skip when: open access, no security requirements, single-agent local work.

Define and manage cognitive patterns for agent reasoning and decision-making

MAD-based outlier detection on session spend. Robust to the very outliers it hunts (unlike mean+sigma). Surfaces specific anomalous sessions with modified-z scores; optional --alert-on-outliers exit code for CI gates. Distinct from cost-burn (aggregate trend) — this answers "which INDIVIDUAL session is the outlier?".

Run the corpus benchmark — booster locally, optional Gemini/Sonnet/Opus baselines — and persist a verifiable measured-vs-claimed table

Apply a simple code transform via agent-booster's WASM engine — sub-millisecond, deterministic, $0 (no LLM call). Companion to cost-booster-route.

Route tasks through hooks_route, partition by Agent Booster availability, and report Tier 1 bypass utilization with $0 cost

Read accumulated cost-tracking spend + budget config, compute utilization, emit 50/75/90/100% alert ladder

Burn-rate trend over time with optional drift-alert exit code. Bins session spend into buckets, surfaces window-over-window delta, and can exit 1 when latest bucket exceeds prior mean by a configurable %. Distinct from `cost-trend` (benchmark drift); this tracks PRODUCTION spend trajectory.

Wrap getTokenOptimizer().getCompactContext() to retrieve compacted ReasoningBank context for cost-analysis queries; report bridge-reported tokensSaved

Per-conversation cost view — list every session in cost-tracking with started-at, message count, top model, and total cost

Multi-baseline counterfactual cost analysis. Compares actual session spend to hypothetical always-haiku / always-sonnet / always-opus routing baselines. Answers "is the routing earning its keep?" Negative savings flag over-escalation; positive savings quantify the router's win.

Snapshot delta between two cost-summary JSON outputs. PR-level cost regression detection — answers "what changed between these two specific snapshots?". Pairs with cost-summary's stable JSON contract.

Export cost-tracking telemetry in Prometheus textfile or webhook JSON formats — for external observability (Grafana, Datadog, custom dashboards)

Consumer-side wiring for ADR-097 Phase 3 federation_spend events — per-peer rolling windows + suspension-threshold check

Composite CI gate — runs cost-budget-check + cost-burn + cost-anomaly + cost-projection in parallel and surfaces a single combined health status with max exit code. The operationally-useful entry point — one shell-out covers all four alert ladders.

Analyze token usage patterns and recommend cost optimizations with estimated savings

Forward-looking spend extrapolation. Computes a USD-per-day rate from the recent measurement window, projects to 7d/30d/90d/365d horizons, and surfaces "days until budget exhausted" when a budget is configured. Predictive counterpart to `cost-budget-check` (reactive).

Generate a cost report showing token usage and USD costs by agent and model

Per-message cost breakdown within a single session. The drill-down companion to cost-anomaly — when an outlier session is flagged, this surfaces the specific expensive messages so operators can see whether the cost came from output tokens, cache writes, or model escalations.

Single-shot programmatic dump of all cost data — total spend, per-tier, top session, budget status, federation aggregate. JSON or markdown.

Initialize federation on this node — generate keypair and configure peers

Read every docs/benchmarks/runs/*.json and surface drift in win rate, latency, escalation rate, and LLM-baseline cost over time

Scaffold a new Claude Code plugin with proper directory structure, plugin.json, skills, commands, and agents

Schedule persistent background workers via CronCreate

Join and operate a signed cross-host agentbbs federation, and coordinate work claims across nodes. Use when: connecting ruflo agents across machines, sharing status/tasks/results between hosts, propagating work claims across a swarm, or standing up a federation hub. Skip when: single-host local work with no other nodes to coordinate with.

Create and adapt Dynamic Agentic Architecture agents that learn and evolve

Scaffold an aggregate root with entity, value objects, repository interface, domain events, and test stubs. Use when adding a new aggregate to an existing bounded context, modeling a new business concept that owns invariants, or generating the boilerplate for an entity + repo + events triplet.

Create and manage a DDD bounded context with standard directory structure. Use when starting a new subdomain, splitting a monolith into bounded contexts, or scaffolding the domain/application/infrastructure layout for a fresh module.

Validate domain boundaries -- detect cross-context import violations and aggregate invariant issues. Use when auditing a DDD codebase for leaks between bounded contexts, before merging cross-cutting changes, or as a CI gate to catch boundary erosion early.

Orchestrate multi-phase deep research with web search, memory retrieval, pattern matching, and synthesis into structured findings

Scan project dependencies for known vulnerabilities and CVEs. Use when auditing third-party packages, before releases, after `npm install`/lockfile changes, or when investigating reported CVE advisories.

Analyze git diffs for risk scoring, reviewer recommendations, and change classification. Use when preparing a PR, reviewing a large or cross-module change, or before merging to assess risk and pick reviewers.

Discover and recommend ruflo plugins based on your workflow, installed MCP tools, and current task

Generate and maintain documentation with drift detection. Use when the user asks to write/update/refresh docs, detect doc drift against code, or schedule recurring documentation maintenance.

Build a graph-structured dossier on a seed entity via parallel fan-out + recursive expansion across web, memory, knowledge-graph, codebase, ADR index, and git intel

Vector embeddings with HNSW indexing, sql.js persistence, and hyperbolic support. 75x faster with agentic-flow integration. Use when: semantic search, pattern matching, similarity queries, knowledge retrieval. Skip when: exact text matching, simple lookups, no semantic understanding needed.

Query federation audit logs with compliance filtering

Show federation health — peers, sessions, trust levels, and message metrics. Use when the user asks "is federation healthy?", "show peers", "federation status", or wants to inspect cross-installation agent connectivity.

Train and deploy neural networks in distributed E2B sandboxes with Flow Nexus

Comprehensive Flow Nexus platform management - authentication, sandboxes, app deployment, payments, and challenges

Cloud-based AI swarm deployment and event-driven workflow automation with Flow Nexus platform

Side-by-side comparison of ruflo vs HAL vs other GAIA harnesses — capability gaps, design decisions, and improvement roadmap

Diagnose why a GAIA question failed — extract trace, classify failure mode, and propose a fix. Use when a GAIA benchmark run reports a failed/incorrect task_id and you need to root-cause it before resubmitting.

Walk through a complete GAIA benchmark→submit flow — from key resolution through HAL-compatible package generation

Advanced git workflows with branch management, conflict resolution, and PR lifecycle

GitHub workflow automation, PR management, issue tracking, and code review coordination. Integrates with GitHub Actions and repository management. Use when: PR creation, code review, issue management, release automation, workflow setup. Skip when: local-only changes, non-GitHub repositories.

Comprehensive GitHub code review with AI-powered swarm coordination

Multi-repository coordination, synchronization, and architecture management with AI swarm orchestration

Comprehensive GitHub project management with swarm-coordinated issue tracking, project board automation, and sprint planning

Comprehensive GitHub release orchestration with AI swarm coordination for automated versioning, testing, deployment, and rollback management

Advanced GitHub Actions workflow automation with AI swarm coordination, intelligent CI/CD pipelines, and comprehensive repository management

Create and execute Goal-Oriented Action Plans (GOAP) with precondition analysis, cost optimization, and adaptive replanning

Manage `@metaharness/darwin` bench suites — `bench create <repo>` scaffolds a JSON suite from a repo's test corpus; `bench verify <suite.json>` checks suite well-formedness. Bench suites are the fixed evaluation corpora that `harness-evolve --bench <suite.json>` scores variants against, decoupling evolution from the repo's natural tests. Degrades gracefully when @metaharness/darwin is absent.

One-command drift detection. Composes audit-list + oia-audit + audit-trend into a single primitive — finds the most recent audit in `metaharness-audit` namespace, runs a fresh audit against the current repo, diffs them via ADR-152 §3.1 similarity, and alerts when structural distance crosses `--threshold`. Iter 53 of ADR-150 deep integration.

Run `@metaharness/darwin evolve <repo>` to mutate a harness's seven policy surfaces (planner/contextBuilder/reviewer/retryPolicy/toolPolicy/memoryPolicy/scorePolicy), sandbox-score each variant, and promote only measured wins. The model is frozen; the harness evolves. Closes the loop ADR-150 opens (score+genome describe; evolve changes). Degrades gracefully when @metaharness/darwin is absent (ADR-150 + ADR-153 architectural constraints).

7-section repo readiness report from `metaharness genome <path>`. Returns repo_type / agent_topology / risk_score / mcp_surface / test_confidence / publish_readiness. Pure-read; degrades gracefully (ADR-150).

Inspect and audit GEPA genomes via the `@metaharness/darwin/gepa` library entry (darwin 0.8.0) — load/validate a genome (default is the shipped cand-6 promotion), render the system prompt a genome compiles to, or classify failure modes in a run transcript. The `gepaOptimize` loop itself is library-only (bring your own evaluator) and not surfaced here — use `harness-evolve` for sandbox-scored evolution. Degrades gracefully when @metaharness/darwin is absent.

Run a GEPA learning cycle via `metaharness learn` (upstream ADR-235, metaharness@0.3.0) — optimizes a harness genome against a SWE-bench-style slice manifest. $0 dry-run by default; `--run` is the explicit spend opt-in. Requires a metaharness repo checkout (`--repo` or $METAHARNESS_REPO) — without one it reports `checkout-required` with clone instructions. Degrades gracefully when metaharness is absent.

Static security scan of a harness's declared MCP surface via `harness mcp-scan <path>`. Reads `.mcp/servers.json` + `.harness/claims.json`. Pure-read, no dispatch. Exits 1 on findings at or above `--fail-on` severity.

Scaffold a custom AI agent harness via `metaharness new <name> --template <id> --host <id>`. Defaults to DRY-RUN (no writes) unless --confirm is passed. Refuses to write to the calling repo root or anywhere inside it. Honors ADR-150 architectural constraint + ruflo's "destructive-action confirmation" pattern.

Composite Phase-2 audit worker (ADR-150). Bundles harness oia-manifest + threat-model + mcp-scan into one timestamped audit record stored in the `metaharness-audit` memory namespace. Designed for cron-scheduled drift detection.

5-dimension harness readiness scorecard from `metaharness score <path>`. Returns harnessFit / compileConfidence / taskCoverage / toolSafety / memoryUsefulness + estCostPerRunUsd + scaffoldReady. Pure-read; subprocess invocation; degrades gracefully when MetaHarness is absent (ADR-150 architectural constraint).

Run `@metaharness/darwin security bench` (upstream "Darwin Shield" / ADR-155) — evolves a champion security-detection harness against a 10-vuln / 9-decoy corpus and grades it on TPR/FPR/patch-pass/repro/unsafe vs four baselines (B0 static, B1 LLM-single-pass, B2 fixed-agent, B3 Darwin-champion). Closest reference implementation for ruflo's own ADR-155 nightly self-learning security harness (PR

ADR-152 — weighted similarity between two harness fingerprints (genome + score JSON). Returns overall score in [0,1] plus per-component breakdown (cosine over 9 numerics, categorical agreement over 4 enums, jaccard over agent_topology). Unblocks ADR-151 §3.2 Recommender, §3.3 Drift Detection, §3.5 Plugin Compat. Pure-TS, no `@metaharness/*` dep — preserves ADR-150's four architectural constraints.

Enterprise-review-grade threat model from `harness threat-model <path>`. Categorizes MCP-surface threats; emits `worst: 'clean'|'low'|'medium'|'high'` + per-threat findings. Pure-read.

Byzantine fault-tolerant consensus and distributed coordination. Queen-led hierarchical swarm management with multiple consensus strategies. Use when: distributed coordination, fault-tolerant operations, multi-agent consensus, collective decision making. Skip when: single-agent tasks, simple operations, local-only work.

Advanced Hive Mind collective intelligence system for queen-led multi-agent coordination with consensus mechanisms and persistent memory

Automated coordination, formatting, and learning from Claude Code operations using intelligent hooks with MCP integration. Includes pre$post task hooks, session management, Git integration, memory coordination, and neural pattern training for enhanced development workflows.

Track long-horizon objectives across multiple sessions with milestone checkpoints, progress persistence, and drift detection

Initialize a new Ruflo project with MCP tools, hooks, and agent configuration. Use when setting up Ruflo in a fresh repo, or when the user says "init ruflo", "set up ruflo", or asks how to bootstrap the MCP server, hooks, and agent configs from scratch.

Route tasks via the 3-tier model selector and learned patterns; emits a routing rationale via hooks_explain

Publish or fetch learned patterns across projects via IPFS (Pinata) -- the cross-project pattern transfer that hooks_transfer enables

Detect and classify telemetry anomalies on Cognitum Seed devices. Use when investigating a device that's reporting odd metrics, before approving a firmware canary advancement, or when triaging fleet-wide health alerts.

Orchestrate firmware rollouts with canary deployment and anomaly-gated advancement

Create and manage Cognitum Seed device fleets with firmware policies

Register a Cognitum Seed device by endpoint and establish agent bridge

Verify witness chain integrity and detect provenance gaps

Extract entities and relations from source files to build a knowledge graph

Pathfinder traversal of the knowledge graph starting from a seed entity

Configure RuVLLM local inference with model selection, MicroLoRA fine-tuning, and SONA adaptation

Run Ruflo background workers using Claude Code native /loop scheduling

Run an Anthropic Claude Managed Agent — a cloud agent harness (container + filesystem + tools), the cloud counterpart of the local wasm-agent runtime

Ingest and normalize market data into OHLCV vectors with HNSW indexing

Detect and classify candlestick patterns from ingested OHLCV data

Bridge Claude Code auto-memory into AgentDB with ONNX embeddings, deduplicate, and enable unified cross-project search

AgentDB memory system with HNSW vector search. Provides 150x-12,500x faster pattern retrieval, persistent storage, and semantic search capabilities for learning and knowledge management. Use when: need to store successful patterns, searching for similar solutions, semantic lookup of past work, learning from previous tasks, sharing knowledge between agents, building knowledge base. Skip when: no learning needed, ephemeral one-off tasks, external data sources available, read-only exploration.

SOTA semantic search — hybrid (sparse+dense), Graph RAG multi-hop, MMR diversity reranking, recency weighting

Create a new sequentially numbered database migration with up/down SQL files

Validate pending migrations for foreign key consistency, rollback safety, and best practices

Stream live swarm events using the Monitor tool for real-time observability

One-time setup — mint a Cognitum Music personal access token and register the cogmusic MCP server with Claude Code

Generate a new song from a creative brief (genre, mood, language, BPM, theme) via the cogmusic MCP create_production tool

Fetch metadata and audio_url for a single production by id

List the account's saved music productions with metadata and audio_url

Run a mastering pass (LUFS loudness normalization + peak limiting) on an existing production

Extract MIDI/score from an existing production

Run 4-stem separation (vocals/drums/bass/other) on an existing production

Spawn nested sub-agents (agents that spawn sub-agents, up to depth=5) via Claude Code's native Task tool — for context-managed deep delegation

Train SONA + MicroLoRA neural patterns from successful task completions; runs the DISTILL + CONSOLIDATE phases of the 4-step pipeline

Neural pattern training with SONA (Self-Optimizing Neural Architecture), MoE (Mixture of Experts), and EWC++ for knowledge consolidation. Use when: pattern learning, model optimization, knowledge transfer, adaptive routing. Skip when: simple tasks, no learning required, one-off operations.

Aggregate and display system metrics with anomaly detection for a time period

Trace agent execution by collecting spans and building a trace tree for a task

Coordinate with the open ruflo swarm federation at x.ruv.io (signed Nostr, membership-gated) and ask Seraphina — the swarm queen / primary coordinator — for guidance. Use when: seeing who is online across the internet, reading/assigning work, checking or issuing claims across hosts, onboarding a new node or user, opening a public or private coordination channel, or deciding what the swarm should do next. Skip when: single-host local work with no other nodes.

AI-assisted pair programming with multiple modes (driver$navigator$switch), real-time verification, quality monitoring, and comprehensive testing. Supports TDD, debugging, refactoring, and learning sessions. Features automatic role switching, continuous code review, security scanning, and performance optimization with truth-score verification.

Comprehensive performance analysis, bottleneck detection, and optimization recommendations for Claude Flow swarms

Detect and flag personally identifiable information (PII) in text, code, and configurations. Use before committing code, writing logs, storing data, or sending model responses that might contain emails, phone numbers, SSNs, API keys, or passwords.

Run one tick of the sales business-pod (ADR-164 §4.1, Phase 2). Loads templates/sales.json, validates it against the pod-schema, resolves agents against ruflo's agent registry, reserves budget via the Phase-2 file-based stub ledger (atomic SQLite tracker is Phase 3 per ADR-164.1), constructs per-agent dry-run prompts, posts a summary envelope to room "sales" via the federation_bbs_publish JSONL backing store, and emits a structured {podName, tickId, agentsRan, totalUsd, envelopeId, status} line for /loop ingestion. Dry-run by default; --live is reserved for Phase 3.

Implement adaptive learning with ReasoningBank for pattern recognition, strategy optimization, and continuous improvement. Use when building self-learning agents, optimizing workflows, or implementing meta-cognitive systems.

Implement ReasoningBank adaptive learning with AgentDB's 150x faster vector database. Includes trajectory tracking, verdict judgment, memory distillation, and pattern recognition. Use when building self-learning agents, optimizing decision-making, or implementing experience replay systems.

Synthesize research findings from memory into structured reports with evidence grading, contradiction resolution, and actionable recommendations

Ruflo is a multi-agent orchestration platform for AI coding agents (Claude Code, Cursor, Codex, Copilot, Gemini, Amp, +12 more). Use this skill when the user wants to (1) install/init ruflo in a project, (2) run multi-agent swarms with hierarchical coordination, (3) use ruflo's 314+ MCP tools for memory, routing, hooks, sub-agents, or workflows, (4) check ruflo status/version/doctor health, or (5) discover which of ruflo's 30+ plugins fits their task.

Run health checks on the Ruflo installation and fix common issues

Diagnose Ruflo health, then report system, MCP server, and active-agent status without changing the installation

Manage RVF (Ruflo Vector Format) files for portable agent memory and cross-platform transfer

Scan inputs for prompt injection, unsafe content, and adversarial attacks using AIDefence. Use when processing untrusted input (user submissions, API payloads, webhook data, tool outputs) before passing it to a model or executing it.

Comprehensive security scanning and vulnerability detection. Includes input validation, path traversal prevention, CVE detection, and secure coding pattern enforcement. Use when: authentication implementation, authorization logic, payment processing, user data handling, API endpoint creation, file upload handling, database queries, external API integration. Skip when: read-only operations on public data, internal development tooling, static documentation, styling changes.

Run full security scans on the codebase using Ruflo security tools. Use when reviewing PRs for security regressions, auditing auth/input-handling code, before production deploys, or when the user asks for a security check at quick/standard/deep depth.

Persist and restore agent sessions across conversations with state snapshots

Create new Claude Code Skills with proper YAML frontmatter, progressive disclosure structure, and complete directory organization. Use when you need to build custom skills for specific workflows, generate skill templates, or understand the Claude Skills specification.

Run the SPARC Pseudocode and Architecture phases (2 and 3) — write algorithm pseudocode, design module boundaries and API contracts, then implement

SPARC development workflow: Specification, Pseudocode, Architecture, Refinement, Completion. A structured approach for complex implementations that ensures thorough planning before coding. Use when: new feature implementation, complex implementations, architectural changes, system redesign, integration work, unclear requirements. Skip when: simple bug fixes, documentation updates, configuration changes, well-defined small tasks, routine maintenance.

Run the SPARC Refinement and Completion phases — review code, improve test coverage, validate against specification, and generate documentation

Run the SPARC Specification phase — gather requirements, define acceptance criteria, identify constraints, and store the spec in memory

Stream-JSON chaining for multi-agent pipelines, data transformation, and sequential workflows

Advanced swarm orchestration patterns for research, development, testing, and complex distributed workflows

Initialize a multi-agent swarm with anti-drift configuration. Use when starting a complex multi-file task that needs 3+ coordinated agents (feature implementation, refactor across modules, security audit). Skip for single-file edits or quick questions.

Multi-agent swarm coordination for complex tasks. Uses hierarchical topology with specialized agents to break down and execute complex work across multiple files and modules. Use when: 3+ files need changes, new feature implementation, cross-module refactoring, API changes with tests, security-related changes, performance optimization across codebase, database schema changes. Skip when: single file edits, simple bug fixes (1-2 lines), documentation updates, configuration changes, quick exploration.

Test-Driven Repair — given a failing test, spawn a bounded headless `claude -p` (Read/Edit/Bash only) that makes the test pass without modifying it. Modeled on agent-harness-generator's ADR-175 Test-Driven Repair mode. Bounded cost via --max-budget-usd, bounded capability via --allowedTools. Closes the loop the TDD plugins didn't — we generate tests, this fixes the code to satisfy them.

TDD London School workflow -- mock-first, outside-in test development

Detect missing test coverage and generate test suggestions. Use when the user asks about coverage gaps, untested code, or what tests to write next; also after adding a feature to find what still needs tests.

Run a historical backtest using npx neural-trader with Rust/NAPI engine (8-19x faster) and walk-forward validation; Ed25519-sign the result for paper→live tamper evidence (ADR-126 Phase 4)

Run a heavy neural-trader job (long walk-forward, big Monte-Carlo, parameter sweep, model training) on the Anthropic Managed Agent cloud runtime instead of locally

Regulator-grade feature attribution for any LSTM/Transformer signal — single-entry PageRank ranks the top-K features that drove the prediction (ADR-126 Phase 6, ADR-123 single-entry PR)

Optimize portfolio allocation using npx neural-trader mean-variance engine with risk constraints and rebalancing plan

Mean-variance portfolio optimization via Conjugate Gradient — 40-60× faster than the legacy Neumann path (ADR-126 Phase 3, ADR-123 Wedge 8)

Detect current market regime using npx neural-trader — bull/bear/ranging/volatile classification with recommended strategy. Use when the user asks about market conditions, wants to pick a strategy for current conditions, or before running a backtest/signal that should be regime-aware.

Assess portfolio risk using npx neural-trader — VaR, CVaR, Sharpe, position sizing, circuit breaker status

Generate trading signals using npx neural-trader anomaly detection engine with Z-score scoring and neural prediction

Train neural models (LSTM, Transformer, N-BEATS) on market data using npx neural-trader with confidence intervals

Create and manage sandboxed WASM agents for isolated code execution

CLI modernization and hooks system enhancement for claude-flow v3. Implements interactive prompts, command decomposition, enhanced hooks integration, and intelligent workflow automation.

Core module implementation for claude-flow v3. Implements DDD domains, clean architecture patterns, dependency injection, and modular TypeScript codebase with comprehensive testing.

Domain-Driven Design architecture for claude-flow v3. Implements modular, bounded context architecture with clean separation of concerns and microkernel pattern.

Deep agentic-flow@alpha integration implementing ADR-001. Eliminates 10,000+ duplicate lines by building claude-flow as specialized extension rather than parallel implementation.

MCP server optimization and transport layer enhancement for claude-flow v3. Implements connection pooling, load balancing, tool registry optimization, and performance monitoring for sub-100ms response times.

Unify 6+ memory systems into AgentDB with HNSW indexing for 150x-12,500x search improvements. Implements ADR-006 (Unified Memory Service) and ADR-009 (Hybrid Memory Backend).

Achieve aggressive v3 performance targets: 2.49x-7.47x Flash Attention speedup, 150x-12,500x search improvements, 50-75% memory reduction. Comprehensive benchmarking and optimization suite.

Complete security architecture overhaul for claude-flow v3. Addresses critical CVEs (CVE-1, CVE-2, CVE-3) and implements secure-by-default patterns. Use for security-first v3 implementation.

15-agent hierarchical mesh coordination for v3 implementation. Orchestrates parallel execution across security, core, and integration domains following 10 ADRs with 14-week timeline.

Validate a Claude Code plugin structure, frontmatter, and MCP tool references

Cluster code by graph community detection via npx ruvector@0.2.25 hooks graph-cluster (spectral / Louvain)

Generate embeddings via npx ruvector@0.2.25 embed text (ONNX all-MiniLM-L6-v2, 384-dim), normalize, and store in HNSW index

Embed hierarchical data via npx ruvector@0.2.25 embed text and project into the Poincare ball in user code (no --model poincare flag in 0.2.25)

Vector search via embeddings_* (large-scale HNSW) and ruvllm_hnsw_* (WASM router for ≤11 hot patterns), with RaBitQ 1-bit quantization for 32× memory reduction

First-run setup for ruvector@0.2.25 — installs ONNX/Brain/SONA add-ons, registers the MCP server, and verifies the install via `doctor`

Comprehensive truth scoring, code quality verification, and automatic rollback system with 0.95 accuracy threshold for ensuring high-quality agent outputs and codebase reliability.

Browse, publish, and install WASM agents from the community gallery

Sign, verify, and track fix-marker regressions over time using a deterministic Ed25519 witness manifest. Works in any project — clone the toolkit, run init, register fixes, regen on each release.

Run comprehensive worker system benchmarks and performance analysis

Worker-Agent integration for intelligent task dispatch and performance tracking

Workflow creation, execution, and template management. Automates complex multi-step processes with agent coordination. Use when: automating processes, creating reusable workflows, orchestrating multi-step tasks. Skip when: simple single-step tasks, ad-hoc operations.

Author a workflow — either an MCP workflow template (persisted, lifecycle) or a native .claude/workflows/*.js orchestration script (agent/parallel/pipeline fan-out)

Run a workflow — drive an MCP workflow lifecycle (execute/pause/resume/cancel) or invoke + resume a native .claude/workflows/*.js orchestration via the Workflow tool