π The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated
TypeScript agentic-aiagentic-frameworkagentic-workflowagentsai-agentsai-assistantai-skillsautonomous-agentsclaudecodexdsh-pluginharnessmcp-servermulti-agentmulti-agent-systemsnpmskillsswarmswarm-intelligencetypescript
feat: add ruflo-goals plugin β GOAP planning, deep research, horizon tracking
Reuven851f3ed4ce28
diff --git a/.claude-plugin/marketplace.json b/.claude-plugin/marketplace.jsonindex 3b965dc425..f11146bc19 100644--- a/.claude-plugin/marketplace.json+++ b/.claude-plugin/marketplace.json@@ -100,6 +100,11 @@"name": "ruflo-plugin-creator","source": "./plugins/ruflo-plugin-creator","description": "Scaffold, validate, and publish new Claude Code plugins with proper structure"+ },+ {+ "name": "ruflo-goals",+ "source": "./plugins/ruflo-goals",+ "description": "Long-horizon goal planning, deep research orchestration, and adaptive replanning using GOAP"}]}diff --git a/README.md b/README.mdindex f7f0d64e8b..2071521ffd 100644--- a/README.md+++ b/README.md@@ -51,7 +51,7 @@ Install Ruflo as a native Claude Code plugin -- adds skills, commands, agents, a```<details>-<summary><strong>All 19 plugins</strong></summary>+<summary><strong>All 20 plugins</strong></summary>| Plugin | What it adds ||--------|-------------|@@ -74,6 +74,7 @@ Install Ruflo as a native Claude Code plugin -- adds skills, commands, agents, a| **ruflo-testgen** | Test gap detection, TDD workflow, tester agent || **ruflo-docs** | Doc generation, drift detection, docs-writer agent || **ruflo-plugin-creator** | Scaffold, validate, and publish new plugins |+| **ruflo-goals** | GOAP planning, deep research, long-horizon tracking |</details>@@ -108,7 +109,7 @@ claude mcp add ruflo -- npx -y @claude-flow/cli@latest| π§ **Self-Learning** | SONA neural patterns, ReasoningBank, trajectory learning || πΎ **Vector Memory** | HNSW-indexed AgentDB with 150x-12,500x faster search || β‘ **Background Workers** | 12 auto-triggered workers (audit, optimize, testgaps, etc.) |-| π§© **Plugin Marketplace** | 19 native Claude Code plugins + 20 npm plugins |+| π§© **Plugin Marketplace** | 20 native Claude Code plugins + 20 npm plugins || π **Multi-Provider** | Claude, GPT, Gemini, Cohere, Ollama with smart routing || π‘οΈ **Security** | AIDefence, input validation, CVE remediation, path traversal prevention |diff --git a/plugins/ruflo-goals/.claude-plugin/plugin.json b/plugins/ruflo-goals/.claude-plugin/plugin.jsonnew file mode 100644index 0000000000..e512f59a68--- /dev/null+++ b/plugins/ruflo-goals/.claude-plugin/plugin.json@@ -0,0 +1,12 @@+{+ "name": "ruflo-goals",+ "description": "Long-horizon goal planning, deep research orchestration, and adaptive replanning using GOAP algorithms",+ "version": "0.1.0",+ "author": {+ "name": "ruvnet",+ "url": "https://github.com/ruvnet"+ },+ "homepage": "https://github.com/ruvnet/ruflo",+ "license": "MIT",+ "keywords": ["ruflo", "goals", "goap", "research", "planning", "deep-research", "long-horizon"]+}diff --git a/plugins/ruflo-goals/README.md b/plugins/ruflo-goals/README.mdnew file mode 100644index 0000000000..2717c85d50--- /dev/null+++ b/plugins/ruflo-goals/README.md@@ -0,0 +1,34 @@+# ruflo-goals++Long-horizon goal planning, deep research orchestration, and adaptive replanning.++## Install++```+/plugin marketplace add ruvnet/ruflo+/plugin install ruflo-goals@ruflo+```++## Features++- **Goal planning**: GOAP-based action planning with precondition analysis and cost optimization+- **Deep research**: Multi-source research orchestration (web, memory, codebase, patterns)+- **Horizon tracking**: Persistent objectives across sessions with milestone checkpoints+- **Research synthesis**: Evidence-graded reports with contradiction resolution++## Commands++- `/goals` -- List active horizons, check progress, view research++## Skills++- `deep-research` -- Orchestrate multi-phase research campaigns+- `goal-plan` -- Create and execute GOAP action plans+- `horizon-track` -- Track objectives across sessions with drift detection+- `research-synthesize` -- Synthesize findings into structured reports++## Agents++- `goal-planner` -- GOAP specialist with A* planning and trajectory learning+- `deep-researcher` -- Multi-source research with evidence grading+- `horizon-tracker` -- Cross-session objective tracking with drift detectiondiff --git a/plugins/ruflo-goals/agents/deep-researcher.md b/plugins/ruflo-goals/agents/deep-researcher.mdnew file mode 100644index 0000000000..a29fe93c02--- /dev/null+++ b/plugins/ruflo-goals/agents/deep-researcher.md@@ -0,0 +1,15 @@+---+name: deep-researcher+description: Multi-source research specialist that gathers, cross-references, and synthesizes information from web, codebase, memory, and pattern databases+model: sonnet+---++You are a deep research specialist. You investigate topics thoroughly by:+1. Checking existing knowledge in memory and pattern databases+2. Searching the web for current information+3. Analyzing relevant source code and documentation+4. Cross-referencing findings across sources+5. Grading evidence quality (high/medium/low)+6. Producing structured synthesis reports++Store all findings in the `research` memory namespace. Flag contradictions explicitly.diff --git a/plugins/ruflo-goals/agents/goal-planner.md b/plugins/ruflo-goals/agents/goal-planner.mdnew file mode 100644index 0000000000..4b51e0609a--- /dev/null+++ b/plugins/ruflo-goals/agents/goal-planner.md@@ -0,0 +1,16 @@+---+name: goal-planner+description: GOAP specialist that creates optimal action plans using A* search through state spaces, with adaptive replanning and trajectory learning+model: sonnet+---++You are a Goal-Oriented Action Planning (GOAP) specialist. You use A* search to find optimal paths through state spaces and create executable plans.++Your methodology:+1. Assess current state and define goal state+2. Inventory available actions with preconditions, effects, and costs+3. Search for the cheapest action sequence that transforms current into goal state+4. Execute with continuous monitoring β replan when actions fail or conditions change+5. Record trajectories for learning via hooks_intelligence tools++Always produce plans with concrete success criteria, cost estimates, and fallback strategies.diff --git a/plugins/ruflo-goals/agents/horizon-tracker.md b/plugins/ruflo-goals/agents/horizon-tracker.mdnew file mode 100644index 0000000000..1cb7cbb462--- /dev/null+++ b/plugins/ruflo-goals/agents/horizon-tracker.md@@ -0,0 +1,14 @@+---+name: horizon-tracker+description: Long-horizon objective tracker that persists progress across sessions with milestone checkpoints and drift detection+model: sonnet+---++You are a long-horizon objective tracker. You manage objectives that span multiple sessions by:+1. Defining milestones with concrete completion criteria+2. Recording session check-ins and check-outs in memory+3. Detecting drift (scope creep, timeline slip, approach obsolescence)+4. Persisting state across conversations via the horizons memory namespace+5. Recommending course corrections when progress deviates from plan++At session start, always recall the current horizon state. At session end, always update it.diff --git a/plugins/ruflo-goals/commands/goals.md b/plugins/ruflo-goals/commands/goals.mdnew file mode 100644index 0000000000..cbc57671d5--- /dev/null+++ b/plugins/ruflo-goals/commands/goals.md@@ -0,0 +1,11 @@+---+name: goals+description: List active horizons, check goal progress, and view research findings+---++Show goal and research status:++1. Call `mcp__claude-flow__memory_search` with namespace `horizons` and query `*` to list active horizons+2. For each horizon, show: objective, current milestone, progress %, target date, drift status+3. Call `mcp__claude-flow__memory_search` with namespace `research-synthesis` to list completed research reports+4. Show a summary table of horizons and research statediff --git a/plugins/ruflo-goals/skills/deep-research/SKILL.md b/plugins/ruflo-goals/skills/deep-research/SKILL.mdnew file mode 100644index 0000000000..21018a0eb2--- /dev/null+++ b/plugins/ruflo-goals/skills/deep-research/SKILL.md@@ -0,0 +1,42 @@+---+name: deep-research+description: Orchestrate multi-phase deep research with web search, memory retrieval, pattern matching, and synthesis into structured findings+allowed-tools: mcp__claude-flow__memory_store mcp__claude-flow__memory_search mcp__claude-flow__memory_search_unified mcp__claude-flow__agentdb_hierarchical-store mcp__claude-flow__agentdb_hierarchical-recall mcp__claude-flow__agentdb_pattern-search mcp__claude-flow__agentdb_pattern-store mcp__claude-flow__neural_predict mcp__claude-flow__hooks_intelligence_pattern-search mcp__claude-flow__hooks_intelligence_pattern-store mcp__claude-flow__task_create mcp__claude-flow__task_list mcp__claude-flow__task_summary Bash WebSearch WebFetch Read Write+---++# Deep Research++Orchestrate multi-phase deep research campaigns that gather, cross-reference, and synthesize information from multiple sources.++## When to use++When you need to investigate a complex topic thoroughly β spanning web sources, codebase patterns, stored memory, and external documentation β and produce a structured synthesis.++## Steps++1. **Define research scope** β break the question into 3-7 sub-questions that together answer the main question+2. **Search existing knowledge** β call `mcp__claude-flow__memory_search_unified` and `mcp__claude-flow__agentdb_pattern-search` to check what's already known+3. **Web research** β use `WebSearch` and `WebFetch` to gather external information for each sub-question+4. **Codebase analysis** β use `Bash` (grep/find), `Read` to examine relevant source files+5. **Cross-reference** β compare findings across sources, identify agreements and contradictions+6. **Store findings** β call `mcp__claude-flow__memory_store` with namespace `research` for each key finding+7. **Store patterns** β call `mcp__claude-flow__agentdb_pattern-store` for reusable patterns discovered+8. **Synthesize** β produce a structured research report with:+ - Executive summary (2-3 sentences)+ - Key findings (bulleted)+ - Evidence quality assessment (high/medium/low per finding)+ - Open questions remaining+ - Recommended next steps++## Research depth levels++- **Quick** β memory search + 1-2 web queries, 2-3 minutes+- **Standard** β memory + web + codebase scan, 5-10 minutes+- **Deep** β all sources + cross-referencing + pattern storage, 15-30 minutes+- **Exhaustive** β deep + spawn sub-agents for parallel research threads, 30+ minutes++## Memory namespaces++- `research` β raw findings keyed by topic+- `research-synthesis` β completed synthesis reports+- `research-sources` β source URLs and referencesdiff --git a/plugins/ruflo-goals/skills/goal-plan/SKILL.md b/plugins/ruflo-goals/skills/goal-plan/SKILL.mdnew file mode 100644index 0000000000..91fd31c9d8--- /dev/null+++ b/plugins/ruflo-goals/skills/goal-plan/SKILL.md@@ -0,0 +1,58 @@+---+name: goal-plan+description: Create and execute Goal-Oriented Action Plans (GOAP) with precondition analysis, cost optimization, and adaptive replanning+allowed-tools: mcp__claude-flow__task_create mcp__claude-flow__task_list mcp__claude-flow__task_status mcp__claude-flow__task_assign mcp__claude-flow__task_update mcp__claude-flow__task_complete mcp__claude-flow__task_summary mcp__claude-flow__memory_store mcp__claude-flow__memory_search mcp__claude-flow__neural_predict mcp__claude-flow__workflow_create mcp__claude-flow__workflow_execute mcp__claude-flow__workflow_status mcp__claude-flow__hooks_intelligence_trajectory-start mcp__claude-flow__hooks_intelligence_trajectory-step mcp__claude-flow__hooks_intelligence_trajectory-end Bash Read Write Edit+---++# Goal Plan++Create and execute intelligent plans using Goal-Oriented Action Planning (GOAP).++## When to use++When you have a complex objective that requires multiple steps, has dependencies between steps, and may need adaptive replanning as conditions change.++## Steps++1. **Define goal state** β what does "done" look like? List concrete success criteria+2. **Assess current state** β what's true now? What assets, code, infrastructure exist?+3. **Identify gap** β what must change between current and goal state?+4. **Inventory actions** β list available actions with:+ - Preconditions (what must be true before this action)+ - Effects (what becomes true after this action)+ - Cost estimate (time, complexity, risk)+5. **Generate plan** β find the optimal action sequence using A* through the state space+6. **Record trajectory** β call `mcp__claude-flow__hooks_intelligence_trajectory-start` to begin tracking+7. **Create tasks** β call `mcp__claude-flow__task_create` for each action in the plan+8. **Execute** β work through tasks in dependency order:+ - Before each action: verify preconditions still hold+ - After each action: verify effects achieved+ - Record each step via `mcp__claude-flow__hooks_intelligence_trajectory-step`+9. **Monitor & replan** β if an action fails or produces unexpected results:+ - Reassess current state+ - Recalculate optimal path from new state+ - Update remaining tasks+10. **Complete trajectory** β call `mcp__claude-flow__hooks_intelligence_trajectory-end`+11. **Store successful plan** β call `mcp__claude-flow__memory_store` with namespace `goap-plans`++## Plan output format++```+Goal: [concrete objective]+Current State: [key facts]+Plan Cost: [estimated effort]+Steps:+ 1. [action] β precondition: [X], effect: [Y], cost: [Z]+ 2. [action] β precondition: [Y], effect: [W], cost: [Z]+ ...+Risk Factors: [what could force a replan]+Fallback: [alternative approach if primary path fails]+```++## Replanning triggers++- Action fails (precondition no longer met)+- Unexpected side effects detected+- New information changes goal definition+- Cost exceeds threshold+- External dependency becomes unavailablediff --git a/plugins/ruflo-goals/skills/horizon-track/SKILL.md b/plugins/ruflo-goals/skills/horizon-track/SKILL.mdnew file mode 100644index 0000000000..201aa8ac76--- /dev/null+++ b/plugins/ruflo-goals/skills/horizon-track/SKILL.md@@ -0,0 +1,60 @@+---+name: horizon-track+description: Track long-horizon objectives across multiple sessions with milestone checkpoints, progress persistence, and drift detection+allowed-tools: mcp__claude-flow__memory_store mcp__claude-flow__memory_search mcp__claude-flow__memory_list mcp__claude-flow__memory_retrieve mcp__claude-flow__task_list mcp__claude-flow__task_summary mcp__claude-flow__progress_check mcp__claude-flow__progress_summary mcp__claude-flow__agentdb_hierarchical-store mcp__claude-flow__agentdb_hierarchical-recall mcp__claude-flow__hooks_intelligence_pattern-store mcp__claude-flow__session_save mcp__claude-flow__session_restore Bash Read Write+---++# Horizon Track++Track long-running objectives that span multiple sessions, days, or weeks.++## When to use++When an objective is too large for a single session β multi-week features, research programs, migration projects, or any work that requires persistent progress tracking across conversations.++## Steps++1. **Initialize horizon** β define the objective, target date, and 3-7 milestones+2. **Store horizon** β call `mcp__claude-flow__memory_store` with namespace `horizons` and key `horizon-[name]`:+ ```json+ {+ "objective": "...",+ "created": "2026-04-28",+ "targetDate": "2026-05-15",+ "milestones": [+ {"id": "m1", "name": "...", "criteria": "...", "status": "pending"},+ {"id": "m2", "name": "...", "criteria": "...", "status": "pending"}+ ],+ "currentMilestone": "m1",+ "sessions": []+ }+ ```+3. **Session check-in** β at the start of each session:+ - Recall horizon: `mcp__claude-flow__memory_retrieve` key `horizon-[name]` namespace `horizons`+ - Review milestone status+ - Assess drift (are we still on track?)+ - Plan this session's contribution+4. **Work and record** β as work progresses:+ - Update milestone status+ - Record session summary+ - Store intermediate findings+5. **Session check-out** β at the end of each session:+ - Update horizon state in memory+ - Record what was accomplished+ - Note blockers or scope changes+ - Estimate remaining effort+6. **Milestone completion** β when a milestone is done:+ - Verify completion criteria met+ - Store learned patterns via `mcp__claude-flow__hooks_intelligence_pattern-store`+ - Advance to next milestone+7. **Drift detection** β flag when:+ - Progress rate suggests target date will be missed+ - Scope has grown beyond original definition+ - Dependencies have changed+ - Approach needs fundamental rethinking++## Memory namespaces++- `horizons` β active horizon definitions and state+- `horizon-sessions` β per-session summaries keyed by `[horizon]-[date]`+- `horizon-learnings` β patterns and insights discovered during the horizondiff --git a/plugins/ruflo-goals/skills/research-synthesize/SKILL.md b/plugins/ruflo-goals/skills/research-synthesize/SKILL.mdnew file mode 100644index 0000000000..69d059f837--- /dev/null+++ b/plugins/ruflo-goals/skills/research-synthesize/SKILL.md@@ -0,0 +1,61 @@+---+name: research-synthesize+description: Synthesize research findings from memory into structured reports with evidence grading, contradiction resolution, and actionable recommendations+allowed-tools: mcp__claude-flow__memory_search mcp__claude-flow__memory_search_unified mcp__claude-flow__memory_list mcp__claude-flow__memory_retrieve mcp__claude-flow__memory_store mcp__claude-flow__agentdb_context-synthesize mcp__claude-flow__agentdb_pattern-search mcp__claude-flow__neural_predict Bash Read Write+---++# Research Synthesize++Synthesize accumulated research findings into actionable reports.++## When to use++After running deep-research (one or multiple times), when you need to pull together findings from memory into a coherent synthesis with recommendations.++## Steps++1. **Gather findings** β search across research namespaces:+ - `mcp__claude-flow__memory_search` namespace `research` for raw findings+ - `mcp__claude-flow__memory_search` namespace `research-sources` for references+ - `mcp__claude-flow__agentdb_pattern-search` for discovered patterns+ - `mcp__claude-flow__agentdb_context-synthesize` for AI-assisted context building+2. **Grade evidence** β for each finding, assess:+ - **High**: Multiple independent sources agree, directly observed, reproducible+ - **Medium**: Single credible source, indirectly supported, plausible+ - **Low**: Anecdotal, single unverified source, speculative+3. **Resolve contradictions** β when findings conflict:+ - Identify the specific claim in tension+ - Compare evidence quality+ - Check recency (newer data may supersede)+ - Note unresolved contradictions explicitly+4. **Predict relevance** β call `mcp__claude-flow__neural_predict` to score which findings are most relevant to the original goal+5. **Structure report**:+ - Executive summary (2-3 sentences answering the original question)+ - Key findings (ranked by evidence quality)+ - Methodology (what sources were checked)+ - Limitations (what wasn't checked, what remains uncertain)+ - Recommendations (concrete next actions)+ - References (source links and memory keys)+6. **Store synthesis** β call `mcp__claude-flow__memory_store` namespace `research-synthesis` with the full report++## Output format++```+# [Research Topic] β Synthesis Report++## Summary+[2-3 sentence answer]++## Key Findings+1. [Finding] β Evidence: High/Medium/Low+2. [Finding] β Evidence: High/Medium/Low++## Contradictions+- [Claim A] vs [Claim B]: [resolution or "unresolved"]++## Recommendations+1. [Action] β because [reasoning]++## Sources+- [key]: [description]+```