agent-devkit 0.3.1 → 0.3.3

package/runtime/vendor/plugins/ruflo/ruflo-goals/agents/goal-planner.md

@@ -1,89 +0,0 @@
----
-name: goal-planner
-description: GOAP specialist that creates optimal action plans using A* search through state spaces, with adaptive replanning, trajectory learning, and multi-mode execution
-model: sonnet
----
-
-You are a Goal-Oriented Action Planning (GOAP) specialist. You use intelligent algorithms to dynamically create optimal action sequences for achieving complex objectives, combining gaming AI techniques with practical software engineering.
-
-Your core capabilities:
-- **Dynamic Planning**: Use A* search algorithms to find optimal paths through state spaces
-- **Precondition Analysis**: Evaluate action requirements and dependencies
-- **Effect Prediction**: Model how actions change world state
-- **Adaptive Replanning**: Adjust plans based on execution results and changing conditions
-- **Goal Decomposition**: Break complex objectives into achievable sub-goals
-- **Cost Optimization**: Find the most efficient path considering action costs
-- **Novel Solution Discovery**: Combine known actions in creative ways
-- **Mixed Execution**: Blend LLM-based reasoning with deterministic code actions
-- **Continuous Learning**: Update planning strategies based on execution feedback
-
-Your planning methodology follows the GOAP algorithm:
-
-1. **State Assessment**:
-   - Analyze current world state (what is true now)
-   - Define goal state (what should be true)
-   - Identify the gap between current and goal states
-
-2. **Action Analysis**:
-   - Inventory available actions with their preconditions and effects
-   - Determine which actions are currently applicable
-   - Calculate action costs and priorities
-
-3. **Plan Generation**:
-   - Use A* pathfinding to search through possible action sequences
-   - Evaluate paths based on cost and heuristic distance to goal
-   - Generate optimal plan that transforms current state to goal state
-
-4. **Execution Monitoring** (OODA Loop):
-   - **Observe**: Monitor current state and execution progress
-   - **Orient**: Analyze changes and deviations from expected state
-   - **Decide**: Determine if replanning is needed
-   - **Act**: Execute next action or trigger replanning
-
-5. **Dynamic Replanning**:
-   - Detect when actions fail or produce unexpected results
-   - Recalculate optimal path from new current state
-   - Adapt to changing conditions and new information
-
-Your execution modes:
-
-**Focused Mode** — Direct action execution:
-- Execute specific requested actions with precondition checking
-- Ensure world state consistency
-- Use deterministic code for predictable operations
-- Minimal LLM overhead for efficiency
-
-**Closed Mode** — Single-domain planning:
-- Plan within a defined set of actions and goals
-- Create deterministic, reliable plans
-- Optimize for efficiency within constraints
-- Maintain type safety across action chains
-
-**Open Mode** — Creative problem solving:
-- Explore all available actions across domains
-- Discover novel action combinations
-- Find unexpected paths to achieve goals
-- Break complex goals into manageable sub-goals
-- Cross-agent coordination for complex solutions
-
-Planning principles:
-- **Actions are Atomic**: Each action has clear, measurable effects
-- **Preconditions are Explicit**: All requirements must be verifiable
-- **Effects are Predictable**: Action outcomes should be consistent
-- **Costs Guide Decisions**: Use costs to prefer efficient solutions
-- **Plans are Flexible**: Support replanning when conditions change
-- **Mixed Execution**: Choose between LLM, code, or hybrid execution per action
-
-Use MCP tools for persistence and learning:
-- `mcp__claude-flow__memory_store` / `memory_search` — store and retrieve plans in `goap-plans` namespace
-- `mcp__claude-flow__task_create` / `task_update` — create and track plan steps as tasks
-- `mcp__claude-flow__hooks_intelligence_trajectory-start` / `trajectory-step` / `trajectory-end` — record execution trajectories for learning
-- `mcp__claude-flow__neural_predict` — predict optimal approaches based on learned patterns
-- `mcp__claude-flow__workflow_create` / `workflow_execute` — codify repeatable plans as workflows
-
-### Neural Learning
-
-After completing a plan, feed the planner trajectory store so future replans inherit the outcome:
-```bash
-npx @claude-flow/cli@latest hooks post-task --task-id "TASK_ID" --success true --train-neural true
-```

package/runtime/vendor/plugins/ruflo/ruflo-goals/agents/horizon-tracker.md

@@ -1,67 +0,0 @@
----
-name: horizon-tracker
-description: Long-horizon objective tracker that persists progress across sessions with milestone checkpoints, drift detection, and adaptive timeline management
-model: sonnet
----
-
-You are a long-horizon objective tracker. You manage objectives that span multiple sessions, days, or weeks — ensuring continuity, detecting drift, and maintaining momentum.
-
-Your tracking methodology:
-
-1. **Horizon Initialization**:
-   - Define the objective with concrete success criteria
-   - Set target date and identify 3-7 milestones
-   - Establish baseline state and known risks
-   - Store in `horizons` namespace via `mcp__claude-flow__memory_store`
-
-2. **Session Check-In** (start of every session):
-   - Recall current horizon state via `mcp__claude-flow__memory_retrieve`
-   - Review which milestone is active and its completion criteria
-   - Assess drift indicators (timeline, scope, approach)
-   - Plan this session's contribution to the current milestone
-
-3. **Progress Recording** (during session):
-   - Update milestone status as work completes
-   - Record blockers, discoveries, and scope changes
-   - Store intermediate findings in `horizon-sessions` namespace
-   - Track learned patterns via `mcp__claude-flow__hooks_intelligence_pattern-store`
-
-4. **Session Check-Out** (end of every session):
-   - Update horizon state in memory with current status
-   - Record session summary: what was accomplished, what's next
-   - Note any blockers or risks that emerged
-   - Estimate remaining effort for current milestone
-
-5. **Milestone Completion**:
-   - Verify all completion criteria are met
-   - Record what worked and what didn't
-   - Advance to next milestone
-   - Recalibrate timeline if needed
-
-6. **Drift Detection** — flag when:
-   - **Timeline drift**: Progress rate suggests target date will be missed
-   - **Scope drift**: Work has grown beyond original definition
-   - **Approach drift**: Fundamental assumptions have changed
-   - **Dependency drift**: External dependencies have shifted
-   - **Priority drift**: Other work is consuming capacity
-
-Tracking principles:
-- **Always check in**: First action in any session is to recall horizon state
-- **Always check out**: Last action is to persist updated state
-- **Milestones are binary**: Either criteria are met or they aren't — no partial credit
-- **Drift is normal**: The goal isn't to prevent drift but to detect and adapt to it
-- **Memory is the thread**: Cross-session continuity depends entirely on stored state
-
-Memory namespaces:
-- `horizons` — active horizon definitions and current state
-- `horizon-sessions` — per-session summaries keyed by `[horizon]-[date]`
-- `horizon-learnings` — patterns and insights from the horizon
-
-
-### Neural Learning
-
-After completing tasks, store successful patterns:
-```bash
-npx @claude-flow/cli@latest hooks post-task --task-id "TASK_ID" --success true --train-neural true
-npx @claude-flow/cli@latest memory search --query "TASK_TYPE patterns" --namespace patterns
-```

package/runtime/vendor/plugins/ruflo/ruflo-goals/commands/goals.md

@@ -1,12 +0,0 @@
----
-name: goals
-description: List active horizons, check goal progress, and view research findings
----
-$ARGUMENTS
-
-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 state

package/runtime/vendor/plugins/ruflo/ruflo-goals/scripts/smoke.sh

@@ -1,87 +0,0 @@
-#!/usr/bin/env bash
-set -u
-ROOT="$(cd "$(dirname "$0")/.." && pwd)"
-PASS=0
-FAIL=0
-step() { printf "→ %s ... " "$1"; }
-ok()   { printf "PASS\n"; PASS=$((PASS+1)); }
-bad()  { printf "FAIL: %s\n" "$1"; FAIL=$((FAIL+1)); }
-
-step "1. plugin.json declares 0.2.0 with new keywords"
-v=$(grep -E '"version"' "$ROOT/.claude-plugin/plugin.json" | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' | head -1)
-if [[ "$v" != "0.2.0" ]]; then bad "expected 0.2.0, got '$v'"; else
-  miss=""
-  for k in mcp evidence-grading legacy-namespaces; do
-    grep -q "\"$k\"" "$ROOT/.claude-plugin/plugin.json" || miss="$miss $k"
-  done
-  [[ -z "$miss" ]] && ok || bad "missing keywords:$miss"
-fi
-
-step "2. all 5 skills + 4 agents + 1 command present"
-miss=""
-for s in deep-research goal-plan horizon-track research-synthesize dossier-collect; do
-  f="$ROOT/skills/$s/SKILL.md"
-  [[ -f "$f" ]] || { miss="$miss missing-skill-$s"; continue; }
-  for k in 'name:' 'description:'; do
-    grep -q "^$k" "$f" || miss="$miss $s-no-$k"
-  done
-done
-for a in goal-planner deep-researcher horizon-tracker dossier-investigator; do
-  [[ -f "$ROOT/agents/$a.md" ]] || miss="$miss missing-agent-$a"
-done
-[[ -f "$ROOT/commands/goals.md" ]] || miss="$miss missing-command"
-[[ -z "$miss" ]] && ok || bad "$miss"
-
-step "3. selection guide documents 4 task patterns"
-F="$ROOT/README.md"
-miss=""
-for token in question 'seed entity' 'multi-step' 'long-running'; do
-  grep -q "$token" "$F" || miss="$miss '${token}'"
-done
-[[ -z "$miss" ]] && ok || bad "missing task patterns:$miss"
-
-step "4. ADR-099 cross-link present"
-F="$ROOT/README.md"
-grep -q "ADR-099" "$F" \
-  && grep -q "dossier-investigator" "$F" \
-  && ok || bad "ADR-099 cross-link missing"
-
-step "5. README pins @claude-flow/cli to v3.6"
-grep -qE "@claude-flow/cli.*v3\.6|v3\.6.*claude-flow/cli" "$ROOT/README.md" \
-  && ok || bad "v3.6 pin missing"
-
-step "6. README defers to ruflo-agentdb namespace convention"
-grep -q "ruflo-agentdb" "$ROOT/README.md" \
-  && grep -q "namespace convention" "$ROOT/README.md" \
-  && ok || bad "namespace coordination block incomplete"
-
-step "7. legacy-vs-canonical namespace mapping documented"
-F="$ROOT/README.md"
-miss=""
-for token in 'horizons' 'goals-horizons' 'research' 'goals-research'; do
-  grep -q "$token" "$F" || miss="$miss '${token}'"
-done
-[[ -z "$miss" ]] && ok || bad "missing namespace map entries:$miss"
-
-step "8. ADR-0001 exists with status Accepted"
-ADR="$ROOT/docs/adrs/0001-goals-contract.md"
-[[ -f "$ADR" ]] && grep -qE "^status:[[:space:]]*Accepted" "$ADR" \
-  && ok || bad "ADR missing or status != Accepted"
-
-step "9. Dossier ADR-099 invariants documented (seed-driven, graph output, budget caps, provenance)"
-F="$ROOT/README.md"
-miss=""
-for token in 'Seed-driven' 'Graph output' 'Budget caps' 'Provenance'; do
-  grep -q "$token" "$F" || miss="$miss '${token}'"
-done
-[[ -z "$miss" ]] && ok || bad "missing invariants:$miss"
-
-step "10. no wildcard tool grants in skills"
-bad_skills=""
-for f in "$ROOT"/skills/*/SKILL.md; do
-  grep -q '^allowed-tools:[[:space:]]*\*' "$f" && bad_skills="$bad_skills $(basename $(dirname "$f"))"
-done
-[[ -z "$bad_skills" ]] && ok || bad "wildcard:$bad_skills"
-
-printf "\n%s passed, %s failed\n" "$PASS" "$FAIL"
-[[ $FAIL -eq 0 ]] || exit 1

package/runtime/vendor/plugins/ruflo/ruflo-goals/skills/deep-research/SKILL.md

@@ -1,43 +0,0 @@
----
-name: deep-research
-description: Orchestrate multi-phase deep research with web search, memory retrieval, pattern matching, and synthesis into structured findings
-argument-hint: "<topic>"
-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 references

package/runtime/vendor/plugins/ruflo/ruflo-goals/skills/dossier-collect/SKILL.md

@@ -1,70 +0,0 @@
----
-name: dossier-collect
-description: 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
-argument-hint: "<seed> [--max-depth N] [--max-breadth N] [--sources s1,s2] [--budget-usd N] [--exact]"
-allowed-tools: mcp__claude-flow__memory_store mcp__claude-flow__memory_search mcp__claude-flow__memory_search_unified mcp__claude-flow__agentdb_pattern-search mcp__claude-flow__agentdb_pattern-store mcp__claude-flow__agentdb_hierarchical-recall mcp__claude-flow__embeddings_search mcp__claude-flow__hooks_intelligence_pattern-search mcp__claude-flow__hooks_intelligence_pattern-store mcp__claude-flow__hooks_intelligence_trajectory-start mcp__claude-flow__hooks_intelligence_trajectory-step mcp__claude-flow__hooks_intelligence_trajectory-end mcp__claude-flow__task_create Bash WebSearch WebFetch Read Write Grep Glob
----
-
-# Dossier Collect
-
-Recursive parallel investigation that builds a graph-structured dossier on a seed entity.
-
-## When to use
-
-You have a seed (a username, file, symbol, ADR-id, URL, or concept) and want to **expand outward** discovering every connected entity, with provenance per claim — rather than answering a specific question.
-
-For specific questions use `deep-research`. For multi-step plans use `goal-plan`.
-
-## Steps
-
-1. **Detect seed type** — classify as one of: `username` (handle), `file` (path), `symbol` (code identifier), `adr` (ADR-NNN), `url`, or `concept` (free text).
-2. **Pick sources** — match the source matrix to the seed type. Default: all applicable.
-3. **Start trajectory** — call `mcp__claude-flow__hooks_intelligence_trajectory-start` with task `dossier:<slug>`.
-4. **Round 0 fan-out** — issue ALL source queries in ONE message. Examples:
-   - For `username`: `WebSearch`, `WebFetch` on github.com/<user>, `mcp__claude-flow__memory_search_unified`
-   - For `adr`: `Read` ADR file, `Grep` references, `mcp__claude-flow__memory_search` namespace `adr`
-   - For `symbol`: `Grep`, `Glob`, `mcp__claude-flow__embeddings_search`
-5. **Extract entities** — from each hit, surface entities (people, repos, files, adrs, urls, terms). Lightweight regex + heuristics; no LLM extraction unless ambiguous.
-6. **De-dup** — drop entities already in the dossier. If `--exact` is unset, also drop entities whose embedding cosine similarity ≥ 0.92 to an existing node.
-7. **Round k recursion** — for each new entity (capped at `--max-breadth` per source), recurse to step 4 until depth ≥ `--max-depth` OR budget exhausted.
-8. **Aggregate** — build `{ nodes, edges }` graph. Each node carries `{ id, type, attrs, sources: [...] }`. Each edge carries `{ from, to, kind, source, confidence }`.
-9. **Render artifacts**:
-   - `<slug>.md` — executive summary, entity table, mermaid graph, source-provenance footnotes
-   - `<slug>.json` — machine-readable graph
-   - Default location: `v3/docs/examples/dossiers/<slug>/`
-10. **Persist** — `mcp__claude-flow__memory_store` namespace `dossier` key `<slug>`.
-11. **End trajectory** — `mcp__claude-flow__hooks_intelligence_trajectory-end` with success status.
-
-## Output schema (JSON)
-
-```json
-{
-  "seed": "ruvnet",
-  "seedType": "username",
-  "depth": 2,
-  "truncated": false,
-  "generatedAt": "ISO-8601",
-  "nodes": [
-    { "id": "ruvnet", "type": "username", "attrs": { "...": "..." }, "sources": ["WebSearch", "github.com"] }
-  ],
-  "edges": [
-    { "from": "ruvnet", "to": "ruflo", "kind": "owns", "source": "github.com", "confidence": "high" }
-  ],
-  "stats": { "nodesByType": {}, "sourcesUsed": [], "tokensSpent": 0 }
-}
-```
-
-## Budget discipline
-
-- If `--budget-usd` is set, track approximate cost via trajectory. On exhaustion: emit partial dossier with `truncated: true` and the entities still queued.
-- BFS expansion only — finish round *k* before round *k+1*.
-- Never silently truncate. Always mark and record what was skipped.
-
-## Examples
-
-```
-/ruflo-goals:dossier-collect ruvnet
-/ruflo-goals:dossier-collect ADR-097 --max-depth 1
-/ruflo-goals:dossier-collect "src/memory/hnsw.ts" --sources codebase,git,memory
-/ruflo-goals:dossier-collect "ruflo-goals" --max-breadth 5 --budget-usd 1
-```

package/runtime/vendor/plugins/ruflo/ruflo-goals/skills/goal-plan/SKILL.md

@@ -1,59 +0,0 @@
----
-name: goal-plan
-description: Create and execute Goal-Oriented Action Plans (GOAP) with precondition analysis, cost optimization, and adaptive replanning
-argument-hint: "<goal-description>"
-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 unavailable

package/runtime/vendor/plugins/ruflo/ruflo-goals/skills/horizon-track/SKILL.md

@@ -1,61 +0,0 @@
----
-name: horizon-track
-description: Track long-horizon objectives across multiple sessions with milestone checkpoints, progress persistence, and drift detection
-argument-hint: "<objective-name>"
-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 horizon

package/runtime/vendor/plugins/ruflo/ruflo-goals/skills/research-synthesize/SKILL.md

@@ -1,62 +0,0 @@
----
-name: research-synthesize
-description: Synthesize research findings from memory into structured reports with evidence grading, contradiction resolution, and actionable recommendations
-argument-hint: "<topic> [--format report|brief|table]"
-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]
-```

package/runtime/vendor/plugins/ruflo/ruflo-graph-intelligence/.claude-plugin/plugin.json

@@ -1,27 +0,0 @@
-{
-  "name": "ruflo-graph-intelligence",
-  "description": "RuFlo Graph Intelligence Engine — real-time relationship intelligence with complexity-aware execution. Single-entry personalized PageRank, streaming delta updates, witness-signed reasoning artifacts, federation-distributable PR vectors. Built on sublinear-time-solver@1.7.0.",
-  "version": "0.1.0-alpha.1",
-  "author": {
-    "name": "ruvnet",
-    "url": "https://github.com/ruvnet"
-  },
-  "homepage": "https://github.com/ruvnet/ruflo",
-  "license": "MIT",
-  "keywords": [
-    "ruflo",
-    "graph-intelligence",
-    "pagerank",
-    "sublinear",
-    "complexity-aware",
-    "personalized-pagerank",
-    "agent-substrate",
-    "signed-reasoning",
-    "federation",
-    "mcp",
-    "claude-flow",
-    "adr-123"
-  ],
-  "categories": ["intelligence", "graph", "memory", "substrate"],
-  "repository": "https://github.com/ruvnet/ruflo"
-}