SKILL.md
$2a
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 dependenciesApplication 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