@monoes/monomindcli 1.10.54 → 1.10.55

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

@@ -1,444 +0,0 @@
----
-name: ddd-architecture
-description: "Domain-Driven Design architecture for monomind. Implements modular, bounded context architecture with clean separation of concerns and microkernel pattern."
-triggers:
-  - god object
-  - decompose orchestrator
-  - DDD boundaries
-  - bounded context
-  - plugin architecture
-  - microkernel
-  - domain separation
-  - modular architecture
----
-
-# 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 = process.env.npm_package_version ?? "1.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
-
-Start with the shared kernel (base entity, value object, aggregate root, domain event classes) before any bounded context. Then implement core domains in dependency order: task-management first (no cross-domain dependencies), followed by session-management and health-monitoring (which may subscribe to task events), and finally event-coordination as the integration layer that wires domain events across contexts.
-
-### 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 Skills
-
-- `core-implementation` - Implementation of DDD domains
-- `memory-unification` - AgentDB integration within bounded contexts
-- `swarm-coordination` - Swarm coordination as domain plugin
-- `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
-```