@claude-flow/shared 3.0.0-alpha.1 → 3.0.0-alpha.8

package/.claude-flow/logs/headless/optimize_1777380274732_apxz3s_prompt.log

@@ -0,0 +1,3504 @@
+[2026-04-28T12:44:34.736Z] PROMPT
+============================================================
+Analyze this codebase for performance optimizations:
+- Identify N+1 query patterns
+- Find unnecessary re-renders in React
+- Suggest caching opportunities
+- Identify memory leaks
+- Find redundant computations
+
+Provide actionable suggestions with code examples.
+
+## Codebase Context
+
+--- src/core/config/defaults.ts ---
+/**
+ * V3 Default Configuration Values
+ */
+
+import type {
+  AgentConfig,
+  TaskConfig,
+  SwarmConfig,
+  MemoryConfig,
+  MCPServerConfig,
+  OrchestratorConfig,
+  SystemConfig,
+} from './schema.js';
+
+/**
+ * Default agent configuration
+ */
+export const defaultAgentConfig: Partial<AgentConfig> = {
+  capabilities: [],
+  maxConcurrentTasks: 5,
+  priority: 50,
+  retryPolicy: {
+    maxRetries: 3,
+    backoffMs: 1000,
+    backoffMultiplier: 2,
+  },
+};
+
+/**
+ * Default task configuration
+ */
+export const defaultTaskConfig: Partial<TaskConfig> = {
+  priority: 50,
+  metadata: {
+    maxRetries: 3,
+  },
+};
+
+/**
+ * Default swarm configuration (core version)
+ */
+export const defaultSwarmConfigCore: SwarmConfig = {
+  topology: 'hierarchical-mesh',
+  maxAgents: 20,
+  autoScale: {
+    enabled: false,
+    minAgents: 1,
+    maxAgents: 20,
+    scaleUpThreshold: 0.8,
+    scaleDownThreshold: 0.3,
+  },
+  coordination: {
+    consensusRequired: false,
+    timeoutMs: 10000,
+    retryPolicy: {
+      maxRetries: 3,
+      backoffMs: 500,
+    },
+  },
+  communication: {
+    protocol: 'events',
+    batchSize: 10,
+    flushIntervalMs: 100,
+  },
+};
+
+/**
+ * Default memory configuration (hybrid backend - ADR-009)
+ */
+export const defaultMemoryConfig: MemoryConfig = {
+  type: 'hybrid',
+  path: './data/memory',
+  sqlite: {
+    inMemory: false,
+    wal: true,
+  },
+  agentdb: {
+    dimensions: 1536,
+    indexType: 'hnsw',
+    efConstruction: 200,
+    m: 16,
+    quantization: 'none',
+  },
+  hybrid: {
+    vectorThreshold: 100,
+  },
+};
+
+/**
+ * Default MCP server configuration
+ */
+export const defaultMCPServerConfig: MCPServerConfig = {
+  name: 'claude-flow',
+  version: '3.0.0',
+  transport: {
+    type: 'stdio',
+  },
+  capabilities: {
+    tools: true,
+    resources: true,
+    prompts: true,
+    logging: true,
+  },
+};
+
+/**
+ * Default orchestrator configuration
+ */
+export const defaultOrchestratorConfig: OrchestratorConfig = {
+  session: {
+    persistSessions: true,
+    dataDir: './data',
+    sessionRetentionMs: 3600000, // 1 hour
+  },
+  health: {
+    checkInterval: 30000, // 30 seconds
+    historyLimit: 100,
+    degradedThreshold: 1,
+    unhealthyThreshold: 2,
+  },
+  lifecycle: {
+    maxConcurrentAgents: 20,
+    spawnTimeout: 30000, // 30 seconds
+    terminateTimeout: 10000, // 10 seconds
+    maxSpawnRetries: 3,
+  },
+};
+
+/**
+ * Default full system configuration
+ */
+export const defaultSystemConfig: SystemConfig = {
+  orchestrator: defaultOrchestratorConfig,
+  memory: defaultMemoryConfig,
+  mcp: defaultMCPServerConfig,
+  swarm: defaultSwarmConfigCore,
+};
+
+/**
+ * Agent type presets
+ */
+export const agentTypePresets: Record<string, Partial<AgentConfig>> = {
+  coder: {
+    type: 'coder',
+    capabilities: ['code', 'debug', 'refactor', 'test'],
+    maxConcurrentTasks: 3,
+    priority: 70,
+  },
+  reviewer: {
+    type: 'reviewer',
+    capabilities: ['review', 'analyze', 'suggest'],
+    maxConcurrentTasks: 5,
+    priority: 60,
+  },
+  tester: {
+    type: 'tester',
+    capabilities: ['test', 'validate', 'benchmark'],
+    maxConcurrentTasks: 4,
+    priority: 65,
+  },
+  researcher: {
+    type: 'researcher',
+    capabilities: ['research', 'analyze', 'summarize'],
+    maxConcurrentTasks: 3,
+    priority: 50,
+  },
+  planner: {
+    type: 'planner',
+    capabilities: ['plan', 'organize', 'decompose'],
+    maxConcurrentTasks: 2,
+    priority: 80,
+  },
+  architect: {
+    type: 'architect',
+    capabilities: ['design', 'architecture', 'patterns'],
+    maxConcurrentTasks: 2,
+    priority: 85,
+  },
+  coordinator: {
+    type: 'coordinator',
+    capabilities: ['coordinate', 'delegate', 'monitor'],
+    maxConcurrentTasks: 10,
+    priority: 90,
+  },
+  security: {
+    type: 'security',
+    capabilities: ['audit', 'scan', 'validate', 'secure'],
+    maxConcurrentTasks: 3,
+    priority: 95,
+  },
+  performance: {
+    type: 'performance',
+    capabilities: ['benchmark', 'optimize', 'profile'],
+    maxConcurrentTasks: 2,
+    priority: 70,
+  },
+};
+
+/**
+ * Get merged configuration with defaults
+ */
+export function mergeWithDefaults<T extends Record<string, unknown>>(
+  config: Partial<T>,
+  defaults: T,
+): T {
+  return { ...defaults, ...config } as T;
+}
+
+
+--- src/core/config/index.ts ---
+/**
+ * V3 Configuration - Public API
+ */
+
+// Schemas
+export * from './schema.js';
+
+// Validation
+export * from './validator.js';
+
+// Defaults
+export * from './defaults.js';
+
+// Loader
+export * from './loader.js';
+
+
+--- src/core/config/loader.ts (truncated) ---
+/**
+ * V3 Configuration Loader
+ * Load configuration from various sources
+ */
+
+import { readFile } from 'fs/promises';
+import { join, resolve } from 'path';
+import { existsSync } from 'fs';
+import type { SystemConfig } from './schema.js';
+import { validateSystemConfig, type ValidationResult } from './validator.js';
+import { defaultSystemConfig, mergeWithDefaults } from './defaults.js';
+
+/**
+ * Configuration source type
+ */
+export type ConfigSource = 'file' | 'env' | 'default' | 'merged';
+
+/**
+ * Loaded configuration with metadata
+ */
+export interface LoadedConfig {
+  config: SystemConfig;
+  source: ConfigSource;
+  path?: string;
+  warnings?: string[];
+}
+
+/**
+ * Configuration file names to search for
+ */
+const CONFIG_FILE_NAMES = [
+  'claude-flow.config.json',
+  'claude-flow.config.js',
+  'claude-flow.json',
+  '.claude-flow.json',
+];
+
+/**
+ * Find configuration file in directory
+ */
+async function findConfigFile(directory: string): Promise<string | null> {
+  for (const name of CONFIG_FILE_NAMES) {
+    const path = join(directory, name);
+    if (existsSync(path)) {
+      return path;
+    }
+  }
+  return null;
+}
+
+/**
+ * Load configuration from JSON file
+ */
+async function loadJsonConfig(path: string): Promise<unknown> {
+  const content = await readFile(path, 'utf8');
+  return JSON.parse(content);
+}
+
+/**
+ * Load configuration from environment variables
+ */
+function loadEnvConfig(): Partial<SystemConfig> {
+  const config: Partial<SystemConfig> = {};
+
+  // Orchestrator settings
+  if (process.env.CLAUDE_FLOW_MAX_AGENTS) {
+    config.orchestrator = {
+      ...defaultSystemConfig.orchestrator,
+      lifecycle: {
+        ...defaultSystemConfig.orchestrator.lifecycle,
+        maxConcurrentAgents: parseInt(process.env.CLAUDE_FLOW_MAX_AGENTS, 10),
+      },
+    };
+  }
+
+  // Data directory
+  if (process.env.CLAUDE_FLOW_DATA_DIR) {
+    config.orchestrator = {
+      ...config.orchestrator,
+      ...defaultSystemConfig.orchestrator,
+      session: {
+        ...defaultSystemConfig.orchestrator.session,
+        dataDir: process.env.CLAUDE_FLOW_DATA_DIR,
+      },
+    };
+  }
+
+  // Memory type
+  if (process.env.CLAUDE_FLOW_MEMORY_TYPE) {
+    const memoryType = process.env.CLAUDE_FLOW_MEMORY_TYPE as NonNullable<SystemConfig['memory']>['type'];
+    if (['sqlite', 'agentdb', 'hybrid', 'redis', 'memory'].includes(memoryType)) {
+      config.memory = {
+        ...(defaultSystemConfig.memory ?? { type: 'hybrid' }),
+        type: memoryType,
+      };
+    }
+  }
+
+  // MCP transport
+  const defaultMcp = defaultSystemConfig.mcp ?? { name: 'claude-flow', version: '3.0.0', transport: { type: 'stdio' as const } };
+  if (process.env.CLAUDE_FLOW_MCP_TRANSPORT) {
+    const transport = process.env.CLAUDE_FLOW_MCP_TRANSPORT as 'stdio' | 'http' | 'websocket';
+    if (['stdio', 'http', 'websocket'].includes(transport)) {
+      config.mcp = {
+        ...defaultMcp,
+        transport: {
+          ...defaultMcp.transport,
+          type: transport,
+        },
+      };
+    }
+  }
+
+  if (process.env.CLAUDE_FLOW_MCP_PORT) {
+    config.mcp = {
+      ...config.mcp,
+      ...defaultMcp,
+      transport: {
+        ...config.mcp?.transport,
+        ...defaultMcp.transport,
+        port: parseInt(process.env.CLAUDE_FLOW_MCP_PORT, 10),
+      },
+    };
+  }
+
+  // Swarm topology
+  const defaultSwarm = defaultSystemConfig.swarm ?? { topology: 'hierarchical-mesh' as const, maxAgents: 20 };
+  if (process.env.CLAUDE_FLOW_SWARM_TOPOLOGY) {
+    const topology = process.env.CLAUDE_FLOW_SWARM_TOPOLOGY as NonNullable<SystemConfig['swarm']>['topology'];
+    if (['hierarchical', 'mesh', 'ring', 'star', 'adaptive', 'hierarchical-mesh'].includes(topology)) {
+      config.swarm = {
+        ...defaultSwarm,
+        topology,
+      };
+    }
+  }
+
+  return config;
+}
+
+/**
+ * Configuration loader class
+ */
+export class ConfigLoader {
+  private searchPaths: string[] = [];
+
+  constructor(additionalPaths?: string[]) {
+    // Default search paths
+    this.searchPaths = [
+      process.cwd(),
+      resolve(process.cwd(), '..'),
+      resolve(process.env.HOME ?? '', '.claude-flow'),
+    ];
+
+    if (additionalPaths) {
+      this.searchPaths.push(...additionalPaths);
+    }
+  }
+
+  /**
+   * Load configuration from all sources
+   */
+  async load(): Promise<LoadedConfig> {
+    const warnings: string[] = [];
+
+    // Start with defaults
+    let config: SystemConfig = { ...defaultSystemConfig };
+    let source: ConfigSource = 'default';
+    let path: string | undefined;
+
+    // Try to load from file
+    for (const searchPath of this.searchPaths) {
+      const configPath = await findConfigFile(searchPath);
+      if (configPath) {
+        try {
+          const fileConfig = await loadJsonConfig(configPath);
+          const validation = validateSystemConfig(fileConfig);
+
+          if (validation.success) {
+            config = mergeWithDefaults(validation.data!, defaultSystemConfig) as SystemConfig;
+            source = 'file';
+            path = configPath;
+            break;
+          } else {
+           
+
+--- src/core/config/schema.ts (truncated) ---
+/**
+ * V3 Configuration Schemas
+ * Zod schemas for all configuration types
+ */
+
+import { z } from 'zod';
+
+/**
+ * Agent configuration schema
+ */
+export const AgentConfigSchema = z.object({
+  id: z.string().min(1),
+  name: z.string().min(1),
+  type: z.string().min(1),
+  capabilities: z.array(z.string()).default([]),
+  maxConcurrentTasks: z.number().int().min(1).default(5),
+  priority: z.number().int().min(0).max(100).default(50),
+  timeout: z.number().int().positive().optional(),
+  retryPolicy: z.object({
+    maxRetries: z.number().int().min(0).default(3),
+    backoffMs: z.number().int().positive().default(1000),
+    backoffMultiplier: z.number().positive().default(2),
+  }).optional(),
+  resources: z.object({
+    maxMemoryMb: z.number().int().positive().optional(),
+    maxCpuPercent: z.number().min(0).max(100).optional(),
+  }).optional(),
+  metadata: z.record(z.unknown()).optional(),
+});
+
+/**
+ * Task configuration schema
+ */
+export const TaskConfigSchema = z.object({
+  type: z.string().min(1),
+  description: z.string().min(1),
+  priority: z.number().int().min(0).max(100).default(50),
+  timeout: z.number().int().positive().optional(),
+  assignedAgent: z.string().optional(),
+  input: z.record(z.unknown()).optional(),
+  metadata: z.object({
+    requiredCapabilities: z.array(z.string()).optional(),
+    retryCount: z.number().int().min(0).optional(),
+    maxRetries: z.number().int().min(0).optional(),
+    critical: z.boolean().optional(),
+    parentTaskId: z.string().optional(),
+    childTaskIds: z.array(z.string()).optional(),
+    tags: z.array(z.string()).optional(),
+  }).optional(),
+});
+
+/**
+ * Swarm configuration schema
+ */
+export const SwarmConfigSchema = z.object({
+  topology: z.enum(['hierarchical', 'mesh', 'ring', 'star', 'adaptive', 'hierarchical-mesh']),
+  maxAgents: z.number().int().positive().default(20),
+  autoScale: z.object({
+    enabled: z.boolean().default(false),
+    minAgents: z.number().int().min(0).default(1),
+    maxAgents: z.number().int().positive().default(20),
+    scaleUpThreshold: z.number().min(0).max(1).default(0.8),
+    scaleDownThreshold: z.number().min(0).max(1).default(0.3),
+  }).optional(),
+  coordination: z.object({
+    consensusRequired: z.boolean().default(false),
+    timeoutMs: z.number().int().positive().default(10000),
+    retryPolicy: z.object({
+      maxRetries: z.number().int().min(0).default(3),
+      backoffMs: z.number().int().positive().default(500),
+    }),
+  }).optional(),
+  communication: z.object({
+    protocol: z.enum(['events', 'messages', 'shared-memory']).default('events'),
+    batchSize: z.number().int().positive().default(10),
+    flushIntervalMs: z.number().int().positive().default(100),
+  }).optional(),
+  metadata: z.record(z.unknown()).optional(),
+});
+
+/**
+ * Memory configuration schema
+ */
+export const MemoryConfigSchema = z.object({
+  type: z.enum(['sqlite', 'agentdb', 'hybrid', 'redis', 'memory']).default('hybrid'),
+  path: z.string().optional(),
+  maxSize: z.number().int().positive().optional(),
+  ttlMs: z.number().int().positive().optional(),
+  sqlite: z.object({
+    filename: z.string().optional(),
+    inMemory: z.boolean().default(false),
+    wal: z.boolean().default(true),
+  }).optional(),
+  agentdb: z.object({
+    dimensions: z.number().int().positive().default(1536),
+    indexType: z.enum(['hnsw', 'flat', 'ivf']).default('hnsw'),
+    efConstruction: z.number().int().positive().default(200),
+    m: z.number().int().positive().default(16),
+    quantization: z.enum(['none', 'scalar', 'product']).default('none'),
+  }).optional(),
+  redis: z.object({
+    host: z.string().default('localhost'),
+    port: z.number().int().positive().default(6379),
+    password: z.string().optional(),
+    db: z.number().int().min(0).default(0),
+    keyPrefix: z.string().default('claude-flow:'),
+  }).optional(),
+  hybrid: z.object({
+    vectorThreshold: z.number().int().positive().default(100),
+  }).optional(),
+});
+
+/**
+ * MCP server configuration schema
+ */
+export const MCPServerConfigSchema = z.object({
+  name: z.string().min(1).default('claude-flow'),
+  version: z.string().min(1).default('3.0.0'),
+  transport: z.object({
+    type: z.enum(['stdio', 'http', 'websocket']).default('stdio'),
+    port: z.number().int().positive().optional(),
+    host: z.string().optional(),
+    path: z.string().optional(),
+  }),
+  capabilities: z.object({
+    tools: z.boolean().default(true),
+    resources: z.boolean().default(true),
+    prompts: z.boolean().default(true),
+    logging: z.boolean().default(true),
+    experimental: z.record(z.boolean()).optional(),
+  }).optional(),
+});
+
+/**
+ * Orchestrator configuration schema
+ */
+export const OrchestratorConfigSchema = z.object({
+  session: z.object({
+    persistSessions: z.boolean().default(true),
+    dataDir: z.string().default('./data'),
+    sessionRetentionMs: z.number().int().positive().default(3600000),
+  }),
+  health: z.object({
+    checkInterval: z.number().int().positive().default(30000),
+    historyLimit: z.number().int().positive()
+
+--- src/core/config/validator.ts ---
+/**
+ * V3 Configuration Validator
+ * Validation logic using Zod schemas
+ */
+
+import { z, type ZodError } from 'zod';
+import {
+  AgentConfigSchema,
+  TaskConfigSchema,
+  SwarmConfigSchema,
+  MemoryConfigSchema,
+  MCPServerConfigSchema,
+  OrchestratorConfigSchema,
+  SystemConfigSchema,
+  type AgentConfig,
+  type TaskConfig,
+  type SwarmConfig,
+  type MemoryConfig,
+  type MCPServerConfig,
+  type OrchestratorConfig,
+  type SystemConfig,
+} from './schema.js';
+
+/**
+ * Validation result
+ */
+export interface ValidationResult<T> {
+  success: boolean;
+  data?: T;
+  errors?: ValidationError[];
+}
+
+/**
+ * Validation error
+ */
+export interface ValidationError {
+  path: string;
+  message: string;
+  code: string;
+}
+
+/**
+ * Convert Zod error to validation errors
+ */
+function zodErrorToValidationErrors(error: ZodError): ValidationError[] {
+  return error.errors.map((e) => ({
+    path: e.path.join('.'),
+    message: e.message,
+    code: e.code,
+  }));
+}
+
+/**
+ * Generic validation function
+ * Uses parse + try/catch to get output types with defaults applied
+ */
+function validate<TInput, TOutput>(
+  schema: z.ZodType<TOutput, z.ZodTypeDef, TInput>,
+  data: unknown
+): ValidationResult<TOutput> {
+  try {
+    const parsed = schema.parse(data);
+    return {
+      success: true,
+      data: parsed,
+    };
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      return {
+        success: false,
+        errors: zodErrorToValidationErrors(error),
+      };
+    }
+    throw error;
+  }
+}
+
+/**
+ * Validate agent configuration
+ */
+export function validateAgentConfig(data: unknown): ValidationResult<AgentConfig> {
+  return validate(AgentConfigSchema, data);
+}
+
+/**
+ * Validate task configuration
+ */
+export function validateTaskConfig(data: unknown): ValidationResult<TaskConfig> {
+  return validate(TaskConfigSchema, data);
+}
+
+/**
+ * Validate swarm configuration
+ */
+export function validateSwarmConfig(data: unknown): ValidationResult<SwarmConfig> {
+  return validate(SwarmConfigSchema, data);
+}
+
+/**
+ * Validate memory configuration
+ */
+export function validateMemoryConfig(data: unknown): ValidationResult<MemoryConfig> {
+  return validate(MemoryConfigSchema, data);
+}
+
+/**
+ * Validate MCP server configuration
+ */
+export function validateMCPServerConfig(data: unknown): ValidationResult<MCPServerConfig> {
+  return validate(MCPServerConfigSchema, data);
+}
+
+/**
+ * Validate orchestrator configuration
+ */
+export function validateOrchestratorConfig(data: unknown): ValidationResult<OrchestratorConfig> {
+  return validate(OrchestratorConfigSchema, data);
+}
+
+/**
+ * Validate full system configuration
+ */
+export function validateSystemConfig(data: unknown): ValidationResult<SystemConfig> {
+  return validate(SystemConfigSchema, data);
+}
+
+/**
+ * Configuration validator class
+ */
+export class ConfigValidator {
+  /**
+   * Validate and throw on error
+   */
+  static validateOrThrow<TInput, TOutput>(
+    schema: z.ZodType<TOutput, z.ZodTypeDef, TInput>,
+    data: unknown,
+    configName: string
+  ): TOutput {
+    const result = validate(schema, data);
+
+    if (!result.success) {
+      const errorMessages = result.errors
+        ?.map((e) => `  - ${e.path}: ${e.message}`)
+        .join('\n');
+      throw new Error(`Invalid ${configName} configuration:\n${errorMessages}`);
+    }
+
+    return result.data!;
+  }
+
+  /**
+   * Validate agent config or throw
+   */
+  static validateAgentOrThrow(data: unknown): AgentConfig {
+    return this.validateOrThrow(AgentConfigSchema, data, 'agent');
+  }
+
+  /**
+   * Validate task config or throw
+   */
+  static validateTaskOrThrow(data: unknown): TaskConfig {
+    return this.validateOrThrow(TaskConfigSchema, data, 'task');
+  }
+
+  /**
+   * Validate swarm config or throw
+   */
+  static validateSwarmOrThrow(data: unknown): SwarmConfig {
+    return this.validateOrThrow(SwarmConfigSchema, data, 'swarm');
+  }
+
+  /**
+   * Validate memory config or throw
+   */
+  static validateMemoryOrThrow(data: unknown): MemoryConfig {
+    return this.validateOrThrow(MemoryConfigSchema, data, 'memory');
+  }
+
+  /**
+   * Validate MCP server config or throw
+   */
+  static validateMCPServerOrThrow(data: unknown): MCPServerConfig {
+    return this.validateOrThrow(MCPServerConfigSchema, data, 'MCP server');
+  }
+
+  /**
+   * Validate orchestrator config or throw
+   */
+  static validateOrchestratorOrThrow(data: unknown): OrchestratorConfig {
+    return this.validateOrThrow(OrchestratorConfigSchema, data, 'orchestrator');
+  }
+
+  /**
+   * Validate system config or throw
+   */
+  static validateSystemOrThrow(data: unknown): SystemConfig {
+    return this.validateOrThrow(SystemConfigSchema, data, 'system');
+  }
+
+  /**
+   * Check if data matches schema
+   */
+  static isValid<TInput, TOutput>(
+    schema: z.ZodType<TOutput, z.ZodTypeDef, TInput>,
+    data: unknown
+  ): boolean {
+    return validate(schema, data).success;
+  }
+}
+
+
+--- src/core/event-bus.ts (truncated) ---
+/**
+ * V3 Event Bus
+ * Core event pub/sub implementation
+ */
+
+import type {
+  IEvent,
+  IEventBus,
+  IEventCreate,
+  IEventHandler,
+  IEventSubscription,
+  IEventFilter,
+} from './interfaces/event.interface.js';
+import { randomBytes } from 'crypto';
+
+// Secure event ID generation
+function generateSecureEventId(): string {
+  const timestamp = Date.now().toString(36);
+  const random = randomBytes(12).toString('hex');
+  return `evt_${timestamp}_${random}`;
+}
+
+/**
+ * Event subscription implementation
+ */
+class EventSubscription implements IEventSubscription {
+  private active = true;
+  private paused = false;
+
+  constructor(
+    readonly id: string,
+    readonly filter: IEventFilter,
+    private removeCallback: () => void,
+  ) {}
+
+  unsubscribe(): void {
+    this.active = false;
+    this.removeCallback();
+  }
+
+  pause(): void {
+    this.paused = true;
+  }
+
+  resume(): void {
+    this.paused = false;
+  }
+
+  isActive(): boolean {
+    return this.active && !this.paused;
+  }
+}
+
+/**
+ * Event bus implementation
+ */
+export class EventBus implements IEventBus {
+  private handlers = new Map<string, Set<IEventHandler>>();
+  private subscriptions = new Map<string, { filter: IEventFilter; handler: IEventHandler; subscription: EventSubscription }>();
+  private subscriptionId = 0;
+
+  emit<T = unknown>(type: string, payload: T, options?: Partial<IEventCreate<T>>): void {
+    const event = this.createEvent(type, payload, options);
+    this.dispatchEvent(event);
+  }
+
+  async emitAsync<T = unknown>(type: string, payload: T, options?: Partial<IEventCreate<T>>): Promise<void> {
+    const event = this.createEvent(type, payload, options);
+    await this.dispatchEventAsync(event);
+  }
+
+  on<T = unknown>(type: string, handler: IEventHandler<T>): IEventSubscription {
+    return this.subscribe({ types: [type] }, handler);
+  }
+
+  subscribe<T = unknown>(filter: IEventFilter, handler: IEventHandler<T>): IEventSubscription {
+    const id = `sub_${++this.subscriptionId}`;
+
+    // Register for all matching types
+    const types = filter.types ?? ['*'];
+    for (const type of types) {
+      let handlers = this.handlers.get(type);
+      if (!handlers) {
+        handlers = new Set();
+        this.handlers.set(type, handlers);
+      }
+      handlers.add(handler as IEventHandler);
+    }
+
+    const subscription = new EventSubscription(id, filter, () => {
+      this.removeSubscription(id);
+    });
+
+    this.subscriptions.set(id, { filter, handler: handler as IEventHandler, subscription });
+
+    return subscription;
+  }
+
+  once<T = unknown>(type: string, handler: IEventHandler<T>): IEventSubscription {
+    const wrappedHandler: IEventHandler<T> = async (event) => {
+      subscription.unsubscribe();
+      await handler(event);
+    };
+
+    const subscription = this.on(type, wrappedHandler);
+    return subscription;
+  }
+
+  off(type: string, handler: IEventHandler): void {
+    const handlers = this.handlers.get(type);
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.handlers.delete(type);
+      }
+    }
+  }
+
+  removeAllListeners(type?: string): void {
+    if (type) {
+      this.handlers.delete(type);
+    } else {
+      this.handlers.clear();
+    }
+  }
+
+  listenerCount(type: string): number {
+    return this.handlers.get(type)?.size ?? 0;
+  }
+
+  eventNames(): string[] {
+    return Array.from(this.handlers.keys());
+  }
+
+  private createEvent<T>(type: string, payload: T, options?: Partial<IEventCreate<T>>): IEvent<T> {
+    return {
+      id: generateSecureEventId(),
+      type,
+      timestamp: new Date(),
+      source: options?.source ?? 'event-bus',
+      payload,
+      priority: options?.priority,
+      correlationId: options?.correlationId,
+      causationId: options?.causationId,
+      metadata: options?.metadata,
+    };
+  }
+
+  private dispatchEvent<T>(event: IEvent<T>): void {
+    // Get handlers for specific type
+    const typeHandlers = this.handlers.get(event.type);
+
+    // Get wildcard handlers
+    const wildcardHandlers = this.handlers.get('*');
+
+    const allHandlers = new Set<IEventHandler>();
+
+    if (typeHandlers) {
+      for (const handler of typeHandlers) {
+        allHandlers.add(handler);
+      }
+    }
+
+    if (wildcardHandlers) {
+      for (const handler of wildcardHandlers) {
+        allHandlers.add(handler);
+      }
+    }
+
+    for (const handler of allHandlers) {
+      try {
+        const result = handler(event);
+        if (result instanceof Promise) {
+          result.catch((error) => {
+            console.error(`Error in async event handler for ${event.type}:`, error);
+          });
+        }
+      } catch (error) {
+        console.error(`Error in event handler for ${event.type}:`, error);
+      }
+    }
+  }
+
+  private async dispatchEventAsync<T>(event: IEvent<T>): Promise<void> {
+    const typeHandlers = this.handlers.get(event.type);
+    const wildcardHandlers = this.handlers.get('*');
+
+    const allHandlers = new Set<IEventHandler>();
+
+    if (typeHandlers) {
+      for (const handler
+
+--- src/core/index.ts ---
+/**
+ * V3 Core Module - Public API
+ * Domain-Driven Design with Clean Architecture
+ *
+ * This module provides the core architecture for claude-flow v3:
+ * - Decomposed orchestrator (task, session, health, lifecycle management)
+ * - Event-driven architecture with event bus and coordinator
+ * - Type-safe configuration with Zod validation
+ * - Clean interfaces following DDD principles
+ */
+
+// Interfaces (Domain contracts)
+export * from './interfaces/index.js';
+
+// Event system
+export { EventBus, createEventBus } from './event-bus.js';
+
+// Orchestrator components (decomposed)
+export * from './orchestrator/index.js';
+
+// Configuration
+export * from './config/index.js';
+
+
+--- src/core/interfaces/agent.interface.ts ---
+/**
+ * V3 Agent Interfaces
+ * Domain-Driven Design - Agent Lifecycle Bounded Context
+ */
+
+/**
+ * Agent status in the system
+ */
+export type AgentStatus = 'spawning' | 'active' | 'idle' | 'busy' | 'error' | 'terminated';
+
+/**
+ * Agent type classification
+ */
+export type AgentType =
+  | 'coder'
+  | 'reviewer'
+  | 'tester'
+  | 'researcher'
+  | 'planner'
+  | 'architect'
+  | 'coordinator'
+  | 'security'
+  | 'performance'
+  | 'custom';
+
+/**
+ * Agent capability declaration
+ */
+export interface IAgentCapability {
+  name: string;
+  level: 'basic' | 'intermediate' | 'advanced' | 'expert';
+  description?: string;
+}
+
+/**
+ * Agent configuration for spawning
+ */
+export interface IAgentConfig {
+  readonly id: string;
+  readonly name: string;
+  readonly type: AgentType | string;
+
+  capabilities: string[];
+  maxConcurrentTasks: number;
+  priority: number;
+
+  timeout?: number;
+  retryPolicy?: {
+    maxRetries: number;
+    backoffMs: number;
+    backoffMultiplier: number;
+  };
+
+  resources?: {
+    maxMemoryMb?: number;
+    maxCpuPercent?: number;
+  };
+
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * Core agent entity
+ */
+export interface IAgent {
+  readonly id: string;
+  readonly name: string;
+  readonly type: AgentType | string;
+  readonly config: IAgentConfig;
+  readonly createdAt: Date;
+
+  status: AgentStatus;
+  currentTaskCount: number;
+  lastActivity: Date;
+
+  sessionId?: string;
+  terminalId?: string;
+  memoryBankId?: string;
+
+  metrics?: {
+    tasksCompleted: number;
+    tasksFailed: number;
+    avgTaskDuration: number;
+    errorCount: number;
+    uptime: number;
+  };
+
+  health?: {
+    status: 'healthy' | 'degraded' | 'unhealthy';
+    lastCheck: Date;
+    issues?: string[];
+  };
+}
+
+/**
+ * Agent session for tracking active work
+ */
+export interface IAgentSession {
+  readonly id: string;
+  readonly agentId: string;
+  readonly startTime: Date;
+
+  status: 'active' | 'idle' | 'terminated';
+  terminalId: string;
+  memoryBankId: string;
+
+  lastActivity: Date;
+  endTime?: Date;
+
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * Agent pool for managing multiple agents
+ */
+export interface IAgentPool {
+  /**
+   * Add an agent to the pool
+   */
+  add(agent: IAgent): void;
+
+  /**
+   * Remove an agent from the pool
+   */
+  remove(agentId: string): boolean;
+
+  /**
+   * Get an agent by ID
+   */
+  get(agentId: string): IAgent | undefined;
+
+  /**
+   * Get all agents in the pool
+   */
+  getAll(): IAgent[];
+
+  /**
+   * Get agents by status
+   */
+  getByStatus(status: AgentStatus): IAgent[];
+
+  /**
+   * Get agents by type
+   */
+  getByType(type: AgentType | string): IAgent[];
+
+  /**
+   * Get available agents (can accept more tasks)
+   */
+  getAvailable(): IAgent[];
+
+  /**
+   * Get pool size
+   */
+  size(): number;
+
+  /**
+   * Check if pool has capacity
+   */
+  hasCapacity(maxSize: number): boolean;
+
+  /**
+   * Clear all agents
+   */
+  clear(): void;
+}
+
+/**
+ * Agent lifecycle manager interface
+ */
+export interface IAgentLifecycleManager {
+  /**
+   * Spawn a new agent
+   */
+  spawn(config: IAgentConfig): Promise<IAgent>;
+
+  /**
+   * Spawn multiple agents in parallel
+   */
+  spawnBatch(configs: IAgentConfig[]): Promise<Map<string, IAgent>>;
+
+  /**
+   * Terminate an agent
+   */
+  terminate(agentId: string, reason?: string): Promise<void>;
+
+  /**
+   * Terminate all agents
+   */
+  terminateAll(reason?: string): Promise<void>;
+
+  /**
+   * Restart an agent
+   */
+  restart(agentId: string): Promise<IAgent>;
+
+  /**
+   * Update agent configuration
+   */
+  updateConfig(agentId: string, config: Partial<IAgentConfig>): Promise<void>;
+
+  /**
+   * Get agent by ID
+   */
+  getAgent(agentId: string): IAgent | undefined;
+
+  /**
+   * Get all agents
+   */
+  getAllAgents(): IAgent[];
+
+  /**
+   * Get active agents count
+   */
+  getActiveCount(): number;
+
+  /**
+   * Check agent health
+   */
+  checkHealth(agentId: string): Promise<IAgent['health']>;
+}
+
+/**
+ * Agent registry for type definitions
+ */
+export interface IAgentRegistry {
+  /**
+   * Register an agent type with default config
+   */
+  register(type: string, defaultConfig: Partial<IAgentConfig>): void;
+
+  /**
+   * Unregister an agent type
+   */
+  unregister(type: string): boolean;
+
+  /**
+   * Get default config for a type
+   */
+  getDefaultConfig(type: string): Partial<IAgentConfig> | undefined;
+
+  /**
+   * Get all registered types
+   */
+  getRegisteredTypes(): string[];
+
+  /**
+   * Check if a type is registered
+   */
+  isRegistered(type: string): boolean;
+}
+
+
+--- src/core/interfaces/coordinator.interface.ts (truncated) ---
+/**
+ * V3 Coordinator Interfaces
+ * Domain-Driven Design - Coordination Bounded Context
+ * Aligned with ADR-003 (Single Coordination Engine)
+ */
+
+import type { ITask, ITaskResult } from './task.interface.js';
+import type { IAgent, IAgentConfig } from './agent.interface.js';
+
+/**
+ * Swarm topology types
+ */
+export type SwarmTopology =
+  | 'hierarchical'
+  | 'mesh'
+  | 'ring'
+  | 'star'
+  | 'adaptive'
+  | 'hierarchical-mesh';
+
+/**
+ * Coordination status
+ */
+export type CoordinationStatus =
+  | 'initializing'
+  | 'ready'
+  | 'coordinating'
+  | 'degraded'
+  | 'error'
+  | 'shutdown';
+
+/**
+ * Swarm configuration
+ */
+export interface ISwarmConfig {
+  topology: SwarmTopology;
+  maxAgents: number;
+
+  autoScale?: {
+    enabled: boolean;
+    minAgents: number;
+    maxAgents: number;
+    scaleUpThreshold: number;
+    scaleDownThreshold: number;
+  };
+
+  coordination?: {
+    consensusRequired: boolean;
+    timeoutMs: number;
+    retryPolicy: {
+      maxRetries: number;
+      backoffMs: number;
+    };
+  };
+
+  communication?: {
+    protocol: 'events' | 'messages' | 'shared-memory';
+    batchSize: number;
+    flushIntervalMs: number;
+  };
+
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * Swarm state
+ */
+export interface ISwarmState {
+  readonly id: string;
+  readonly topology: SwarmTopology;
+  readonly createdAt: Date;
+
+  status: CoordinationStatus;
+  agentCount: number;
+  taskCount: number;
+
+  metrics?: {
+    throughput: number;
+    latencyMs: number;
+    successRate: number;
+    resourceUtilization: number;
+  };
+}
+
+/**
+ * Coordinator interface - unified coordination engine
+ */
+export interface ICoordinator {
+  /**
+   * Initialize the coordinator
+   */
+  initialize(): Promise<void>;
+
+  /**
+   * Shutdown the coordinator
+   */
+  shutdown(): Promise<void>;
+
+  /**
+   * Initialize a swarm with configuration
+   */
+  initializeSwarm(config: ISwarmConfig): Promise<ISwarmState>;
+
+  /**
+   * Get swarm state
+   */
+  getSwarmState(): ISwarmState | undefined;
+
+  /**
+   * Assign a task to an agent
+   */
+  assignTask(task: ITask, agentId: string): Promise<void>;
+
+  /**
+   * Get tasks assigned to an agent
+   */
+  getAgentTasks(agentId: string): Promise<ITask[]>;
+
+  /**
+   * Get task count for an agent
+   */
+  getAgentTaskCount(agentId: string): Promise<number>;
+
+  /**
+   * Cancel a task
+   */
+  cancelTask(taskId: string): Promise<void>;
+
+  /**
+   * Report task completion
+   */
+  reportTaskComplete(taskId: string, result: ITaskResult): Promise<void>;
+
+  /**
+   * Get coordination health status
+   */
+  getHealthStatus(): Promise<{ healthy: boolean; error?: string; metrics?: Record<string, number> }>;
+
+  /**
+   * Perform maintenance tasks
+   */
+  performMaintenance(): Promise<void>;
+}
+
+/**
+ * Coordination manager interface - higher-level orchestration
+ */
+export interface ICoordinationManager extends ICoordinator {
+  /**
+   * Register an agent with the coordinator
+   */
+  registerAgent(agent: IAgent): Promise<void>;
+
+  /**
+   * Unregister an agent
+   */
+  unregisterAgent(agentId: string): Promise<void>;
+
+  /**
+   * Get all registered agents
+   */
+  getRegisteredAgents(): IAgent[];
+
+  /**
+   * Request agent consensus on a decision
+   */
+  requestConsensus(topic: string, options: unknown[], timeout?: number): Promise<unknown>;
+
+  /**
+   * Broadcast message to all agents
+   */
+  broadcast(message: unknown): Promise<void>;
+
+  /**
+   * Send message to specific agent
+   */
+  sendToAgent(agentId: string, message: unknown): Promise<void>;
+
+  /**
+   * Acquire a distributed lock
+   */
+  acquireLock(resourceId: string, agentId: string, timeout?: number): Promise<boolean>;
+
+  /**
+   * Release a distributed lock
+   */
+  releaseLock(resourceId: string, agentId: string): Promise<void>;
+
+  /**
+   * Check for deadlocks
+   */
+  detectDeadlocks(): Promise<{ detected: boolean; agents?: string[]; resources?: string[] }>;
+}
+
+/**
+ * Health status for components
+ */
+export interface IHealthStatus {
+  status: 'healthy' | 'degraded' | 'unhealthy';
+  components: Record<string, IComponentHealth>;
+  timestamp: Date;
+}
+
+/**
+ * Component health details
+ */
+export interface IComponentHealth {
+  name: string;
+  status: 'healthy' | 'degraded' | 'unhealthy';
+  lastCheck: Date;
+  error?: string;
+  metrics?: Record<string, number>;
+}
+
+/**
+ * Health monitor interface
+ */
+export interface IHealthMonitor {
+  /**
+   * Start health monitoring
+   */
+  start(): void;
+
+  /**
+   * Stop health monitoring
+   */
+  stop(): void;
+
+  /**
+   * Get current health status
+   */
+  getStatus(): Promise<IHealthStatus>;
+
+  /**
+   * Register a health check
+   */
+  registerCheck(
+    name: string,
+    check: () => Promise<{ healthy: boolean; error?: string; metrics?: Record<string, number> }>
+  ): void;
+
+  /**
+   * Unregister a health check
+   */
+  unregisterCheck(name: string): void;
+
+  /**
+   * Get health history
+   */
+  getHistory(limit?: number): IHealthStatus[];
+
+  /**
+   * Subscribe to health changes
+   */
+  onHealthChange(callback: (status: IHealthStatus) => void): () => void;
+}
+
+/**
+ * Metrics co
+
+--- src/core/interfaces/event.interface.ts (truncated) ---
+/**
+ * V3 Event Interfaces
+ * Domain-Driven Design - Event Sourcing Pattern (ADR-007)
+ */
+
+/**
+ * Event priority levels
+ */
+export type EventPriority = 'critical' | 'high' | 'normal' | 'low';
+
+/**
+ * Core event structure
+ */
+export interface IEvent<T = unknown> {
+  readonly id: string;
+  readonly type: string;
+  readonly timestamp: Date;
+  readonly source: string;
+
+  payload: T;
+  priority?: EventPriority;
+  correlationId?: string;
+  causationId?: string;
+
+  metadata?: {
+    version?: number;
+    userId?: string;
+    sessionId?: string;
+    [key: string]: unknown;
+  };
+}
+
+/**
+ * Event creation parameters
+ */
+export interface IEventCreate<T = unknown> {
+  type: string;
+  payload: T;
+  source?: string;
+  priority?: EventPriority;
+  correlationId?: string;
+  causationId?: string;
+  metadata?: IEvent['metadata'];
+}
+
+/**
+ * Event handler function type
+ */
+export type IEventHandler<T = unknown> = (event: IEvent<T>) => void | Promise<void>;
+
+/**
+ * Event filter for subscriptions
+ */
+export interface IEventFilter {
+  types?: string[];
+  sources?: string[];
+  priority?: EventPriority[];
+  correlationId?: string;
+}
+
+/**
+ * Event subscription handle
+ */
+export interface IEventSubscription {
+  readonly id: string;
+  readonly filter: IEventFilter;
+
+  /**
+   * Unsubscribe from events
+   */
+  unsubscribe(): void;
+
+  /**
+   * Pause subscription
+   */
+  pause(): void;
+
+  /**
+   * Resume subscription
+   */
+  resume(): void;
+
+  /**
+   * Check if subscription is active
+   */
+  isActive(): boolean;
+}
+
+/**
+ * Event bus interface for pub/sub communication
+ */
+export interface IEventBus {
+  /**
+   * Emit an event to all subscribers
+   */
+  emit<T = unknown>(type: string, payload: T, options?: Partial<IEventCreate<T>>): void;
+
+  /**
+   * Emit an event and wait for all handlers
+   */
+  emitAsync<T = unknown>(type: string, payload: T, options?: Partial<IEventCreate<T>>): Promise<void>;
+
+  /**
+   * Subscribe to events matching a type pattern
+   */
+  on<T = unknown>(type: string, handler: IEventHandler<T>): IEventSubscription;
+
+  /**
+   * Subscribe to events with filter
+   */
+  subscribe<T = unknown>(filter: IEventFilter, handler: IEventHandler<T>): IEventSubscription;
+
+  /**
+   * Subscribe to a single event occurrence
+   */
+  once<T = unknown>(type: string, handler: IEventHandler<T>): IEventSubscription;
+
+  /**
+   * Remove a specific handler
+   */
+  off(type: string, handler: IEventHandler): void;
+
+  /**
+   * Remove all handlers for a type
+   */
+  removeAllListeners(type?: string): void;
+
+  /**
+   * Get count of listeners for a type
+   */
+  listenerCount(type: string): number;
+
+  /**
+   * Get all event types with active listeners
+   */
+  eventNames(): string[];
+}
+
+/**
+ * System event types enumeration
+ */
+export const SystemEventTypes = {
+  // System lifecycle
+  SYSTEM_READY: 'system:ready',
+  SYSTEM_SHUTDOWN: 'system:shutdown',
+  SYSTEM_ERROR: 'system:error',
+  SYSTEM_HEALTHCHECK: 'system:healthcheck',
+
+  // Agent lifecycle
+  AGENT_SPAWNED: 'agent:spawned',
+  AGENT_TERMINATED: 'agent:terminated',
+  AGENT_ERROR: 'agent:error',
+  AGENT_IDLE: 'agent:idle',
+  AGENT_BUSY: 'agent:busy',
+  AGENT_HEALTH_CHANGED: 'agent:health:changed',
+
+  // Task lifecycle
+  TASK_CREATED: 'task:created',
+  TASK_ASSIGNED: 'task:assigned',
+  TASK_STARTED: 'task:started',
+  TASK_COMPLETED: 'task:completed',
+  TASK_FAILED: 'task:failed',
+  TASK_CANCELLED: 'task:cancelled',
+  TASK_TIMEOUT: 'task:timeout',
+  TASK_RETRY: 'task:retry',
+
+  // Session lifecycle
+  SESSION_CREATED: 'session:created',
+  SESSION_RESTORED: 'session:restored',
+  SESSION_TERMINATED: 'session:terminated',
+  SESSION_PERSISTED: 'session:persisted',
+
+  // Memory events
+  MEMORY_STORED: 'memory:stored',
+  MEMORY_RETRIEVED: 'memory:retrieved',
+  MEMORY_CLEARED: 'memory:cleared',
+
+  // Coordination events
+  COORDINATION_STARTED: 'coordination:started',
+  COORDINATION_COMPLETED: 'coordination:completed',
+  DEADLOCK_DETECTED: 'coordination:deadlock',
+
+  // Metrics events
+  METRICS_COLLECTED: 'metrics:collected',
+} as const;
+
+export type SystemEventType = typeof SystemEventTypes[keyof typeof SystemEventTypes];
+
+/**
+ * Event store interface for event sourcing
+ */
+export interface IEventStore {
+  /**
+   * Append an event to the store
+   */
+  append(event: IEvent): Promise<void>;
+
+  /**
+   * Get events by aggregate ID
+   */
+  getByAggregateId(aggregateId: string, fromVersion?: number): Promise<IEvent[]>;
+
+  /**
+   * Get events by type
+   */
+  getByType(type: string, options?: { limit?: number; offset?: number }): Promise<IEvent[]>;
+
+  /**
+   * Get events in time range
+   */
+  getByTimeRange(start: Date, end: Date): Promise<IEvent[]>;
+
+  /**
+   * Get events by correlation ID
+   */
+  getByCorrelationId(correlationId: string): Promise<IEvent[]>;
+
+  /**
+   * Get all events (paginated)
+   */
+  getAll(options?: { limit?: number; offset?: number }): Promise<IEvent[]>;
+
+  /**
+   * Get event count
+   */
+  count(filter?: IEventFilter): Promise<number>;
+
+  /**
+   * Clear old events
+   */
+  prune(olderThan: Date): P
+
+--- src/core/interfaces/index.ts ---
+/**
+ * V3 Core Interfaces - Public API
+ * Domain-Driven Design with Clean Architecture
+ */
+
+// Task interfaces
+export * from './task.interface.js';
+
+// Agent interfaces
+export * from './agent.interface.js';
+
+// Event interfaces
+export * from './event.interface.js';
+
+// Memory interfaces
+export * from './memory.interface.js';
+
+// Coordinator interfaces
+export * from './coordinator.interface.js';
+
+
+--- src/core/interfaces/memory.interface.ts (truncated) ---
+/**
+ * V3 Memory Interfaces
+ * Domain-Driven Design - Memory Management Bounded Context
+ * Aligned with ADR-006 (Unified Memory Service) and ADR-009 (Hybrid Memory Backend)
+ */
+
+/**
+ * Memory entry types
+ */
+export type MemoryType = 'session' | 'persistent' | 'vector' | 'cache' | 'pattern';
+
+/**
+ * Memory entry structure
+ */
+export interface IMemoryEntry {
+  readonly id: string;
+  readonly key: string;
+  readonly type: MemoryType;
+  readonly createdAt: Date;
+
+  value: unknown;
+  updatedAt: Date;
+  expiresAt?: Date;
+
+  metadata?: {
+    source?: string;
+    agentId?: string;
+    sessionId?: string;
+    version?: number;
+    tags?: string[];
+    embedding?: number[];
+    [key: string]: unknown;
+  };
+}
+
+/**
+ * Memory entry creation parameters
+ */
+export interface IMemoryEntryCreate {
+  key: string;
+  value: unknown;
+  type?: MemoryType;
+  expiresAt?: Date;
+  ttlMs?: number;
+  metadata?: IMemoryEntry['metadata'];
+}
+
+/**
+ * Vector search parameters
+ */
+export interface IVectorSearchParams {
+  embedding: number[];
+  k?: number;
+  threshold?: number;
+  filter?: {
+    type?: MemoryType;
+    tags?: string[];
+    agentId?: string;
+  };
+}
+
+/**
+ * Vector search result
+ */
+export interface IVectorSearchResult {
+  entry: IMemoryEntry;
+  score: number;
+  distance: number;
+}
+
+/**
+ * Memory backend interface for storage operations
+ */
+export interface IMemoryBackend {
+  /**
+   * Initialize the backend
+   */
+  initialize(): Promise<void>;
+
+  /**
+   * Shutdown the backend
+   */
+  shutdown(): Promise<void>;
+
+  /**
+   * Store a memory entry
+   */
+  store(entry: IMemoryEntryCreate): Promise<IMemoryEntry>;
+
+  /**
+   * Retrieve a memory entry by key
+   */
+  retrieve(key: string): Promise<IMemoryEntry | undefined>;
+
+  /**
+   * Retrieve by ID
+   */
+  retrieveById(id: string): Promise<IMemoryEntry | undefined>;
+
+  /**
+   * Update a memory entry
+   */
+  update(key: string, value: unknown, metadata?: Partial<IMemoryEntry['metadata']>): Promise<IMemoryEntry | undefined>;
+
+  /**
+   * Delete a memory entry
+   */
+  delete(key: string): Promise<boolean>;
+
+  /**
+   * Check if a key exists
+   */
+  exists(key: string): Promise<boolean>;
+
+  /**
+   * List all keys matching a pattern
+   */
+  keys(pattern?: string): Promise<string[]>;
+
+  /**
+   * Get all entries matching filter
+   */
+  list(filter?: { type?: MemoryType; tags?: string[] }): Promise<IMemoryEntry[]>;
+
+  /**
+   * Clear all entries
+   */
+  clear(): Promise<void>;
+
+  /**
+   * Get entry count
+   */
+  count(): Promise<number>;
+
+  /**
+   * Prune expired entries
+   */
+  prune(): Promise<number>;
+
+  /**
+   * Get health status
+   */
+  getHealthStatus(): Promise<{ healthy: boolean; error?: string; metrics?: Record<string, number> }>;
+}
+
+/**
+ * Vector memory backend for similarity search
+ */
+export interface IVectorMemoryBackend extends IMemoryBackend {
+  /**
+   * Store with embedding
+   */
+  storeVector(entry: IMemoryEntryCreate & { embedding: number[] }): Promise<IMemoryEntry>;
+
+  /**
+   * Search by vector similarity
+   */
+  search(params: IVectorSearchParams): Promise<IVectorSearchResult[]>;
+
+  /**
+   * Update embedding for an entry
+   */
+  updateEmbedding(key: string, embedding: number[]): Promise<boolean>;
+
+  /**
+   * Build or rebuild index
+   */
+  buildIndex(): Promise<void>;
+
+  /**
+   * Get index statistics
+   */
+  getIndexStats(): Promise<{
+    vectorCount: number;
+    dimensions: number;
+    indexType: string;
+    memoryUsageMb: number;
+  }>;
+}
+
+/**
+ * Memory bank for agent-specific storage
+ */
+export interface IMemoryBank {
+  readonly id: string;
+  readonly agentId: string;
+  readonly createdAt: Date;
+
+  /**
+   * Store in bank
+   */
+  store(key: string, value: unknown, options?: Partial<IMemoryEntryCreate>): Promise<IMemoryEntry>;
+
+  /**
+   * Retrieve from bank
+   */
+  retrieve(key: string): Promise<IMemoryEntry | undefined>;
+
+  /**
+   * Delete from bank
+   */
+  delete(key: string): Promise<boolean>;
+
+  /**
+   * List all entries in bank
+   */
+  list(): Promise<IMemoryEntry[]>;
+
+  /**
+   * Clear all entries in bank
+   */
+  clear(): Promise<void>;
+
+  /**
+   * Get bank size
+   */
+  size(): Promise<number>;
+
+  /**
+   * Close the bank
+   */
+  close(): Promise<void>;
+}
+
+/**
+ * Memory manager interface
+ */
+export interface IMemoryManager {
+  /**
+   * Initialize the manager
+   */
+  initialize(): Promise<void>;
+
+  /**
+   * Shutdown the manager
+   */
+  shutdown(): Promise<void>;
+
+  /**
+   * Create a memory bank for an agent
+   */
+  createBank(agentId: string): Promise<string>;
+
+  /**
+   * Get a memory bank
+   */
+  getBank(bankId: string): IMemoryBank | undefined;
+
+  /**
+   * Close a memory bank
+   */
+  closeBank(bankId: string): Promise<void>;
+
+  /**
+   * Store in global memory
+   */
+  store(entry: IMemoryEntryCreate): Promise<IMemoryEntry>;
+
+  /**
+   * Retrieve from global memory
+   */
+  retrieve(key: string): Promise<IMemoryEntry | undefined>;
+
+  /**
+   * Search vectors (if vector backend available)
+   */
+  searchVectors?(params: IVectorSearchParams): Promise<IVectorSearchResult[]>;
+
+  /**
+   
+
+--- src/core/interfaces/task.interface.ts ---
+/**
+ * V3 Task Interfaces
+ * Domain-Driven Design - Task Bounded Context
+ */
+
+/**
+ * Task priority levels
+ */
+export type TaskPriority = 'critical' | 'high' | 'medium' | 'low';
+
+/**
+ * Task status throughout its lifecycle
+ */
+export type TaskStatus =
+  | 'pending'
+  | 'queued'
+  | 'assigned'
+  | 'running'
+  | 'completed'
+  | 'failed'
+  | 'cancelled'
+  | 'timeout';
+
+/**
+ * Core task entity
+ */
+export interface ITask {
+  readonly id: string;
+  readonly type: string;
+  readonly description: string;
+  readonly priority: number;
+  readonly createdAt: Date;
+
+  status: TaskStatus;
+  assignedAgent?: string;
+  startedAt?: Date;
+  completedAt?: Date;
+  timeout?: number;
+
+  input?: Record<string, unknown>;
+  output?: Record<string, unknown>;
+  error?: Error;
+
+  metadata?: {
+    requiredCapabilities?: string[];
+    retryCount?: number;
+    maxRetries?: number;
+    critical?: boolean;
+    parentTaskId?: string;
+    childTaskIds?: string[];
+    tags?: string[];
+    [key: string]: unknown;
+  };
+}
+
+/**
+ * Task creation parameters
+ */
+export interface ITaskCreate {
+  type: string;
+  description: string;
+  priority?: number;
+  timeout?: number;
+  assignedAgent?: string;
+  input?: Record<string, unknown>;
+  metadata?: ITask['metadata'];
+}
+
+/**
+ * Task result after completion
+ */
+export interface ITaskResult {
+  taskId: string;
+  success: boolean;
+  output?: Record<string, unknown>;
+  error?: Error;
+  duration: number;
+  agentId?: string;
+  metrics?: {
+    tokensUsed?: number;
+    memoryPeakMb?: number;
+    retryCount?: number;
+  };
+}
+
+/**
+ * Task queue interface for managing task ordering and processing
+ */
+export interface ITaskQueue {
+  /**
+   * Add a task to the queue
+   */
+  enqueue(task: ITask): Promise<void>;
+
+  /**
+   * Remove and return the highest priority task
+   */
+  dequeue(): Promise<ITask | undefined>;
+
+  /**
+   * Peek at the next task without removing it
+   */
+  peek(): Promise<ITask | undefined>;
+
+  /**
+   * Get the current queue size
+   */
+  size(): number;
+
+  /**
+   * Check if the queue is empty
+   */
+  isEmpty(): boolean;
+
+  /**
+   * Clear all tasks from the queue
+   */
+  clear(): Promise<void>;
+
+  /**
+   * Get all queued tasks (for inspection)
+   */
+  getAll(): Promise<ITask[]>;
+
+  /**
+   * Remove a specific task by ID
+   */
+  remove(taskId: string): Promise<boolean>;
+
+  /**
+   * Update task priority
+   */
+  updatePriority(taskId: string, priority: number): Promise<boolean>;
+}
+
+/**
+ * Task manager interface for lifecycle management
+ */
+export interface ITaskManager {
+  /**
+   * Create a new task
+   */
+  createTask(params: ITaskCreate): Promise<ITask>;
+
+  /**
+   * Get a task by ID
+   */
+  getTask(taskId: string): ITask | undefined;
+
+  /**
+   * Get all tasks matching optional filter
+   */
+  getTasks(filter?: Partial<Pick<ITask, 'status' | 'type' | 'assignedAgent'>>): ITask[];
+
+  /**
+   * Assign a task to an agent
+   */
+  assignTask(taskId: string, agentId: string): Promise<void>;
+
+  /**
+   * Start task execution
+   */
+  startTask(taskId: string): Promise<void>;
+
+  /**
+   * Complete a task with result
+   */
+  completeTask(taskId: string, result: ITaskResult): Promise<void>;
+
+  /**
+   * Fail a task with error
+   */
+  failTask(taskId: string, error: Error): Promise<void>;
+
+  /**
+   * Cancel a task
+   */
+  cancelTask(taskId: string, reason?: string): Promise<void>;
+
+  /**
+   * Retry a failed task
+   */
+  retryTask(taskId: string): Promise<void>;
+
+  /**
+   * Get task metrics
+   */
+  getMetrics(): TaskManagerMetrics;
+
+  /**
+   * Clean up old completed/failed tasks
+   */
+  cleanup(olderThan: Date): Promise<number>;
+}
+
+/**
+ * Task manager metrics
+ */
+export interface TaskManagerMetrics {
+  totalTasks: number;
+  pendingTasks: number;
+  runningTasks: number;
+  completedTasks: number;
+  failedTasks: number;
+  cancelledTasks: number;
+  avgDuration: number;
+  avgWaitTime: number;
+}
+
+/**
+ * Task assignment strategy interface
+ */
+export interface ITaskAssignmentStrategy {
+  /**
+   * Select the best agent for a task
+   */
+  selectAgent(task: ITask, availableAgents: string[]): Promise<string | undefined>;
+
+  /**
+   * Score an agent for a task (higher is better)
+   */
+  scoreAgent(task: ITask, agentId: string): Promise<number>;
+}
+
+
+--- src/core/orchestrator/event-coordinator.ts ---
+/**
+ * V3 Event Coordinator
+ * Decomposed from orchestrator.ts - Event routing
+ * ~100 lines (target achieved)
+ */
+
+import type {
+  IEvent,
+  IEventBus,
+  IEventHandler,
+  IEventCoordinator,
+} from '../interfaces/event.interface.js';
+import { SystemEventTypes } from '../interfaces/event.interface.js';
+
+/**
+ * Event coordinator implementation
+ */
+export class EventCoordinator implements IEventCoordinator {
+  private handlers = new Map<string, Set<IEventHandler>>();
+  private initialized = false;
+
+  constructor(private eventBus: IEventBus) {}
+
+  async initialize(): Promise<void> {
+    if (this.initialized) {
+      return;
+    }
+
+    // Register default system event handlers
+    this.registerSystemHandlers();
+
+    this.initialized = true;
+  }
+
+  async shutdown(): Promise<void> {
+    // Clear all handlers
+    this.handlers.clear();
+    this.initialized = false;
+  }
+
+  async route(event: IEvent): Promise<void> {
+    const handlers = this.handlers.get(event.type);
+    if (!handlers || handlers.size === 0) {
+      return;
+    }
+
+    const handlerPromises = Array.from(handlers).map(async handler => {
+      try {
+        await handler(event);
+      } catch (error) {
+        // Log error but don't throw
+        console.error(`Error in event handler for ${event.type}:`, error);
+      }
+    });
+
+    await Promise.allSettled(handlerPromises);
+  }
+
+  registerHandler(type: string, handler: IEventHandler): void {
+    let handlers = this.handlers.get(type);
+    if (!handlers) {
+      handlers = new Set();
+      this.handlers.set(type, handlers);
+    }
+    handlers.add(handler);
+
+    // Also register with event bus
+    this.eventBus.on(type, handler);
+  }
+
+  unregisterHandler(type: string, handler: IEventHandler): void {
+    const handlers = this.handlers.get(type);
+    if (handlers) {
+      handlers.delete(handler);
+      if (handlers.size === 0) {
+        this.handlers.delete(type);
+      }
+    }
+
+    // Also unregister from event bus
+    this.eventBus.off(type, handler);
+  }
+
+  getEventBus(): IEventBus {
+    return this.eventBus;
+  }
+
+  private registerSystemHandlers(): void {
+    // Error handling
+    this.eventBus.on(SystemEventTypes.SYSTEM_ERROR, (event: IEvent) => {
+      const { error, component } = event.payload as { error: Error; component: string };
+      console.error(`System error in ${component}:`, error);
+    });
+
+    // Deadlock detection
+    this.eventBus.on(SystemEventTypes.DEADLOCK_DETECTED, (event: IEvent) => {
+      const { agents, resources } = event.payload as { agents: string[]; resources: string[] };
+      console.warn('Deadlock detected:', { agents, resources });
+    });
+  }
+
+  /**
+   * Get registered handler count for a type
+   */
+  getHandlerCount(type: string): number {
+    return this.handlers.get(type)?.size ?? 0;
+  }
+
+  /**
+   * Get all registered event types
+   */
+  getRegisteredTypes(): string[] {
+    return Array.from(this.handlers.keys());
+  }
+
+  /**
+   * Check if coordinator is initialized
+   */
+  isInitialized(): boolean {
+    return this.initialized;
+  }
+}
+
+
+--- src/core/orchestrator/health-monitor.ts (truncated) ---
+/**
+ * V3 Health Monitor
+ * Decomposed from orchestrator.ts - Agent health checks
+ * ~150 lines (target achieved)
+ */
+
+import type {
+  IHealthMonitor,
+  IHealthStatus,
+  IComponentHealth,
+} from '../interfaces/coordinator.interface.js';
+import type { IEventBus } from '../interfaces/event.interface.js';
+import { SystemEventTypes } from '../interfaces/event.interface.js';
+
+/**
+ * Health check function type
+ */
+export type HealthCheckFn = () => Promise<{
+  healthy: boolean;
+  error?: string;
+  metrics?: Record<string, number>;
+}>;
+
+/**
+ * Health monitor configuration
+ */
+export interface HealthMonitorConfig {
+  checkInterval: number;
+  historyLimit: number;
+  degradedThreshold: number;
+  unhealthyThreshold: number;
+}
+
+/**
+ * Health monitor implementation
+ */
+export class HealthMonitor implements IHealthMonitor {
+  private checks = new Map<string, HealthCheckFn>();
+  private history: IHealthStatus[] = [];
+  private interval?: ReturnType<typeof setInterval>;
+  private listeners: Array<(status: IHealthStatus) => void> = [];
+  private running = false;
+
+  constructor(
+    private eventBus: IEventBus,
+    private config: HealthMonitorConfig = {
+      checkInterval: 30000,
+      historyLimit: 100,
+      degradedThreshold: 1,
+      unhealthyThreshold: 2,
+    },
+  ) {}
+
+  start(): void {
+    if (this.running) {
+      return;
+    }
+
+    this.running = true;
+    this.interval = setInterval(async () => {
+      const status = await this.getStatus();
+      this.addToHistory(status);
+      this.notifyListeners(status);
+      this.eventBus.emit(SystemEventTypes.SYSTEM_HEALTHCHECK, { status });
+    }, this.config.checkInterval);
+  }
+
+  stop(): void {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = undefined;
+    }
+    this.running = false;
+  }
+
+  async getStatus(): Promise<IHealthStatus> {
+    const components: Record<string, IComponentHealth> = {};
+    let unhealthyCount = 0;
+    let degradedCount = 0;
+
+    const checkPromises = Array.from(this.checks.entries()).map(
+      async ([name, check]) => {
+        try {
+          const result = await Promise.race([
+            check(),
+            this.timeout(5000, 'Health check timeout'),
+          ]);
+
+          const health: IComponentHealth = {
+            name,
+            status: result.healthy ? 'healthy' : 'unhealthy',
+            lastCheck: new Date(),
+            error: result.error,
+            metrics: result.metrics,
+          };
+
+          return { name, health };
+        } catch (error) {
+          return {
+            name,
+            health: {
+              name,
+              status: 'unhealthy' as const,
+              lastCheck: new Date(),
+              error: error instanceof Error ? error.message : 'Unknown error',
+            },
+          };
+        }
+      },
+    );
+
+    const results = await Promise.allSettled(checkPromises);
+
+    for (const result of results) {
+      if (result.status === 'fulfilled') {
+        const { name, health } = result.value;
+        components[name] = health;
+
+        if (health.status === 'unhealthy') {
+          unhealthyCount++;
+        } else if (health.status === 'degraded') {
+          degradedCount++;
+        }
+      }
+    }
+
+    let overallStatus: IHealthStatus['status'] = 'healthy';
+    if (unhealthyCount >= this.config.unhealthyThreshold) {
+      overallStatus = 'unhealthy';
+    } else if (
+      unhealthyCount > 0 ||
+      degradedCount >= this.config.degradedThreshold
+    ) {
+      overallStatus = 'degraded';
+    }
+
+    return {
+      status: overallStatus,
+      components,
+      timestamp: new Date(),
+    };
+  }
+
+  registerCheck(name: string, check: HealthCheckFn): void {
+    this.checks.set(name, check);
+  }
+
+  unregisterCheck(name: string): void {
+    this.checks.delete(name);
+  }
+
+  getHistory(limit?: number): IHealthStatus[] {
+    const count = limit ?? this.config.historyLimit;
+    return this.history.slice(-count);
+  }
+
+  onHealthChange(callback: (status: IHealthStatus) => void): () => void {
+    this.listeners.push(callback);
+    return () => {
+      const index = this.listeners.indexOf(callback);
+      if (index !== -1) {
+        this.listeners.splice(index, 1);
+      }
+    };
+  }
+
+  private addToHistory(status: IHealthStatus): void {
+    this.history.push(status);
+
+    // Trim history to limit
+    if (this.history.length > this.config.historyLimit) {
+      this.history = this.history.slice(-this.config.historyLimit);
+    }
+  }
+
+  private notifyListeners(status: IHealthStatus): void {
+    for (const listener of this.listeners) {
+      try {
+        listener(status);
+      } catch {
+        // Ignore listener errors
+      }
+    }
+  }
+
+  private timeout(ms: number, message: string): Promise<never> {
+    return new Promise((_, reject) => {
+      setTimeout(() => reject(new Error(message)), ms);
+    });
+  }
+
+  /**
+   * Get component health by name
+   */
+  async getComponentHealth(name: string): Promise<IComponentHealth | undefined> {
+    const status = await this.getStatus();
+  
+
+--- src/core/orchestrator/index.ts ---
+/**
+ * V3 Orchestrator Facade
+ * Unified interface to decomposed orchestrator components
+ * ~50 lines (target achieved)
+ */
+
+import type { IOrchestrator, IHealthStatus, IOrchestratorMetrics } from '../interfaces/coordinator.interface.js';
+import type { ITask, ITaskCreate, ITaskResult } from '../interfaces/task.interface.js';
+import type { IAgent, IAgentConfig } from '../interfaces/agent.interface.js';
+import type { IEventBus } from '../interfaces/event.interface.js';
+
+import { TaskManager } from './task-manager.js';
+import { SessionManager, type ISessionManager, type SessionManagerConfig } from './session-manager.js';
+import { HealthMonitor, type HealthMonitorConfig } from './health-monitor.js';
+import { LifecycleManager, type LifecycleManagerConfig } from './lifecycle-manager.js';
+import { EventCoordinator } from './event-coordinator.js';
+import { EventBus } from '../event-bus.js';
+
+export * from './task-manager.js';
+export * from './session-manager.js';
+export * from './health-monitor.js';
+export * from './lifecycle-manager.js';
+export * from './event-coordinator.js';
+
+/**
+ * Orchestrator facade configuration
+ * (Note: For schema-validated config, use OrchestratorConfig from config/schema.ts)
+ */
+export interface OrchestratorFacadeConfig {
+  session: SessionManagerConfig;
+  health: HealthMonitorConfig;
+  lifecycle: LifecycleManagerConfig;
+}
+
+/**
+ * Default orchestrator facade configuration
+ */
+export const defaultOrchestratorFacadeConfig: OrchestratorFacadeConfig = {
+  session: {
+    persistSessions: true,
+    dataDir: './data',
+    sessionRetentionMs: 3600000,
+  },
+  health: {
+    checkInterval: 30000,
+    historyLimit: 100,
+    degradedThreshold: 1,
+    unhealthyThreshold: 2,
+  },
+  lifecycle: {
+    maxConcurrentAgents: 20,
+    spawnTimeout: 30000,
+    terminateTimeout: 10000,
+    maxSpawnRetries: 3,
+  },
+};
+
+/**
+ * Create orchestrator components
+ */
+export function createOrchestrator(config: Partial<OrchestratorFacadeConfig> = {}) {
+  const mergedConfig: OrchestratorFacadeConfig = {
+    session: { ...defaultOrchestratorFacadeConfig.session, ...config.session },
+    health: { ...defaultOrchestratorFacadeConfig.health, ...config.health },
+    lifecycle: { ...defaultOrchestratorFacadeConfig.lifecycle, ...config.lifecycle },
+  };
+
+  const eventBus = new EventBus();
+  const taskManager = new TaskManager(eventBus);
+  const sessionManager = new SessionManager(eventBus, mergedConfig.session);
+  const healthMonitor = new HealthMonitor(eventBus, mergedConfig.health);
+  const lifecycleManager = new LifecycleManager(eventBus, mergedConfig.lifecycle);
+  const eventCoordinator = new EventCoordinator(eventBus);
+
+  return {
+    eventBus,
+    taskManager,
+    sessionManager,
+    healthMonitor,
+    lifecycleManager,
+    eventCoordinator,
+    config: mergedConfig,
+  };
+}
+
+/**
+ * Orchestrator type for facade
+ */
+export type OrchestratorComponents = ReturnType<typeof createOrchestrator>;
+
+
+--- src/core/orchestrator/lifecycle-manager.ts (truncated) ---
+/**
+ * V3 Lifecycle Manager
+ * Decomposed from orchestrator.ts - Agent spawn/terminate
+ * ~150 lines (target achieved)
+ */
+
+import type {
+  IAgent,
+  IAgentConfig,
+  IAgentLifecycleManager,
+  IAgentPool,
+  AgentStatus,
+} from '../interfaces/agent.interface.js';
+import type { IEventBus } from '../interfaces/event.interface.js';
+import { SystemEventTypes } from '../interfaces/event.interface.js';
+
+/**
+ * Agent pool implementation
+ */
+export class AgentPool implements IAgentPool {
+  private agents = new Map<string, IAgent>();
+
+  add(agent: IAgent): void {
+    this.agents.set(agent.id, agent);
+  }
+
+  remove(agentId: string): boolean {
+    return this.agents.delete(agentId);
+  }
+
+  get(agentId: string): IAgent | undefined {
+    return this.agents.get(agentId);
+  }
+
+  getAll(): IAgent[] {
+    return Array.from(this.agents.values());
+  }
+
+  getByStatus(status: AgentStatus): IAgent[] {
+    return this.getAll().filter(agent => agent.status === status);
+  }
+
+  getByType(type: string): IAgent[] {
+    return this.getAll().filter(agent => agent.type === type);
+  }
+
+  getAvailable(): IAgent[] {
+    return this.getAll().filter(
+      agent =>
+        (agent.status === 'active' || agent.status === 'idle') &&
+        agent.currentTaskCount < agent.config.maxConcurrentTasks,
+    );
+  }
+
+  size(): number {
+    return this.agents.size;
+  }
+
+  hasCapacity(maxSize: number): boolean {
+    return this.agents.size < maxSize;
+  }
+
+  clear(): void {
+    this.agents.clear();
+  }
+}
+
+/**
+ * Lifecycle manager configuration
+ */
+export interface LifecycleManagerConfig {
+  maxConcurrentAgents: number;
+  spawnTimeout: number;
+  terminateTimeout: number;
+  maxSpawnRetries: number;
+}
+
+/**
+ * Lifecycle manager implementation
+ */
+export class LifecycleManager implements IAgentLifecycleManager {
+  private pool: IAgentPool;
+
+  constructor(
+    private eventBus: IEventBus,
+    private config: LifecycleManagerConfig,
+    pool?: IAgentPool,
+  ) {
+    this.pool = pool ?? new AgentPool();
+  }
+
+  async spawn(config: IAgentConfig): Promise<IAgent> {
+    // Validate capacity
+    if (!this.pool.hasCapacity(this.config.maxConcurrentAgents)) {
+      throw new Error('Maximum concurrent agents reached');
+    }
+
+    // Validate agent doesn't already exist
+    if (this.pool.get(config.id)) {
+      throw new Error(`Agent with ID ${config.id} already exists`);
+    }
+
+    const agent: IAgent = {
+      id: config.id,
+      name: config.name,
+      type: config.type,
+      config,
+      createdAt: new Date(),
+      status: 'spawning',
+      currentTaskCount: 0,
+      lastActivity: new Date(),
+      metrics: {
+        tasksCompleted: 0,
+        tasksFailed: 0,
+        avgTaskDuration: 0,
+        errorCount: 0,
+        uptime: 0,
+      },
+    };
+
+    // Add to pool
+    this.pool.add(agent);
+
+    // Mark as active
+    agent.status = 'active';
+
+    this.eventBus.emit(SystemEventTypes.AGENT_SPAWNED, {
+      agentId: agent.id,
+      profile: config,
+      sessionId: undefined,
+    });
+
+    return agent;
+  }
+
+  async spawnBatch(configs: IAgentConfig[]): Promise<Map<string, IAgent>> {
+    const results = new Map<string, IAgent>();
+
+    // Check total capacity
+    if (this.pool.size() + configs.length > this.config.maxConcurrentAgents) {
+      throw new Error('Batch would exceed maximum concurrent agents');
+    }
+
+    // Spawn in parallel
+    const spawnPromises = configs.map(async config => {
+      try {
+        const agent = await this.spawn(config);
+        return { id: config.id, agent, error: null };
+      } catch (error) {
+        return { id: config.id, agent: null, error };
+      }
+    });
+
+    const settled = await Promise.allSettled(spawnPromises);
+
+    for (const result of settled) {
+      if (result.status === 'fulfilled' && result.value.agent) {
+        results.set(result.value.id, result.value.agent);
+      }
+    }
+
+    return results;
+  }
+
+  async terminate(agentId: string, reason?: string): Promise<void> {
+    const agent = this.pool.get(agentId);
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentId}`);
+    }
+
+    agent.status = 'terminated';
+
+    // Remove from pool
+    this.pool.remove(agentId);
+
+    this.eventBus.emit(SystemEventTypes.AGENT_TERMINATED, {
+      agentId,
+      reason: reason ?? 'User requested',
+    });
+  }
+
+  async terminateAll(reason?: string): Promise<void> {
+    const agents = this.pool.getAll();
+    await Promise.allSettled(
+      agents.map(agent => this.terminate(agent.id, reason)),
+    );
+  }
+
+  async restart(agentId: string): Promise<IAgent> {
+    const agent = this.pool.get(agentId);
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentId}`);
+    }
+
+    const config = agent.config;
+    await this.terminate(agentId, 'Restart requested');
+    return this.spawn(config);
+  }
+
+  async updateConfig(agentId: string, config: Partial<IAgentConfig>): Promise<void> {
+    const agent = this.pool.get(agentId);
+    if (!agent) {
+      throw new Error(`Agent not found: ${agentId}`);
+    }
+
+    Object.assign(agent.config,
+
+--- src/core/orchestrator/session-manager.ts (truncated) ---
+/**
+ * V3 Session Manager
+ * Decomposed from orchestrator.ts - Session handling
+ * ~200 lines (target achieved)
+ */
+
+import type { IAgentSession } from '../interfaces/agent.interface.js';
+import type { IEventBus } from '../interfaces/event.interface.js';
+import { SystemEventTypes } from '../interfaces/event.interface.js';
+import type { AgentProfile } from '../../types/agent.types.js';
+import { mkdir, writeFile, readFile } from 'fs/promises';
+import { join, dirname } from 'path';
+import { randomBytes } from 'crypto';
+
+// Secure session ID generation
+function generateSecureSessionId(): string {
+  const timestamp = Date.now().toString(36);
+  const random = randomBytes(12).toString('hex');
+  return `session_${timestamp}_${random}`;
+}
+
+/**
+ * Session persistence structure
+ */
+export interface SessionPersistence {
+  sessions: Array<IAgentSession & { profile: AgentProfile }>;
+  metrics: {
+    completedTasks: number;
+    failedTasks: number;
+    totalTaskDuration: number;
+  };
+  savedAt: Date;
+}
+
+/**
+ * Session manager configuration
+ */
+export interface SessionManagerConfig {
+  persistSessions: boolean;
+  dataDir: string;
+  sessionRetentionMs?: number;
+}
+
+/**
+ * Session manager interface
+ */
+export interface ISessionManager {
+  createSession(profile: AgentProfile, terminalId: string, memoryBankId: string): Promise<IAgentSession>;
+  getSession(sessionId: string): IAgentSession | undefined;
+  getActiveSessions(): IAgentSession[];
+  getSessionsByAgent(agentId: string): IAgentSession[];
+  terminateSession(sessionId: string): Promise<void>;
+  terminateAllSessions(): Promise<void>;
+  persistSessions(): Promise<void>;
+  restoreSessions(): Promise<SessionPersistence | null>;
+  removeSession(sessionId: string): void;
+  updateSessionActivity(sessionId: string): void;
+}
+
+/**
+ * Session manager implementation
+ */
+export class SessionManager implements ISessionManager {
+  private sessions = new Map<string, IAgentSession>();
+  private sessionProfiles = new Map<string, AgentProfile>();
+  private persistencePath: string;
+
+  constructor(
+    private eventBus: IEventBus,
+    private config: SessionManagerConfig,
+  ) {
+    this.persistencePath = join(config.dataDir || './data', 'sessions.json');
+  }
+
+  async createSession(
+    profile: AgentProfile,
+    terminalId: string,
+    memoryBankId: string,
+  ): Promise<IAgentSession> {
+    const session: IAgentSession = {
+      id: generateSecureSessionId(),
+      agentId: profile.id,
+      terminalId,
+      startTime: new Date(),
+      status: 'active',
+      lastActivity: new Date(),
+      memoryBankId,
+    };
+
+    this.sessions.set(session.id, session);
+    this.sessionProfiles.set(session.id, profile);
+
+    this.eventBus.emit(SystemEventTypes.SESSION_CREATED, {
+      sessionId: session.id,
+      agentId: profile.id,
+      terminalId,
+      memoryBankId,
+    });
+
+    // Persist sessions asynchronously
+    this.persistSessions().catch(() => {
+      // Silently ignore persistence errors
+    });
+
+    return session;
+  }
+
+  getSession(sessionId: string): IAgentSession | undefined {
+    return this.sessions.get(sessionId);
+  }
+
+  getActiveSessions(): IAgentSession[] {
+    return Array.from(this.sessions.values()).filter(
+      session => session.status === 'active' || session.status === 'idle',
+    );
+  }
+
+  getSessionsByAgent(agentId: string): IAgentSession[] {
+    return Array.from(this.sessions.values()).filter(
+      session => session.agentId === agentId,
+    );
+  }
+
+  async terminateSession(sessionId: string): Promise<void> {
+    const session = this.sessions.get(sessionId);
+    if (!session) {
+      throw new Error(`Session not found: ${sessionId}`);
+    }
+
+    session.status = 'terminated';
+    session.endTime = new Date();
+
+    const duration = session.endTime.getTime() - session.startTime.getTime();
+
+    this.eventBus.emit(SystemEventTypes.SESSION_TERMINATED, {
+      sessionId,
+      agentId: session.agentId,
+      duration,
+    });
+
+    // Clean up profile reference
+    this.sessionProfiles.delete(sessionId);
+
+    // Persist sessions asynchronously
+    this.persistSessions().catch(() => {
+      // Silently ignore persistence errors
+    });
+  }
+
+  async terminateAllSessions(): Promise<void> {
+    const sessions = this.getActiveSessions();
+    const batchSize = 5;
+
+    for (let i = 0; i < sessions.length; i += batchSize) {
+      const batch = sessions.slice(i, i + batchSize);
+      await Promise.allSettled(
+        batch.map(session => this.terminateSession(session.id)),
+      );
+    }
+  }
+
+  removeSession(sessionId: string): void {
+    this.sessions.delete(sessionId);
+    this.sessionProfiles.delete(sessionId);
+  }
+
+  updateSessionActivity(sessionId: string): void {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      session.lastActivity = new Date();
+    }
+  }
+
+  async persistSessions(): Promise<void> {
+    if (!this.config.persistSessions) {
+      return;
+    }
+
+    try {
+      const data: SessionPersistence = {
+        sessions: Array.from(this.sessions.valu
+
+--- src/core/orchestrator/task-manager.ts (truncated) ---
+/**
+ * V3 Task Manager
+ * Decomposed from orchestrator.ts - Task lifecycle management
+ * ~200 lines (target achieved)
+ */
+
+import type {
+  ITask,
+  ITaskCreate,
+  ITaskResult,
+  ITaskManager,
+  ITaskQueue,
+  TaskManagerMetrics,
+  TaskStatus,
+} from '../interfaces/task.interface.js';
+import type { IEventBus, SystemEventType } from '../interfaces/event.interface.js';
+import { SystemEventTypes } from '../interfaces/event.interface.js';
+import { randomBytes } from 'crypto';
+
+// Secure task ID generation
+function generateSecureTaskId(): string {
+  const timestamp = Date.now().toString(36);
+  const random = randomBytes(12).toString('hex');
+  return `task_${timestamp}_${random}`;
+}
+
+/**
+ * Priority queue implementation for tasks
+ */
+export class TaskQueue implements ITaskQueue {
+  private tasks: ITask[] = [];
+
+  async enqueue(task: ITask): Promise<void> {
+    this.tasks.push(task);
+    this.tasks.sort((a, b) => b.priority - a.priority);
+  }
+
+  async dequeue(): Promise<ITask | undefined> {
+    return this.tasks.shift();
+  }
+
+  async peek(): Promise<ITask | undefined> {
+    return this.tasks[0];
+  }
+
+  size(): number {
+    return this.tasks.length;
+  }
+
+  isEmpty(): boolean {
+    return this.tasks.length === 0;
+  }
+
+  async clear(): Promise<void> {
+    this.tasks = [];
+  }
+
+  async getAll(): Promise<ITask[]> {
+    return [...this.tasks];
+  }
+
+  async remove(taskId: string): Promise<boolean> {
+    const index = this.tasks.findIndex(t => t.id === taskId);
+    if (index !== -1) {
+      this.tasks.splice(index, 1);
+      return true;
+    }
+    return false;
+  }
+
+  async updatePriority(taskId: string, priority: number): Promise<boolean> {
+    const task = this.tasks.find(t => t.id === taskId);
+    if (task) {
+      (task as { priority: number }).priority = priority;
+      this.tasks.sort((a, b) => b.priority - a.priority);
+      return true;
+    }
+    return false;
+  }
+}
+
+/**
+ * Task manager implementation
+ */
+export class TaskManager implements ITaskManager {
+  private tasks = new Map<string, ITask>();
+  private queue: ITaskQueue;
+  private metrics = {
+    totalTasks: 0,
+    completedTasks: 0,
+    failedTasks: 0,
+    cancelledTasks: 0,
+    totalDuration: 0,
+    totalWaitTime: 0,
+  };
+
+  constructor(
+    private eventBus: IEventBus,
+    queue?: ITaskQueue,
+  ) {
+    this.queue = queue ?? new TaskQueue();
+  }
+
+  async createTask(params: ITaskCreate): Promise<ITask> {
+    const task: ITask = {
+      id: generateSecureTaskId(),
+      type: params.type,
+      description: params.description,
+      priority: params.priority ?? 50,
+      createdAt: new Date(),
+      status: 'pending',
+      timeout: params.timeout,
+      assignedAgent: params.assignedAgent,
+      input: params.input,
+      metadata: params.metadata,
+    };
+
+    this.tasks.set(task.id, task);
+    this.metrics.totalTasks++;
+
+    this.eventBus.emit(SystemEventTypes.TASK_CREATED, { task });
+
+    return task;
+  }
+
+  getTask(taskId: string): ITask | undefined {
+    return this.tasks.get(taskId);
+  }
+
+  getTasks(filter?: Partial<Pick<ITask, 'status' | 'type' | 'assignedAgent'>>): ITask[] {
+    let tasks = Array.from(this.tasks.values());
+
+    if (filter) {
+      if (filter.status) {
+        tasks = tasks.filter(t => t.status === filter.status);
+      }
+      if (filter.type) {
+        tasks = tasks.filter(t => t.type === filter.type);
+      }
+      if (filter.assignedAgent) {
+        tasks = tasks.filter(t => t.assignedAgent === filter.assignedAgent);
+      }
+    }
+
+    return tasks;
+  }
+
+  async assignTask(taskId: string, agentId: string): Promise<void> {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      throw new Error(`Task not found: ${taskId}`);
+    }
+
+    task.assignedAgent = agentId;
+    task.status = 'assigned';
+
+    this.eventBus.emit(SystemEventTypes.TASK_ASSIGNED, {
+      taskId,
+      agentId,
+    });
+  }
+
+  async startTask(taskId: string): Promise<void> {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      throw new Error(`Task not found: ${taskId}`);
+    }
+
+    task.status = 'running';
+    task.startedAt = new Date();
+
+    // Calculate wait time
+    const waitTime = task.startedAt.getTime() - task.createdAt.getTime();
+    this.metrics.totalWaitTime += waitTime;
+
+    this.eventBus.emit(SystemEventTypes.TASK_STARTED, {
+      taskId,
+      agentId: task.assignedAgent,
+      startTime: task.startedAt,
+    });
+  }
+
+  async completeTask(taskId: string, result: ITaskResult): Promise<void> {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      throw new Error(`Task not found: ${taskId}`);
+    }
+
+    task.status = 'completed';
+    task.completedAt = new Date();
+    task.output = result.output;
+
+    this.metrics.completedTasks++;
+    this.metrics.totalDuration += result.duration;
+
+    this.eventBus.emit(SystemEventTypes.TASK_COMPLETED, {
+      taskId,
+      result,
+    });
+  }
+
+  async failTask(taskId: string, error: Error): Promise<void> {
+    const task = this.tasks.get(taskId);
+    if (!task) {
+      throw new Error(`Task n
+
+--- src/events/domain-events.ts (truncated) ---
+/**
+ * Domain Events for Event Sourcing (ADR-007)
+ *
+ * Defines all domain events for the V3 system:
+ * - Agent lifecycle events (spawned, started, stopped, failed)
+ * - Task execution events (created, started, completed, failed)
+ * - Memory operations events (stored, retrieved, deleted)
+ * - Swarm coordination events (initialized, scaled, terminated)
+ *
+ * @module v3/shared/events/domain-events
+ */
+
+import { AgentId, TaskId, EventType, SwarmEvent } from '../types.js';
+
+// =============================================================================
+// Base Domain Event Interface
+// =============================================================================
+
+export interface DomainEvent {
+  /** Unique event identifier */
+  id: string;
+
+  /** Event type discriminator */
+  type: string;
+
+  /** Aggregate ID (entity the event belongs to) */
+  aggregateId: string;
+
+  /** Aggregate type (agent, task, memory, swarm) */
+  aggregateType: 'agent' | 'task' | 'memory' | 'swarm';
+
+  /** Event version for ordering */
+  version: number;
+
+  /** Timestamp when event occurred */
+  timestamp: number;
+
+  /** Event source (agent or swarm system) */
+  source: AgentId | 'swarm';
+
+  /** Event payload data */
+  payload: Record<string, unknown>;
+
+  /** Optional metadata */
+  metadata?: Record<string, unknown>;
+
+  /** Optional causation ID (event that caused this event) */
+  causationId?: string;
+
+  /** Optional correlation ID (groups related events) */
+  correlationId?: string;
+}
+
+// =============================================================================
+// Agent Lifecycle Events
+// =============================================================================
+
+export interface AgentSpawnedEvent extends DomainEvent {
+  type: 'agent:spawned';
+  aggregateType: 'agent';
+  payload: {
+    agentId: AgentId;
+    role: string;
+    domain: string;
+    capabilities: string[];
+  };
+}
+
+export interface AgentStartedEvent extends DomainEvent {
+  type: 'agent:started';
+  aggregateType: 'agent';
+  payload: {
+    agentId: AgentId;
+    startedAt: number;
+  };
+}
+
+export interface AgentStoppedEvent extends DomainEvent {
+  type: 'agent:stopped';
+  aggregateType: 'agent';
+  payload: {
+    agentId: AgentId;
+    reason: string;
+    stoppedAt: number;
+  };
+}
+
+export interface AgentFailedEvent extends DomainEvent {
+  type: 'agent:failed';
+  aggregateType: 'agent';
+  payload: {
+    agentId: AgentId;
+    error: string;
+    stack?: string;
+    failedAt: number;
+  };
+}
+
+export interface AgentStatusChangedEvent extends DomainEvent {
+  type: 'agent:status-changed';
+  aggregateType: 'agent';
+  payload: {
+    agentId: AgentId;
+    previousStatus: string;
+    newStatus: string;
+  };
+}
+
+export interface AgentTaskAssignedEvent extends DomainEvent {
+  type: 'agent:task-assigned';
+  aggregateType: 'agent';
+  payload: {
+    agentId: AgentId;
+    taskId: TaskId;
+    assignedAt: number;
+  };
+}
+
+export interface AgentTaskCompletedEvent extends DomainEvent {
+  type: 'agent:task-completed';
+  aggregateType: 'agent';
+  payload: {
+    agentId: AgentId;
+    taskId: TaskId;
+    result: unknown;
+    completedAt: number;
+    duration: number;
+  };
+}
+
+// =============================================================================
+// Task Execution Events
+// =============================================================================
+
+export interface TaskCreatedEvent extends DomainEvent {
+  type: 'task:created';
+  aggregateType: 'task';
+  payload: {
+    taskId: TaskId;
+    taskType: string;
+    title: string;
+    description: string;
+    priority: string;
+    dependencies: TaskId[];
+    createdAt: number;
+  };
+}
+
+export interface TaskStartedEvent extends DomainEvent {
+  type: 'task:started';
+  aggregateType: 'task';
+  payload: {
+    taskId: TaskId;
+    agentId: AgentId;
+    startedAt: number;
+  };
+}
+
+export interface TaskCompletedEvent extends DomainEvent {
+  type: 'task:completed';
+  aggregateType: 'task';
+  payload: {
+    taskId: TaskId;
+    result: unknown;
+    completedAt: number;
+    duration: number;
+  };
+}
+
+export interface TaskFailedEvent extends DomainEvent {
+  type: 'task:failed';
+  aggregateType: 'task';
+  payload: {
+    taskId: TaskId;
+    error: string;
+    stack?: string;
+    failedAt: number;
+    retryCount: number;
+  };
+}
+
+export interface TaskBlockedEvent extends DomainEvent {
+  type: 'task:blocked';
+  aggregateType: 'task';
+  payload: {
+    taskId: TaskId;
+    blockedBy: TaskId[];
+    blockedAt: number;
+  };
+}
+
+export interface TaskQueuedEvent extends DomainEvent {
+  type: 'task:queued';
+  aggregateType: 'task';
+  payload: {
+    taskId: TaskId;
+    priority: string;
+    queuedAt: number;
+  };
+}
+
+// =============================================================================
+// Memory Operations Events
+// =============================================================================
+
+export interface MemoryStoredEvent extends DomainEvent {
+  type: 'memory:stored';
+  aggregateType: 'memory';
+  payload: {
+    memoryId: string;
+    namespace: string;
+    key: s
+
+## Instructions
+
+Analyze the above codebase context and provide your response following the format specified in the task.