monomind 1.6.0 → 1.6.1

package/.claude/skills/v3-ddd-architecture/SKILL.md

@@ -1,451 +0,0 @@
----
-name: "v1 DDD Architecture"
-description: "Domain-Driven Design architecture for monomind v1. Implements modular, bounded context architecture with clean separation of concerns and microkernel pattern."
----
-
-# DDD Architecture
-
-## What This Skill Does
-
-Designs and implements Domain-Driven Design (DDD) architecture for monomind v1, decomposing god objects into bounded contexts, implementing clean architecture patterns, and enabling modular, testable code structure.
-
-## Quick Start
-
-```bash
-# Initialize DDD architecture analysis
-Task("Architecture analysis", "Analyze current architecture and design DDD boundaries", "core-architect")
-
-# Domain modeling (parallel)
-Task("Domain decomposition", "Break down orchestrator god object into domains", "core-architect")
-Task("Context mapping", "Map bounded contexts and relationships", "core-architect")
-Task("Interface design", "Design clean domain interfaces", "core-architect")
-```
-
-## DDD Implementation Strategy
-
-### Current Architecture Analysis
-
-```
-├── PROBLEMATIC: core/orchestrator.ts (1,440 lines - GOD OBJECT)
-│   ├── Task management responsibilities
-│   ├── Session management responsibilities
-│   ├── Health monitoring responsibilities
-│   ├── Lifecycle management responsibilities
-│   └── Event coordination responsibilities
-│
-└── TARGET: Modular DDD Architecture
-    ├── core/domains/
-    │   ├── task-management/
-    │   ├── session-management/
-    │   ├── health-monitoring/
-    │   ├── lifecycle-management/
-    │   └── event-coordination/
-    └── core/shared/
-        ├── interfaces/
-        ├── value-objects/
-        └── domain-events/
-```
-
-### Domain Boundaries
-
-#### 1. Task Management Domain
-
-```typescript
-// core/domains/task-management/
-interface TaskManagementDomain {
-  // Entities
-  Task: TaskEntity;
-  TaskQueue: TaskQueueEntity;
-
-  // Value Objects
-  TaskId: TaskIdVO;
-  TaskStatus: TaskStatusVO;
-  Priority: PriorityVO;
-
-  // Services
-  TaskScheduler: TaskSchedulingService;
-  TaskValidator: TaskValidationService;
-
-  // Repository
-  TaskRepository: ITaskRepository;
-}
-```
-
-#### 2. Session Management Domain
-
-```typescript
-// core/domains/session-management/
-interface SessionManagementDomain {
-  // Entities
-  Session: SessionEntity;
-  SessionState: SessionStateEntity;
-
-  // Value Objects
-  SessionId: SessionIdVO;
-  SessionStatus: SessionStatusVO;
-
-  // Services
-  SessionLifecycle: SessionLifecycleService;
-  SessionPersistence: SessionPersistenceService;
-
-  // Repository
-  SessionRepository: ISessionRepository;
-}
-```
-
-#### 3. Health Monitoring Domain
-
-```typescript
-// core/domains/health-monitoring/
-interface HealthMonitoringDomain {
-  // Entities
-  HealthCheck: HealthCheckEntity;
-  Metric: MetricEntity;
-
-  // Value Objects
-  HealthStatus: HealthStatusVO;
-  Threshold: ThresholdVO;
-
-  // Services
-  HealthCollector: HealthCollectionService;
-  AlertManager: AlertManagementService;
-
-  // Repository
-  MetricsRepository: IMetricsRepository;
-}
-```
-
-## Microkernel Architecture Pattern
-
-### Core Kernel
-
-```typescript
-// core/kernel/monomind-kernel.ts
-export class MonomindKernel {
-  private domains: Map<string, Domain> = new Map();
-  private eventBus: DomainEventBus;
-  private dependencyContainer: Container;
-
-  async initialize(): Promise<void> {
-    // Load core domains
-    await this.loadDomain("task-management", new TaskManagementDomain());
-    await this.loadDomain("session-management", new SessionManagementDomain());
-    await this.loadDomain("health-monitoring", new HealthMonitoringDomain());
-
-    // Wire up domain events
-    this.setupDomainEventHandlers();
-  }
-
-  async loadDomain(name: string, domain: Domain): Promise<void> {
-    await domain.initialize(this.dependencyContainer);
-    this.domains.set(name, domain);
-  }
-
-  getDomain<T extends Domain>(name: string): T {
-    const domain = this.domains.get(name);
-    if (!domain) {
-      throw new DomainNotLoadedError(name);
-    }
-    return domain as T;
-  }
-}
-```
-
-### Plugin Architecture
-
-```typescript
-// core/plugins/
-interface DomainPlugin {
-  name: string;
-  version: string;
-  dependencies: string[];
-
-  initialize(kernel: MonomindKernel): Promise<void>;
-  shutdown(): Promise<void>;
-}
-
-// Example: Swarm Coordination Plugin
-export class SwarmCoordinationPlugin implements DomainPlugin {
-  name = "swarm-coordination";
-  version = "3.0.0";
-  dependencies = ["task-management", "session-management"];
-
-  async initialize(kernel: MonomindKernel): Promise<void> {
-    const taskDomain =
-      kernel.getDomain<TaskManagementDomain>("task-management");
-    const sessionDomain =
-      kernel.getDomain<SessionManagementDomain>("session-management");
-
-    // Register swarm coordination services
-    this.swarmCoordinator = new UnifiedSwarmCoordinator(
-      taskDomain,
-      sessionDomain,
-    );
-    kernel.registerService("swarm-coordinator", this.swarmCoordinator);
-  }
-}
-```
-
-## Domain Events & Integration
-
-### Event-Driven Communication
-
-```typescript
-// core/shared/domain-events/
-abstract class DomainEvent {
-  public readonly eventId: string;
-  public readonly aggregateId: string;
-  public readonly occurredOn: Date;
-  public readonly eventVersion: number;
-
-  constructor(aggregateId: string) {
-    this.eventId = crypto.randomUUID();
-    this.aggregateId = aggregateId;
-    this.occurredOn = new Date();
-    this.eventVersion = 1;
-  }
-}
-
-// Task domain events
-export class TaskAssignedEvent extends DomainEvent {
-  constructor(
-    taskId: string,
-    public readonly agentId: string,
-    public readonly priority: Priority,
-  ) {
-    super(taskId);
-  }
-}
-
-export class TaskCompletedEvent extends DomainEvent {
-  constructor(
-    taskId: string,
-    public readonly result: TaskResult,
-    public readonly duration: number,
-  ) {
-    super(taskId);
-  }
-}
-
-// Event handlers
-@EventHandler(TaskCompletedEvent)
-export class TaskCompletedHandler {
-  constructor(
-    private metricsRepository: IMetricsRepository,
-    private sessionService: SessionLifecycleService,
-  ) {}
-
-  async handle(event: TaskCompletedEvent): Promise<void> {
-    // Update metrics
-    await this.metricsRepository.recordTaskCompletion(
-      event.aggregateId,
-      event.duration,
-    );
-
-    // Update session state
-    await this.sessionService.markTaskCompleted(
-      event.aggregateId,
-      event.result,
-    );
-  }
-}
-```
-
-## Clean Architecture Layers
-
-```typescript
-// Architecture layers
-┌─────────────────────────────────────────┐
-│              Presentation               │  ← CLI, API, UI
-├─────────────────────────────────────────┤
-│              Application                │  ← Use Cases, Commands
-├─────────────────────────────────────────┤
-│               Domain                    │  ← Entities, Services, Events
-├─────────────────────────────────────────┤
-│            Infrastructure               │  ← DB, MCP, External APIs
-└─────────────────────────────────────────┘
-
-// Dependency direction: Outside → Inside
-// Domain layer has NO external dependencies
-```
-
-### Application Layer (Use Cases)
-
-```typescript
-// core/application/use-cases/
-export class AssignTaskUseCase {
-  constructor(
-    private taskRepository: ITaskRepository,
-    private agentRepository: IAgentRepository,
-    private eventBus: DomainEventBus,
-  ) {}
-
-  async execute(command: AssignTaskCommand): Promise<TaskResult> {
-    // 1. Validate command
-    await this.validateCommand(command);
-
-    // 2. Load aggregates
-    const task = await this.taskRepository.findById(command.taskId);
-    const agent = await this.agentRepository.findById(command.agentId);
-
-    // 3. Business logic (in domain)
-    task.assignTo(agent);
-
-    // 4. Persist changes
-    await this.taskRepository.save(task);
-
-    // 5. Publish domain events
-    task
-      .getUncommittedEvents()
-      .forEach((event) => this.eventBus.publish(event));
-
-    // 6. Return result
-    return TaskResult.success(task);
-  }
-}
-```
-
-## Module Configuration
-
-### Bounded Context Modules
-
-```typescript
-// core/domains/task-management/module.ts
-export const taskManagementModule = {
-  name: "task-management",
-
-  entities: [TaskEntity, TaskQueueEntity],
-
-  valueObjects: [TaskIdVO, TaskStatusVO, PriorityVO],
-
-  services: [TaskSchedulingService, TaskValidationService],
-
-  repositories: [{ provide: ITaskRepository, useClass: SqliteTaskRepository }],
-
-  eventHandlers: [TaskAssignedHandler, TaskCompletedHandler],
-};
-```
-
-## Migration Strategy
-
-### Phase 1: Extract Domain Services
-
-```typescript
-// Extract services from orchestrator.ts
-const extractionPlan = {
-  week1: [
-    "TaskManager → task-management domain",
-    "SessionManager → session-management domain",
-  ],
-  week2: [
-    "HealthMonitor → health-monitoring domain",
-    "LifecycleManager → lifecycle-management domain",
-  ],
-  week3: [
-    "EventCoordinator → event-coordination domain",
-    "Wire up domain events",
-  ],
-};
-```
-
-### Phase 2: Implement Clean Interfaces
-
-```typescript
-// Clean separation with dependency injection
-export class TaskController {
-  constructor(
-    @Inject("AssignTaskUseCase") private assignTask: AssignTaskUseCase,
-    @Inject("CompleteTaskUseCase") private completeTask: CompleteTaskUseCase,
-  ) {}
-
-  async assign(request: AssignTaskRequest): Promise<TaskResponse> {
-    const command = AssignTaskCommand.fromRequest(request);
-    const result = await this.assignTask.execute(command);
-    return TaskResponse.fromResult(result);
-  }
-}
-```
-
-### Phase 3: Plugin System
-
-```typescript
-// Enable plugin-based extensions
-const pluginSystem = {
-  core: ["task-management", "session-management", "health-monitoring"],
-  optional: [
-    "swarm-coordination",
-    "learning-integration",
-    "performance-monitoring",
-  ],
-};
-```
-
-## Testing Strategy
-
-### Domain Testing (London School TDD)
-
-```typescript
-// Pure domain logic testing
-describe("Task Entity", () => {
-  let task: TaskEntity;
-  let mockAgent: jest.Mocked<AgentEntity>;
-
-  beforeEach(() => {
-    task = new TaskEntity(TaskId.create(), "Test task");
-    mockAgent = createMock<AgentEntity>();
-  });
-
-  it("should assign to agent when valid", () => {
-    mockAgent.canAcceptTask.mockReturnValue(true);
-
-    task.assignTo(mockAgent);
-
-    expect(task.assignedAgent).toBe(mockAgent);
-    expect(task.status.value).toBe("assigned");
-  });
-
-  it("should emit TaskAssignedEvent when assigned", () => {
-    mockAgent.canAcceptTask.mockReturnValue(true);
-
-    task.assignTo(mockAgent);
-
-    const events = task.getUncommittedEvents();
-    expect(events).toHaveLength(1);
-    expect(events[0]).toBeInstanceOf(TaskAssignedEvent);
-  });
-});
-```
-
-## Success Metrics
-
-- [ ] **God Object Elimination**: orchestrator.ts (1,440 lines) → 5 focused domains (<300 lines each)
-- [ ] **Bounded Context Isolation**: 100% domain independence
-- [ ] **Plugin Architecture**: Core + optional modules loading
-- [ ] **Clean Architecture**: Dependency inversion maintained
-- [ ] **Event-Driven Communication**: Loose coupling between domains
-- [ ] **Test Coverage**: >90% domain logic coverage
-
-## Related v1 Skills
-
-- `v1-core-implementation` - Implementation of DDD domains
-- `v1-memory-unification` - AgentDB integration within bounded contexts
-- `v1-swarm-coordination` - Swarm coordination as domain plugin
-- `v1-performance-optimization` - Performance optimization across domains
-
-## Usage Examples
-
-### Complete Domain Extraction
-
-```bash
-# Full DDD architecture implementation
-Task("DDD architecture implementation",
-     "Extract orchestrator into DDD domains with clean architecture",
-     "core-architect")
-```
-
-### Plugin Development
-
-```bash
-# Create domain plugin
-npm run create:plugin -- --name swarm-coordination --template domain
-```

package/.claude/skills/v3-integration-deep/SKILL.md

@@ -1,258 +0,0 @@
----
-name: "v1 Deep Integration"
-description: "Deep agentic-flow@alpha integration implementing ADR-001. Eliminates 10,000+ duplicate lines by building monomind as specialized extension rather than parallel implementation."
----
-
-# Deep Integration
-
-## What This Skill Does
-
-Transforms monomind from parallel implementation to specialized extension of agentic-flow@alpha, eliminating massive code duplication while achieving performance improvements and feature parity.
-
-## Quick Start
-
-```bash
-# Initialize deep integration
-Task("Integration architecture", "Design agentic-flow@alpha adapter layer", "v1-integration-architect")
-
-# Feature integration (parallel)
-Task("SONA integration", "Integrate 5 SONA learning modes", "v1-integration-architect")
-Task("Flash Attention", "Implement 2.49x-7.47x speedup", "v1-integration-architect")
-Task("AgentDB coordination", "Setup 150x-12,500x search", "v1-integration-architect")
-```
-
-## Code Deduplication Strategy
-
-### Current Overlap → Integration
-
-```
-┌─────────────────────────────────────────┐
-│  monomind          agentic-flow      │
-├─────────────────────────────────────────┤
-│ SwarmCoordinator  →   Swarm System      │ 80% overlap (eliminate)
-│ AgentManager      →   Agent Lifecycle   │ 70% overlap (eliminate)
-│ TaskScheduler     →   Task Execution    │ 60% overlap (eliminate)
-│ SessionManager    →   Session Mgmt      │ 50% overlap (eliminate)
-└─────────────────────────────────────────┘
-
-TARGET: <5,000 lines (vs 15,000+ currently)
-```
-
-## agentic-flow@alpha Feature Integration
-
-### SONA Learning Modes
-
-```typescript
-class SONAIntegration {
-  async initializeMode(mode: SONAMode): Promise<void> {
-    switch (mode) {
-      case "real-time": // ~0.05ms adaptation
-      case "balanced": // general purpose
-      case "research": // deep exploration
-      case "edge": // resource-constrained
-      case "batch": // high-throughput
-    }
-    await this.agenticFlow.sona.setMode(mode);
-  }
-}
-```
-
-### Flash Attention Integration
-
-```typescript
-class FlashAttentionIntegration {
-  async optimizeAttention(): Promise<AttentionResult> {
-    return this.agenticFlow.attention.flashAttention({
-      speedupTarget: "2.49x-7.47x",
-      memoryReduction: "50-75%",
-      mechanisms: ["multi-head", "linear", "local", "global"],
-    });
-  }
-}
-```
-
-### AgentDB Coordination
-
-```typescript
-class AgentDBIntegration {
-  async setupCrossAgentMemory(): Promise<void> {
-    await this.agentdb.enableCrossAgentSharing({
-      indexType: "HNSW",
-      speedupTarget: "150x-12500x",
-      dimensions: 1536,
-    });
-  }
-}
-```
-
-### MCP Tools Integration
-
-```typescript
-class MCPToolsIntegration {
-  async integrateBuiltinTools(): Promise<void> {
-    // Leverage 213 pre-built tools
-    const tools = await this.agenticFlow.mcp.getAvailableTools();
-    await this.registerMonomindSpecificTools(tools);
-
-    // Use 19 hook types
-    const hookTypes = await this.agenticFlow.hooks.getTypes();
-    await this.configureMonomindHooks(hookTypes);
-  }
-}
-```
-
-## Migration Implementation
-
-### Phase 1: Adapter Layer
-
-```typescript
-import { Agent as AgenticFlowAgent } from "agentic-flow@alpha";
-
-export class MonomindAgent extends AgenticFlowAgent {
-  async handleMonomindTask(task: ClaudeTask): Promise<TaskResult> {
-    return this.executeWithSONA(task);
-  }
-
-  // Backward compatibility
-  async legacyCompatibilityLayer(oldAPI: any): Promise<any> {
-    return this.adaptToNewAPI(oldAPI);
-  }
-}
-```
-
-### Phase 2: System Migration
-
-```typescript
-class SystemMigration {
-  async migrateSwarmCoordination(): Promise<void> {
-    // Replace SwarmCoordinator (800+ lines) with agentic-flow Swarm
-    const swarmConfig = await this.extractSwarmConfig();
-    await this.agenticFlow.swarm.initialize(swarmConfig);
-  }
-
-  async migrateAgentManagement(): Promise<void> {
-    // Replace AgentManager (1,736+ lines) with agentic-flow lifecycle
-    const agents = await this.extractActiveAgents();
-    for (const agent of agents) {
-      await this.agenticFlow.agent.create(agent);
-    }
-  }
-
-  async migrateTaskExecution(): Promise<void> {
-    // Replace TaskScheduler with agentic-flow task graph
-    const tasks = await this.extractTasks();
-    await this.agenticFlow.task.executeGraph(this.buildTaskGraph(tasks));
-  }
-}
-```
-
-### Phase 3: Cleanup
-
-```typescript
-class CodeCleanup {
-  async removeDeprecatedCode(): Promise<void> {
-    // Remove massive duplicate implementations
-    await this.removeFile("src/core/SwarmCoordinator.ts"); // 800+ lines
-    await this.removeFile("src/agents/AgentManager.ts"); // 1,736+ lines
-    await this.removeFile("src/task/TaskScheduler.ts"); // 500+ lines
-
-    // Total reduction: 10,000+ → <5,000 lines
-  }
-}
-```
-
-## RL Algorithm Integration
-
-```typescript
-class RLIntegration {
-  algorithms = [
-    "PPO",
-    "DQN",
-    "A2C",
-    "MCTS",
-    "Q-Learning",
-    "SARSA",
-    "Actor-Critic",
-    "Decision-Transformer",
-  ];
-
-  async optimizeAgentBehavior(): Promise<void> {
-    for (const algorithm of this.algorithms) {
-      await this.agenticFlow.rl.train(algorithm, {
-        episodes: 1000,
-        rewardFunction: this.monomindRewardFunction,
-      });
-    }
-  }
-}
-```
-
-## Performance Integration
-
-### Flash Attention Targets
-
-```typescript
-const attentionBenchmark = {
-  baseline: "current attention mechanism",
-  target: "2.49x-7.47x improvement",
-  memoryReduction: "50-75%",
-  implementation: "agentic-flow@alpha Flash Attention",
-};
-```
-
-### AgentDB Search Performance
-
-```typescript
-const searchBenchmark = {
-  baseline: "linear search in current systems",
-  target: "150x-12,500x via HNSW indexing",
-  implementation: "agentic-flow@alpha AgentDB",
-};
-```
-
-## Backward Compatibility
-
-### Gradual Migration
-
-```typescript
-class BackwardCompatibility {
-  // Phase 1: Dual operation
-  async enableDualOperation(): Promise<void> {
-    this.oldSystem.continue();
-    this.newSystem.initialize();
-    this.syncState(this.oldSystem, this.newSystem);
-  }
-
-  // Phase 2: Feature-by-feature migration
-  async migrateGradually(): Promise<void> {
-    const features = this.getAllFeatures();
-    for (const feature of features) {
-      await this.migrateFeature(feature);
-      await this.validateFeatureParity(feature);
-    }
-  }
-
-  // Phase 3: Complete transition
-  async completeTransition(): Promise<void> {
-    await this.validateFullParity();
-    await this.deprecateOldSystem();
-  }
-}
-```
-
-## Success Metrics
-
-- **Code Reduction**: <5,000 lines orchestration (vs 15,000+)
-- **Performance**: 2.49x-7.47x Flash Attention speedup
-- **Search**: 150x-12,500x AgentDB improvement
-- **Memory**: 50-75% usage reduction
-- **Feature Parity**: 100% v2 functionality maintained
-- **SONA**: <0.05ms adaptation time
-- **Integration**: All 213 MCP tools + 19 hook types available
-
-## Related v1 Skills
-
-- `v1-memory-unification` - Memory system integration
-- `v1-performance-optimization` - Performance target validation
-- `v1-swarm-coordination` - Swarm system migration
-- `v1-security-overhaul` - Secure integration patterns