V3 DDD Architecture

What This Skill Does

Designs and implements Domain-Driven Design (DDD) architecture for claude-flow v3, decomposing god objects into bounded contexts, implementing clean architecture patterns, and enabling modular, testable code structure.

Quick Start

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

// 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

// 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

// 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

// core$kernel$claude-flow-kernel.ts export class ClaudeFlowKernel { 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

// core$plugins/ interface DomainPlugin { name: string; version: string; dependencies: string[];

initialize(kernel: ClaudeFlowKernel): 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: ClaudeFlowKernel): 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

// 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

// 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)

// 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

// 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

// 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

// 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

// 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)

// 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 V3 Skills

• v3-core-implementation

• Implementation of DDD domains

• v3-memory-unification

• AgentDB integration within bounded contexts

• v3-swarm-coordination

• Swarm coordination as domain plugin

• v3-performance-optimization

• Performance optimization across domains

Usage Examples

Complete Domain Extraction

Full DDD architecture implementation

Task("DDD architecture implementation", "Extract orchestrator into DDD domains with clean architecture", "core-architect")

Plugin Development

Create domain plugin

npm run create:plugin -- --name swarm-coordination --template domain