diff --git a/packages/subagents/src/coordinator/coordinator.integration.test.ts b/packages/subagents/src/coordinator/coordinator.integration.test.ts
new file mode 100644
index 0000000..ccc981f
--- /dev/null
+++ b/packages/subagents/src/coordinator/coordinator.integration.test.ts
@@ -0,0 +1,310 @@
+/**
+ * Integration Tests: Coordinator → Explorer
+ * Tests the full flow from Coordinator to Explorer Agent
+ */
+
+import { mkdir, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { RepositoryIndexer } from '@lytics/dev-agent-core';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { ExplorerAgent } from '../explorer';
+import { SubagentCoordinator } from './coordinator';
+
+describe('Coordinator → Explorer Integration', () => {
+  let coordinator: SubagentCoordinator;
+  let explorer: ExplorerAgent;
+  let indexer: RepositoryIndexer;
+  let testVectorPath: string;
+
+  beforeEach(async () => {
+    // Create temporary vector store
+    testVectorPath = join(tmpdir(), `test-vectors-${Date.now()}`);
+    await mkdir(testVectorPath, { recursive: true });
+
+    // Initialize coordinator
+    coordinator = new SubagentCoordinator({
+      logLevel: 'error', // Quiet during tests
+      healthCheckInterval: 0, // Disable periodic checks
+    });
+
+    // Initialize indexer (without indexing - tests will mock/stub as needed)
+    indexer = new RepositoryIndexer({
+      repositoryPath: process.cwd(),
+      vectorStorePath: testVectorPath,
+    });
+    await indexer.initialize();
+
+    // Note: NOT indexing the full repo to avoid OOM in tests
+    // Tests will use the indexer API without real data
+
+    // Set indexer in coordinator context
+    coordinator.getContextManager().setIndexer(indexer);
+
+    // Create and register Explorer
+    explorer = new ExplorerAgent();
+    await coordinator.registerAgent(explorer);
+
+    coordinator.start();
+  });
+
+  afterEach(async () => {
+    await coordinator.stop();
+    await indexer.close();
+    await rm(testVectorPath, { recursive: true, force: true });
+  });
+
+  describe('Agent Registration', () => {
+    it('should register Explorer successfully', () => {
+      const agents = coordinator.getAgents();
+      expect(agents).toContain('explorer');
+    });
+
+    it('should initialize Explorer with context', async () => {
+      // Explorer is initialized but reports unhealthy without indexed data
+      const healthCheck = await explorer.healthCheck();
+      expect(healthCheck).toBe(false); // No vectors stored yet
+
+      // But it's still registered and can receive messages
+      const response = await coordinator.sendMessage({
+        type: 'request',
+        sender: 'test',
+        recipient: 'explorer',
+        payload: { action: 'pattern', query: 'test' },
+      });
+      expect(response).toBeDefined();
+    });
+
+    it('should prevent duplicate registration', async () => {
+      const duplicate = new ExplorerAgent();
+      await expect(coordinator.registerAgent(duplicate)).rejects.toThrow('already registered');
+    });
+  });
+
+  describe('Message Routing', () => {
+    it('should route pattern search request to Explorer', async () => {
+      const response = await coordinator.sendMessage({
+        type: 'request',
+        sender: 'test',
+        recipient: 'explorer',
+        payload: {
+          action: 'pattern',
+          query: 'RepositoryIndexer',
+          limit: 5,
+          threshold: 0.7,
+        },
+      });
+
+      expect(response).toBeDefined();
+      expect(response?.type).toBe('response');
+      expect(response?.sender).toBe('explorer');
+
+      const result = response?.payload as { action: string; results?: unknown[] };
+      expect(result.action).toBe('pattern');
+      // Results array exists (may be empty without indexed data)
+      expect(Array.isArray(result.results)).toBe(true);
+    });
+
+    it('should route similar code request to Explorer', async () => {
+      const response = await coordinator.sendMessage({
+        type: 'request',
+        sender: 'test',
+        recipient: 'explorer',
+        payload: {
+          action: 'similar',
+          content: 'export class RepositoryIndexer { constructor() { } }',
+          limit: 3,
+          threshold: 0.5,
+        },
+      });
+
+      expect(response).toBeDefined();
+      // May be error or response depending on indexer state
+      expect(['response', 'error']).toContain(response?.type);
+
+      if (response?.type === 'response') {
+        const result = response.payload as { action: string; results?: unknown[] };
+        expect(result.action).toBe('similar');
+        expect(Array.isArray(result.results)).toBe(true);
+      }
+    });
+
+    it('should route relationships request to Explorer', async () => {
+      const response = await coordinator.sendMessage({
+        type: 'request',
+        sender: 'test',
+        recipient: 'explorer',
+        payload: {
+          action: 'relationships',
+          component: 'RepositoryIndexer',
+          depth: 1,
+        },
+      });
+
+      expect(response).toBeDefined();
+      expect(response?.type).toBe('response');
+
+      const result = response?.payload as { action: string; relationships?: unknown[] };
+      expect(result.action).toBe('relationships');
+      expect(Array.isArray(result.relationships)).toBe(true);
+    });
+
+    it('should route insights request to Explorer', async () => {
+      const response = await coordinator.sendMessage({
+        type: 'request',
+        sender: 'test',
+        recipient: 'explorer',
+        payload: {
+          action: 'insights',
+          scope: 'repository',
+          includePatterns: true,
+        },
+      });
+
+      expect(response).toBeDefined();
+      expect(response?.type).toBe('response');
+
+      const result = response?.payload as { action: string; insights?: unknown };
+      expect(result.action).toBe('insights');
+      expect(result.insights).toBeDefined();
+    });
+
+    it('should handle unknown actions gracefully', async () => {
+      const response = await coordinator.sendMessage({
+        type: 'request',
+        sender: 'test',
+        recipient: 'explorer',
+        payload: {
+          action: 'unknown-action',
+        },
+      });
+
+      expect(response).toBeDefined();
+      expect(response?.type).toBe('response');
+
+      const result = response?.payload as { error?: string };
+      expect(result.error).toBeDefined();
+      expect(result.error).toContain('Unknown action');
+    });
+
+    it('should handle non-existent agent gracefully', async () => {
+      const response = await coordinator.sendMessage({
+        type: 'request',
+        sender: 'test',
+        recipient: 'non-existent-agent',
+        payload: {},
+      });
+
+      expect(response).toBeDefined();
+      expect(response?.type).toBe('error');
+
+      const error = response?.payload as { error: string };
+      expect(error.error).toContain('not found');
+    });
+  });
+
+  describe('Task Execution', () => {
+    it('should execute pattern search task via task queue', async () => {
+      const taskId = coordinator.submitTask({
+        type: 'pattern-search',
+        agentName: 'explorer',
+        payload: {
+          action: 'pattern',
+          query: 'SubagentCoordinator',
+          limit: 5,
+        },
+        priority: 10,
+      });
+
+      expect(taskId).toBeDefined();
+
+      // Wait for task to complete
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      const task = coordinator.getTask(taskId);
+      expect(task).toBeDefined();
+      expect(task?.status).toBe('completed');
+    });
+
+    it('should track task statistics', async () => {
+      coordinator.submitTask({
+        type: 'insights',
+        agentName: 'explorer',
+        payload: {
+          action: 'insights',
+          scope: 'repository',
+        },
+      });
+
+      await new Promise((resolve) => setTimeout(resolve, 100));
+
+      const stats = coordinator.getStats();
+      expect(stats.tasksCompleted).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Health Checks', () => {
+    it('should report Explorer health status based on indexed data', async () => {
+      // Without indexed data, health check returns false
+      const isHealthy = await explorer.healthCheck();
+      expect(isHealthy).toBe(false);
+
+      // Note: In production with indexed data, this would return true
+    });
+
+    it('should track message statistics', async () => {
+      await coordinator.sendMessage({
+        type: 'request',
+        sender: 'test',
+        recipient: 'explorer',
+        payload: {
+          action: 'pattern',
+          query: 'test',
+        },
+      });
+
+      const stats = coordinator.getStats();
+      expect(stats.messagesSent).toBeGreaterThan(0);
+      expect(stats.messagesReceived).toBeGreaterThan(0);
+    });
+  });
+
+  describe('Context Management', () => {
+    it('should share indexer context between Coordinator and Explorer', async () => {
+      const contextIndexer = coordinator.getContextManager().getIndexer();
+      expect(contextIndexer).toBeDefined();
+      expect(contextIndexer).toBe(indexer);
+    });
+
+    it('should allow Explorer to access shared context', async () => {
+      const response = await coordinator.sendMessage({
+        type: 'request',
+        sender: 'test',
+        recipient: 'explorer',
+        payload: {
+          action: 'pattern',
+          query: 'test',
+        },
+      });
+
+      // Should succeed because indexer is in shared context
+      expect(response?.type).toBe('response');
+    });
+  });
+
+  describe('Shutdown', () => {
+    it('should gracefully unregister Explorer', async () => {
+      await coordinator.unregisterAgent('explorer');
+
+      const agents = coordinator.getAgents();
+      expect(agents).not.toContain('explorer');
+    });
+
+    it('should stop coordinator and all agents', async () => {
+      await coordinator.stop();
+
+      const agents = coordinator.getAgents();
+      expect(agents).toHaveLength(0);
+    });
+  });
+});
diff --git a/packages/subagents/src/explorer/README.md b/packages/subagents/src/explorer/README.md
index c81daca..d8f1ffd 100644
--- a/packages/subagents/src/explorer/README.md
+++ b/packages/subagents/src/explorer/README.md
@@ -354,34 +354,210 @@ const response = await explorer.handleMessage({
 
 ## Integration with Coordinator
 
-The Explorer works seamlessly with the Subagent Coordinator:
+The Explorer integrates seamlessly with the Subagent Coordinator, allowing it to work alongside other agents in a coordinated system.
+
+### Complete Integration Example
 
 ```typescript
-import { SubagentCoordinator, ExplorerAgent } from '@lytics/dev-agent-subagents';
+import { 
+  SubagentCoordinator, 
+  ExplorerAgent, 
+  ContextManagerImpl 
+} from '@lytics/dev-agent-subagents';
+import { RepositoryIndexer } from '@lytics/dev-agent-core';
 
-const coordinator = new SubagentCoordinator();
-await coordinator.initialize({
+// 1. Initialize Repository Indexer
+const indexer = new RepositoryIndexer({
   repositoryPath: './my-repo',
   vectorStorePath: './.dev-agent/vectors',
 });
+await indexer.initialize();
+
+// Index the repository
+await indexer.index({ force: false });
+
+// 2. Create Coordinator
+const coordinator = new SubagentCoordinator({
+  maxConcurrentTasks: 5,
+  logLevel: 'info',
+  healthCheckInterval: 60000, // Health checks every minute
+});
+
+// 3. Share Indexer Context
+coordinator.getContextManager().setIndexer(indexer);
+
+// 4. Register Explorer Agent
+const explorer = new ExplorerAgent();
+await coordinator.registerAgent(explorer);
 
-// Register Explorer
-coordinator.registerAgent(new ExplorerAgent());
+// 5. Start Coordinator
+coordinator.start();
 
-// Send exploration request via coordinator
+// 6. Send Exploration Requests via Coordinator
 const response = await coordinator.sendMessage({
-  id: 'explore-1',
   type: 'request',
-  sender: 'user',
+  sender: 'app',
   recipient: 'explorer',
   payload: {
     action: 'pattern',
-    query: 'authentication',
+    query: 'authentication logic',
+    limit: 10,
   },
-  timestamp: Date.now(),
+});
+
+console.log(response?.payload);
+
+// 7. Or Submit Tasks for Async Execution
+const taskId = coordinator.submitTask({
+  type: 'exploration',
+  agentName: 'explorer',
+  payload: {
+    action: 'similar',
+    filePath: 'src/auth/login.ts',
+  },
+  priority: 8, // Higher priority
+});
+
+// Check task status
+const task = coordinator.getTask(taskId);
+console.log('Task status:', task?.status);
+
+// 8. Monitor Health
+setInterval(async () => {
+  const stats = coordinator.getStats();
+  console.log('Coordinator stats:', stats);
+  
+  const healthy = await explorer.healthCheck();
+  console.log('Explorer healthy:', healthy);
+}, 30000);
+
+// 9. Graceful Shutdown
+process.on('SIGINT', async () => {
+  await coordinator.stop();
+  await indexer.close();
+  process.exit(0);
 });
 ```
 
+### Benefits of Coordinator Integration
+
+✅ **Shared Context** - Indexer and other resources shared across agents
+✅ **Task Queue** - Async execution with priority and retries
+✅ **Health Monitoring** - Automated health checks
+✅ **Error Handling** - Centralized error responses
+✅ **Message Routing** - Automatic routing to correct agents
+✅ **Statistics** - Track message counts, response times, task status
+
+### Task-Based Exploration
+
+Submit exploration tasks for async execution:
+
+```typescript
+// Pattern search task
+const taskId1 = coordinator.submitTask({
+  type: 'pattern-search',
+  agentName: 'explorer',
+  payload: {
+    action: 'pattern',
+    query: 'error handling',
+  },
+  priority: 10,      // High priority
+  maxRetries: 3,     // Retry on failure
+});
+
+// Similar code task
+const taskId2 = coordinator.submitTask({
+  type: 'similar-code',
+  agentName: 'explorer',
+  payload: {
+    action: 'similar',
+    filePath: 'src/handlers/api.ts',
+  },
+  priority: 5,
+});
+
+// Check task completion
+const task = coordinator.getTask(taskId1);
+if (task?.status === 'completed') {
+  console.log('Results:', task.result);
+}
+```
+
+### Coordinator Statistics
+
+Monitor system health and performance:
+
+```typescript
+const stats = coordinator.getStats();
+
+console.log({
+  agentCount: stats.agentCount,           // Number of registered agents
+  messagesSent: stats.messagesSent,       // Total messages sent
+  messagesReceived: stats.messagesReceived,
+  messageErrors: stats.messageErrors,
+  tasksCompleted: stats.tasksCompleted,
+  tasksFailed: stats.tasksFailed,
+  avgResponseTime: stats.avgResponseTime, // In milliseconds
+  uptime: stats.uptime,                   // In milliseconds
+});
+```
+
+### Multi-Agent Coordination
+
+Explorer works with other agents:
+
+```typescript
+// Register multiple agents
+await coordinator.registerAgent(new ExplorerAgent());
+await coordinator.registerAgent(new PlannerAgent());
+await coordinator.registerAgent(new PrAgent());
+
+// Explorer can send messages to other agents
+const response = await coordinator.sendMessage({
+  type: 'request',
+  sender: 'explorer',
+  recipient: 'planner',
+  payload: {
+    action: 'analyze',
+    codePatterns: explorerResults,
+  },
+});
+```
+
+### Coordinator Health Checks
+
+The coordinator automatically performs health checks:
+
+```typescript
+const coordinator = new SubagentCoordinator({
+  healthCheckInterval: 60000, // Check every minute
+});
+
+// Health checks run automatically
+// Logs warnings if agents become unhealthy
+
+// Manual health check
+const healthy = await explorer.healthCheck();
+```
+
+### Integration Tests
+
+The Coordinator→Explorer integration is fully tested:
+
+```bash
+# Run integration tests
+pnpm test packages/subagents/src/coordinator/coordinator.integration.test.ts
+```
+
+**Test Coverage:**
+- ✅ Agent registration and initialization
+- ✅ Message routing (pattern, similar, relationships, insights)
+- ✅ Task execution via task queue
+- ✅ Health checks and monitoring
+- ✅ Context sharing (indexer access)
+- ✅ Error handling and edge cases
+- ✅ Graceful shutdown
+
 ## Error Handling
 
 The Explorer returns error responses for invalid requests:
diff --git a/packages/subagents/src/index.ts b/packages/subagents/src/index.ts
index 64bd9ea..befecfa 100644
--- a/packages/subagents/src/index.ts
+++ b/packages/subagents/src/index.ts
@@ -13,13 +13,30 @@
 // Main coordinator module
 export { ContextManagerImpl, SubagentCoordinator, TaskQueue } from './coordinator';
 export { ExplorerAgent } from './explorer';
+// Types - Explorer
+export type {
+  CodeInsights,
+  CodeRelationship,
+  ExplorationAction,
+  ExplorationError,
+  ExplorationRequest,
+  ExplorationResult,
+  InsightsRequest,
+  InsightsResult,
+  PatternFrequency,
+  PatternResult,
+  PatternSearchRequest,
+  RelationshipRequest,
+  RelationshipResult,
+  SimilarCodeRequest,
+  SimilarCodeResult,
+} from './explorer/types';
 // Logger module
 export { CoordinatorLogger } from './logger';
 // Agent modules (stubs for now)
 export { PlannerAgent } from './planner';
 export { PrAgent } from './pr';
-
-// Types
+// Types - Coordinator
 export type {
   Agent,
   AgentContext,