feat: Agentic-Flow Intelligent Hook Service with Swarm Orchestration & Self-Learning

[ruvnet]

Summary

Create a native hook service for agentic-flow that provides intelligent agent routing, swarm-distributed processing, and continuous self-learning. This builds upon RuVector's hook capabilities (v0.1.48) while leveraging agentic-flow's advanced infrastructure for 50-100x performance improvement and runtime optimization.

Motivation

The current RuVector hooks system provides:

• Pre/post tool hooks with Q-learning patterns
• Git co-edit analysis
• Vector memory for context
• Agent routing recommendations

However, it has limitations:

• Latency: 500-2000ms per hook (process spawn overhead)
• Learning: Static Q-table (no continuous improvement)
• Scale: Single-process analysis
• Storage: Flat JSON file (not queryable)

Agentic-flow has infrastructure that can dramatically improve this:

• QuicCoordinator for swarm orchestration
• ReasoningBank with Judge/Distill/Retrieve/Consolidate algorithms
• LearningSystem with 9 RL algorithms
• AgentDB with causal memory graphs
• Native MCP server integration

Proposed Architecture

```
┌─────────────────────────────────────────────────────────────────────┐
│ AGENTIC-FLOW HOOK SERVICE │
├─────────────────────────────────────────────────────────────────────┤
│ ┌─────────────────────────────────────────────────────────────┐ │
│ │ MCP Interface Layer │ │
│ │ PreHook │ PostHook │ Route │ Metrics │ Explain │ Transfer │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │ │
│ ┌───────────────────────────▼─────────────────────────────────┐ │
│ │ Adaptive Swarm Coordinator │ │
│ │ ┌──────────┐ ┌──────────────┐ ┌────────────────────────┐ │ │
│ │ │ Topology │ │ Token Budget │ │ Graceful Degradation │ │ │
│ │ │ Selector │ │ Optimizer │ │ Handler │ │ │
│ │ └──────────┘ └──────────────┘ └────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │ │
│ ┌───────────────────────────▼─────────────────────────────────┐ │
│ │ Intelligence Core │ │
│ │ ┌────────────┐ ┌────────────┐ ┌────────────┐ ┌──────────┐ │ │
│ │ │ Reasoning │ │ Learning │ │ Reflexion │ │ Causal │ │ │
│ │ │ Bank │ │ System │ │ Memory │ │ Graph │ │ │
│ │ │ (Patterns) │ │ (9 RL) │ │ (Errors) │ │(Co-edits)│ │ │
│ │ └────────────┘ └────────────┘ └────────────┘ └──────────┘ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │ │
│ ┌───────────────────────────▼─────────────────────────────────┐ │
│ │ Learning Protection │ │
│ │ ┌────────────┐ ┌────────────┐ ┌────────────────────────┐ │ │
│ │ │ EWC Memory │ │ Incremental│ │ Transfer Learning │ │ │
│ │ │ Protection │ │ Pretrain │ │ (Cross-Project) │ │ │
│ │ └────────────┘ └────────────┘ └────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────┘ │
│ │ │
│ ┌───────────────────────────▼─────────────────────────────────┐ │
│ │ Observability Layer │ │
│ │ ┌────────────┐ ┌────────────┐ ┌────────────────────────┐ │ │
│ │ │ Metrics │ │ Explain- │ │ A/B Testing │ │ │
│ │ │ Dashboard │ │ ability │ │ Framework │ │ │
│ │ └────────────┘ └────────────┘ └────────────────────────┘ │ │
│ └─────────────────────────────────────────────────────────────┘ │
└─────────────────────────────────────────────────────────────────────┘
```

Implementation Plan

Phase 1: Native MCP Hook Tools (P0)

Goal: 50-100x latency reduction

• Create agentic-flow/src/hooks/ module
• Implement native MCP tools:
  • hook_pre_edit - Pre-edit context retrieval and agent routing
  • hook_post_edit - Outcome tracking and learning update
  • hook_pre_command - Command risk assessment
  • hook_post_command - Command outcome learning
  • hook_route - Intelligent agent selection
• Integrate with existing ReasoningBank retrieve/distill
• Add graceful degradation (4-level fallback)

Latency target: 5-50ms (vs 500-2000ms current)

Phase 2: Error Pattern Learning (P0)

Goal: Learn from failures, not just successes

• Integrate ReflexionMemory for error tracking
• Implement error pattern schema:
  ```typescript
  interface ErrorPattern {
  errorType: string;
  context: string;
  resolution: string;
  filePatterns: string[];
  agentSuccess: Record<string, number>;
  }
  ```
• Auto-extract error patterns from failed tool calls
• Route to agents with best error-fix track record

Phase 3: Swarm-Distributed Pretrain (P1)

Goal: 4-8x faster analysis

• Create SwarmPretrain class using QuicCoordinator
• Spawn specialized analysis agents in parallel:
  • code-analyzer - File structure analysis
  • researcher - Git history analysis
  • analyst - Pattern detection
  • optimizer - Embedding computation
• Store results in ReasoningBank (not JSON)
• Implement incremental pretrain (changed files only)

Phase 4: Intelligent Routing with SONA (P1)

Goal: Continuous learning, not static patterns

• Integrate SONA orchestrator for agent selection
• Connect to LearningSystem with configurable RL algorithm:
  • Q-Learning (default, simple)
  • Actor-Critic (balanced)
  • PPO (complex tasks)
  • Decision Transformer (sequential tasks)
• Implement feedback loop:
  ```
  Route → Execute → Judge → Update Policy → Route (improved)
  ```
• Add exploration/exploitation balance

Phase 5: Causal Co-Edit Graph (P1)

Goal: Transitive relationship discovery

• Migrate co-edit patterns to CausalMemoryGraph
• Enable transitive queries ("files 2 hops away")
• Add causal intervention queries ("what if I change X?")
• Integrate with pre-edit hook for file suggestions

Phase 6: Observability & Metrics (P1)

Goal: Visibility into learning effectiveness

• Create metrics collection system:
  ```typescript
  interface LearningMetrics {
  routingAccuracy: number;
  learningVelocity: number;
  patternUtilization: number;
  agentPerformance: Record<string, AgentMetrics>;
  }
  ```
• Add MCP tools: learning_dashboard, learning_health
• Implement A/B testing framework for algorithm comparison

Phase 7: Dynamic Agent Factory (P2)

Goal: Runtime agent creation, not static YAML

• Create AgentFactory class
• Generate agents from pretrain data + learned patterns
• Adaptive system prompts from successful interactions
• Swarm-coordinated agent pool management

Phase 8: Explainability (P2)

Goal: Transparent routing decisions

• Implement RoutingExplanation interface
• Add hook_explain MCP tool
• Show contributing factors with weights
• List alternatives with "why not" reasons

Phase 9: Token Optimization (P2)

Goal: Cost-aware agent selection

• Track token usage per agent
• Add token budget parameter to routing
• Score agents by effectiveness AND efficiency
• Implement cost-sensitive mode

Phase 10: Transfer Learning (P2)

Goal: Cross-project knowledge sharing

• Implement pattern transfer between projects
• Adapt patterns to target project stack
• Seed new projects with high-confidence patterns
• Support federated learning across user projects

Phase 11: Memory Protection (P3)

Goal: Prevent catastrophic forgetting

• Implement EWC (Elastic Weight Consolidation)
• Compute pattern importance weights
• Penalize updates that damage important patterns
• Add memory versioning for rollback

Phase 12: Cold Start Optimization (P3)

Goal: Smart bootstrap for new projects

• Detect project stack automatically
• Load pre-trained domain patterns
• Find and transfer from similar projects
• Quick pretrain for project-specific patterns

Performance Targets

Metric	Current (RuVector)	Target (Agentic-Flow)	Improvement
Hook latency	500-2000ms	5-50ms	50-100x
Pretrain time	30-60s	5-15s	4-8x
Pattern storage	JSON file	ReasoningBank	Queryable
Learning	Static	Continuous	Runtime
Agent routing	Pattern match	SONA + 9 RL	Adaptive
Co-edit queries	O(n) scan	Graph traversal	O(log n)

Files to Create/Modify

New Files

• agentic-flow/src/hooks/index.ts - Hook service entry point
• agentic-flow/src/hooks/HookOrchestrator.ts - Central coordinator
• agentic-flow/src/hooks/SwarmPretrain.ts - Distributed analysis
• agentic-flow/src/hooks/IntelligentRouter.ts - SONA-based routing
• agentic-flow/src/hooks/AgentFactory.ts - Dynamic agent generation
• agentic-flow/src/hooks/ErrorLearner.ts - Error pattern extraction
• agentic-flow/src/hooks/TransferLearner.ts - Cross-project learning
• agentic-flow/src/mcp/fastmcp/tools/hooks/*.ts - MCP tool definitions

Modified Files

• agentic-flow/src/mcp/fastmcp/index.ts - Register hook tools
• agentic-flow/src/reasoningbank/index.ts - Add hook-specific methods
• packages/agentdb/src/controllers/LearningSystem.ts - Hook integration

Integration with RuVector

The hook service should be usable standalone OR as a drop-in replacement for RuVector hooks:

```json
// .claude/settings.json - RuVector mode (current)
{
"hooks": {
"PreToolUse": [{
"matcher": "Edit|Write",
"hooks": [{
"type": "command",
"command": "npx ruvector hooks pre-edit "$TOOL_INPUT_file_path""
}]
}]
}
}

// .claude/settings.json - Agentic-Flow mode (new)
{
"hooks": {
"PreToolUse": [{
"matcher": "Edit|Write",
"hooks": [{
"type": "mcp",
"server": "agentic-flow",
"tool": "hook_pre_edit",
"args": { "file": "$TOOL_INPUT_file_path" }
}]
}]
}
}
```

Success Criteria

1. Latency: Pre-edit hook completes in <50ms (p95)
2. Learning: Routing accuracy improves >10% over 100 interactions
3. Errors: Error patterns reduce repeat failures by >20%
4. Pretrain: Full repo analysis in <15s for 10k files
5. Stability: Graceful degradation maintains functionality during partial failures

Related

• RuVector v0.1.48: hooks build-agents, hooks pretrain
• ReasoningBank: Judge/Distill/Retrieve/Consolidate algorithms
• LearningSystem: 9 RL algorithms
• QuicCoordinator: Swarm orchestration
• AgentDB: CausalMemoryGraph, ReflexionMemory

---

/cc @ruvnet

[ruvnet]

MCP Tools Implementation Details

Current State

agentic-flow/src/mcp/fastmcp/tools/
├── agent/
│   ├── add-agent.ts
│   ├── add-command.ts
│   ├── execute.ts
│   ├── list.ts
│   └── parallel.ts
└── swarm/
    ├── init.ts
    ├── orchestrate.ts
    └── spawn.ts

New Tools Required

agentic-flow/src/mcp/fastmcp/tools/
└── hooks/                          # NEW DIRECTORY
    ├── index.ts                    # Tool registration
    ├── pre-edit.ts                 # hook_pre_edit
    ├── post-edit.ts                # hook_post_edit
    ├── pre-command.ts              # hook_pre_command
    ├── post-command.ts             # hook_post_command
    ├── route.ts                    # hook_route
    ├── pretrain.ts                 # hook_pretrain
    ├── build-agents.ts             # hook_build_agents
    ├── metrics.ts                  # hook_metrics
    ├── explain.ts                  # hook_explain
    └── transfer.ts                 # hook_transfer

Tool Specifications

Core Hooks (P0)

hook_pre_edit - Context retrieval before file edit

{
  name: 'hook_pre_edit',
  description: 'Pre-edit intelligence: retrieve context, suggest agent, find related files',
  parameters: z.object({
    filePath: z.string().describe('Path to file being edited'),
    task: z.string().optional().describe('Optional task description')
  }),
  execute: async ({ filePath, task }) => {
    const memories = await reasoningBank.retrieve(filePath, { k: 3 });
    const agent = await sonaRouter.selectAgent(filePath, memories);
    const coEdits = await causalGraph.getRelated(`file:${filePath}`);
    return { suggestedAgent: agent, memories, relatedFiles: coEdits };
  }
}
// Latency target: <20ms

hook_post_edit - Learn from edit outcome

{
  name: 'hook_post_edit',
  description: 'Post-edit learning: record outcome, update patterns',
  parameters: z.object({
    filePath: z.string(),
    success: z.boolean(),
    duration: z.number().optional(),
    agent: z.string().optional()
  }),
  execute: async ({ filePath, success, duration, agent }) => {
    // Judge the outcome
    const judgment = await reasoningBank.judge({ filePath, success });
    
    // Update Q-values
    await learningSystem.recordFeedback({
      state: `edit:${path.extname(filePath)}`,
      action: agent,
      reward: success ? 1.0 : -0.5,
      success
    });
    
    // Distill pattern if successful
    if (success) {
      await reasoningBank.distill({ filePath, outcome: 'success' });
    }
    
    return { patternsUpdated: true, judgment };
  }
}
// Latency target: <50ms (async learning OK)

hook_pre_command - Command risk assessment

{
  name: 'hook_pre_command',
  description: 'Pre-command intelligence: assess risk, suggest alternatives',
  parameters: z.object({
    command: z.string()
  }),
  execute: async ({ command }) => {
    const riskPatterns = await reasoningBank.retrieve('command-risks');
    const riskLevel = assessRisk(command, riskPatterns);
    const suggestions = riskLevel > 0.7 
      ? await getSaferAlternatives(command) 
      : [];
    return { riskLevel, suggestions, approved: riskLevel < 0.9 };
  }
}

hook_post_command - Command outcome learning

{
  name: 'hook_post_command',
  description: 'Post-command learning: record outcome, learn from errors',
  parameters: z.object({
    command: z.string(),
    exitCode: z.number(),
    stderr: z.string().optional()
  }),
  execute: async ({ command, exitCode, stderr }) => {
    const success = exitCode === 0;
    
    // Learn from failures
    if (!success && stderr) {
      await reflexionMemory.storeFailure({
        command,
        error: stderr,
        exitCode
      });
    }
    
    await learningSystem.recordFeedback({
      state: `command:${command.split(' ')[0]}`,
      action: 'execute',
      reward: success ? 1.0 : -0.3,
      success
    });
    
    return { learned: true };
  }
}

Routing Tools (P1)

hook_route - Intelligent agent selection

{
  name: 'hook_route',
  description: 'Route task to optimal agent using SONA + learned patterns',
  parameters: z.object({
    task: z.string(),
    context: z.object({
      file: z.string().optional(),
      recentFiles: z.array(z.string()).optional(),
      errorContext: z.string().optional()
    }).optional(),
    explain: z.boolean().default(false)
  }),
  execute: async ({ task, context, explain }) => {
    const memories = await reasoningBank.retrieve(task, { k: 5 });
    const decision = await sonaOrchestrator.route({ task, context, memories });
    
    if (explain) {
      return {
        agent: decision.agent,
        confidence: decision.confidence,
        reasons: decision.factors,
        alternatives: decision.alternatives
      };
    }
    
    return { agent: decision.agent, confidence: decision.confidence };
  }
}

hook_explain - Explain routing decision

{
  name: 'hook_explain',
  description: 'Explain why an agent was selected for a task',
  parameters: z.object({
    task: z.string(),
    agent: z.string().optional()
  }),
  execute: async ({ task, agent }) => {
    const decision = await sonaOrchestrator.route({ task, explain: true });
    
    return {
      selectedAgent: decision.agent,
      confidence: decision.confidence,
      reasons: decision.factors.map(f => ({
        factor: f.name,
        weight: f.weight,
        evidence: f.evidence
      })),
      alternatives: decision.alternatives.map(a => ({
        agent: a.agent,
        score: a.score,
        whyNot: a.disqualifyReason
      }))
    };
  }
}

Analysis Tools (P1)

hook_pretrain - Swarm-distributed repository analysis

{
  name: 'hook_pretrain',
  description: 'Analyze repository with swarm for intelligent patterns',
  parameters: z.object({
    depth: z.number().default(100).describe('Git history depth'),
    incremental: z.boolean().default(true).describe('Only analyze changes'),
    workers: z.number().default(4).describe('Parallel analysis agents')
  }),
  execute: async ({ depth, incremental, workers }) => {
    const swarm = await initSwarm({ topology: 'mesh', maxAgents: workers });
    
    // Spawn specialized analyzers
    const results = await Promise.all([
      orchestrate({ task: 'analyze-file-structure', agent: 'code-analyzer' }),
      orchestrate({ task: 'analyze-git-history', agent: 'researcher' }),
      orchestrate({ task: 'detect-patterns', agent: 'analyst' }),
      orchestrate({ task: 'compute-embeddings', agent: 'optimizer' })
    ]);
    
    // Store in ReasoningBank
    await reasoningBank.distill({
      trajectory: results,
      domain: 'pretrain'
    });
    
    return {
      filesAnalyzed: results.files,
      patternsCreated: results.patterns,
      memoriesStored: results.memories,
      coEditsFound: results.coEdits
    };
  }
}

hook_build_agents - Generate optimized agent configurations

{
  name: 'hook_build_agents',
  description: 'Generate agent configurations from pretrain data',
  parameters: z.object({
    focus: z.enum(['quality', 'speed', 'security', 'testing', 'fullstack']),
    output: z.string().default('.claude/agents'),
    includePrompts: z.boolean().default(true)
  }),
  execute: async ({ focus, output, includePrompts }) => {
    const patterns = await reasoningBank.retrieve('pretrain-patterns');
    const performance = await learningSystem.getAgentMetrics();
    
    const agents = await agentFactory.generate({
      focus,
      patterns,
      performance,
      includePrompts
    });
    
    // Save to output directory
    await saveAgentConfigs(agents, output);
    
    return { agents: agents.map(a => a.name), saved: output };
  }
}

Observability Tools (P1)

hook_metrics - Learning dashboard

{
  name: 'hook_metrics',
  description: 'Get learning metrics and performance dashboard',
  parameters: z.object({
    timeframe: z.enum(['1h', '24h', '7d', '30d']).default('24h'),
    detailed: z.boolean().default(false)
  }),
  execute: async ({ timeframe, detailed }) => {
    const metrics = await learningSystem.getMetrics(timeframe);
    
    return {
      routingAccuracy: metrics.accuracy,
      learningVelocity: metrics.velocityTrend,
      patternUtilization: metrics.patternsUsed / metrics.patternsTotal,
      agentPerformance: detailed ? metrics.byAgent : undefined,
      topPatterns: metrics.topPatterns.slice(0, 5),
      recentImprovements: metrics.improvements
    };
  }
}

Transfer Tools (P2)

hook_transfer - Cross-project pattern transfer

{
  name: 'hook_transfer',
  description: 'Transfer learned patterns from another project',
  parameters: z.object({
    sourceProject: z.string(),
    minConfidence: z.number().default(0.7),
    maxPatterns: z.number().default(50)
  }),
  execute: async ({ sourceProject, minConfidence, maxPatterns }) => {
    const patterns = await reasoningBank.retrieve('*', {
      project: sourceProject,
      minConfidence,
      limit: maxPatterns
    });
    
    const targetStack = await detectProjectStack();
    const adapted = await sonaOrchestrator.adaptPatterns(patterns, targetStack);
    
    await reasoningBank.seedPatterns(adapted, { confidence: 0.5 });
    
    return {
      transferred: patterns.length,
      adapted: adapted.length,
      targetStack
    };
  }
}

Integration Points

1. ReasoningBank - Pattern storage and retrieval
2. LearningSystem - Q-learning and RL algorithms
3. CausalMemoryGraph - Co-edit relationships
4. ReflexionMemory - Error pattern learning
5. SOnaOrchestrator - Adaptive agent routing
6. QuicCoordinator - Swarm distribution

Tool Registration

// agentic-flow/src/mcp/fastmcp/tools/hooks/index.ts
import { preEdit } from './pre-edit';
import { postEdit } from './post-edit';
import { preCommand } from './pre-command';
import { postCommand } from './post-command';
import { route } from './route';
import { pretrain } from './pretrain';
import { buildAgents } from './build-agents';
import { metrics } from './metrics';
import { explain } from './explain';
import { transfer } from './transfer';

export const hookTools = [
  preEdit,
  postEdit,
  preCommand,
  postCommand,
  route,
  pretrain,
  buildAgents,
  metrics,
  explain,
  transfer
];

Checklist

• Create agentic-flow/src/mcp/fastmcp/tools/hooks/ directory
• Implement hook_pre_edit tool
• Implement hook_post_edit tool
• Implement hook_pre_command tool
• Implement hook_post_command tool
• Implement hook_route tool
• Implement hook_pretrain tool
• Implement hook_build_agents tool
• Implement hook_metrics tool
• Implement hook_explain tool
• Implement hook_transfer tool
• Register tools in FastMCP server
• Add integration tests
• Update documentation

[ruvnet]

✅ Implementation Complete - Phase 1

Files Created

agentic-flow/src/mcp/fastmcp/tools/hooks/
├── index.ts          (1.4 KB) - Tool exports and registration
├── shared.ts         (5.2 KB) - Shared utilities, agent mapping, intelligence storage
├── pre-edit.ts       (3.1 KB) - Pre-edit context retrieval
├── post-edit.ts      (3.8 KB) - Post-edit learning with Q-updates
├── pre-command.ts    (2.5 KB) - Command risk assessment
├── post-command.ts   (3.5 KB) - Command outcome learning
├── route.ts          (7.8 KB) - Intelligent agent routing with SONA-style selection
├── explain.ts        (6.6 KB) - Routing decision explainability
├── pretrain.ts       (7.3 KB) - Repository analysis and pattern bootstrapping
├── build-agents.ts   (11.3 KB) - Dynamic agent configuration generation
├── metrics.ts        (5.3 KB) - Learning dashboard and metrics
├── transfer.ts       (6.1 KB) - Cross-project pattern transfer
└── benchmark.ts      (4.6 KB) - Performance benchmarking suite

servers/
└── hooks-server.ts   - Dedicated FastMCP server for hooks

tests/hooks/
└── hook-tools.test.ts - Integration tests with performance assertions

Test Results

🧪 Quick Hook Tools Validation
============================================================

📁 Testing agent routing...
✅ TypeScript file -> typescript-developer
✅ Rust file -> rust-developer  
✅ Test file -> test-engineer
✅ Python file -> python-developer
✅ SQL file -> database-specialist

🔒 Testing command risk assessment...
✅ Safe command (npm test)
✅ Dangerous command (rm -rf /)
✅ Sudo command
✅ chmod 777

💾 Testing intelligence storage...
✅ Patterns saved correctly
✅ Metrics saved correctly

⚡ Testing basic performance...
✅ Agent routing + risk check avg < 1ms

📊 Results: 12/12 tests passed
🎉 All tests passed!

Implemented Features

Tool	Status	Description
hook_pre_edit	✅	Context retrieval, agent suggestion, related files
hook_post_edit	✅	Q-learning updates, pattern distillation
hook_pre_command	✅	Risk assessment with 4-level classification
hook_post_command	✅	Error pattern learning, outcome tracking
hook_route	✅	SONA-style routing with exploration/exploitation
hook_explain	✅	Full transparency on routing decisions
hook_pretrain	✅	4-phase repository analysis
hook_build_agents	✅	5 focus modes, YAML/JSON output
hook_metrics	✅	Learning dashboard with health status
hook_transfer	✅	Cross-project pattern transfer

Key Optimizations Applied

1. Latency: All core operations < 20ms (no process spawn)
2. Priority: Test files detected before extension matching
3. Learning: Q-learning with configurable rate (0.1 default)
4. Storage: JSON-based with intelligent defaults
5. Risk Assessment: Multi-level (safe/caution/dangerous/blocked)
6. Exploration: Epsilon-greedy with 10% exploration rate

Next Steps (P1-P3)

• Integration with ReasoningBank for richer semantic memory
• Swarm-distributed pretrain for large repositories
• EWC memory protection to prevent catastrophic forgetting
• GNN-enhanced embeddings from RuVectorLearning
• Full Vitest test suite execution

---

Implementation by @claude-opus-4.5

[ruvnet]

✅ CLI Implementation Complete

CLI Hooks Commands Added

# Full CLI interface now available:
agentic-flow hooks init              # Initialize hooks in project
agentic-flow hooks pretrain          # Analyze repo for patterns  
agentic-flow hooks build-agents      # Generate optimized agents
agentic-flow hooks route <task>      # Route task to best agent
agentic-flow hooks pre-edit <file>   # Get context before editing
agentic-flow hooks post-edit <file>  # Record edit outcome
agentic-flow hooks pre-command <cmd> # Risk assessment
agentic-flow hooks post-command <cmd> # Command outcome learning
agentic-flow hooks metrics           # View learning dashboard
agentic-flow hooks explain <task>    # Explain routing decision
agentic-flow hooks transfer <proj>   # Transfer patterns

Files Created/Modified

New CLI Module:

• agentic-flow/src/cli/commands/hooks.ts (19.8KB) - Full commander.js CLI

Modified:

• agentic-flow/src/cli-proxy.ts - Added hooks mode handler
• agentic-flow/src/utils/cli.ts - Added hooks mode parsing

Test Results

✅ MCP Tools: 10/10 implemented
✅ Vitest Suite: 27/27 passed  
✅ Benchmark: All latency targets met
✅ CLI Commands: All 11 subcommands working

Example Usage

$ agentic-flow hooks route "Write unit tests for authentication"

🎯 Recommended Agent: test-engineer
📊 Confidence: 50.0%
⏱️  Latency: 0ms

Next Steps (P1-P2)

• Integrate with AgentDB's 9 RL algorithms (Q-Learning, SARSA, Actor-Critic, PPO, etc.)
• Connect to ReasoningBank for richer semantic memory
• Add algorithm selection: --algorithm sarsa / --algorithm ppo

---

Implementation by @claude-opus-4.5