V3 DDD Architecture

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

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

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

// core/kernel/claude-flow-kernel.tsexport 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;  }}

// core/plugins/interface DomainPlugin {  name: string;  version: string;  dependencies: string[];
  initialize(kernel: ClaudeFlowKernel): Promise<void>;  shutdown(): Promise<void>;}
// Example: Swarm Coordination Pluginexport 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);  }}

// 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 eventsexport 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    );  }}

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

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

// core/domains/task-management/module.tsexport const taskManagementModule = {  name: 'task-management',
  entities: [    TaskEntity,    TaskQueueEntity  ],
  valueObjects: [    TaskIdVO,    TaskStatusVO,    PriorityVO  ],
  services: [    TaskSchedulingService,    TaskValidationService  ],
  repositories: [    { provide: ITaskRepository, useClass: SqliteTaskRepository }  ],
  eventHandlers: [    TaskAssignedHandler,    TaskCompletedHandler  ]};

// Extract services from orchestrator.tsconst 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'  ]};

// Clean separation with dependency injectionexport 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);  }}

// Enable plugin-based extensionsconst pluginSystem = {  core: ['task-management', 'session-management', 'health-monitoring'],  optional: ['swarm-coordination', 'learning-integration', 'performance-monitoring']};

// Pure domain logic testingdescribe('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);  });});