docs: update architecture and development docs with MCP resources system

- Update TOOLS.md: correct tool count from 84 to 105+, add MCP Resources section
- Update ARCHITECTURE.md: add MCP Resources Layer to architecture diagram, detailed resource system documentation
- Update PLUGIN_DEVELOPMENT.md: comprehensive guide for creating MCP resources, testing patterns, auto-discovery
- Document client capability detection, smart tool filtering, and resource implementation patterns
- Update plugin categories count and structure references
- Provide complete development workflow for both tools and resources

Author: cameroncooke

docs/ARCHITECTURE.md

@@ -42,6 +42,12 @@ XcodeBuildMCP is a Model Context Protocol (MCP) server that exposes Xcode operat
 │  • plugins/**/                  – self-contained plugins    │
 └────────────────────────────────────────────────────────────┘
 ┌────────────────────────────────────────────────────────────┐
+│                    MCP Resources Layer                     │
+│  • src/core/resources.ts        – resource management      │
+│  • src/resources/**/            – MCP resource handlers    │
+│  • Client capability detection  – automatic tool filtering │
+└────────────────────────────────────────────────────────────┘
+┌────────────────────────────────────────────────────────────┐
 │                   Plugin Implementation Layer              │
 │  • plugins/**/**.js – one file per tool capability         │
 │  • Common patterns:                                         │
@@ -229,6 +235,56 @@ plugins/
 └── discovery/               # Dynamic tool discovery
 ```
 
+### MCP Resources System
+
+XcodeBuildMCP provides dual interfaces: traditional MCP tools and efficient MCP resources for supported clients.
+
+#### Resource Architecture
+
+```
+src/resources/
+├── simulators.ts           # Simulator data resource
+└── __tests__/              # Resource-specific tests
+```
+
+#### Client Capability Detection
+
+The system automatically detects client MCP capabilities:
+
+```typescript
+// src/core/resources.ts
+export function supportsResources(server?: unknown): boolean {
+  // Detects client capabilities via getClientCapabilities()
+  // Conservative fallback: assumes resource support
+}
+```
+
+#### Smart Tool Filtering
+
+When resources are available, redundant tools are automatically filtered:
+
+- **Resource-supported clients**: Get `mcp://xcodebuild/simulators` resource
+- **Tool-only clients**: Keep `list_sims` tool for compatibility
+- **Automatic detection**: No client configuration required
+
+#### Resource Implementation Pattern
+
+Resources reuse existing tool logic for consistency:
+
+```typescript
+// src/resources/simulators.ts
+export default {
+  uri: 'mcp://xcodebuild/simulators',
+  description: 'Available iOS simulators with UUIDs and states',
+  mimeType: 'text/plain',
+  async handler(executor = getDefaultCommandExecutor()) {
+    // Reuses list_simsLogic for consistency
+    const result = await list_simsLogic({}, executor);
+    return { contents: [{ type: 'text', text: result.content[0].text }] };
+  }
+};
+```
+
 ### Utility Layer
 
 #### Command Execution (`src/utils/command.ts`)
@@ -257,7 +313,7 @@ plugins/
 
 ## Plugin Organization
 
-### Plugin Categories (84 tools total across 16 directories)
+### Plugin Categories (105+ tools total across 15 workflow directories)
 
 #### Build Tools (20 tools)
 - macOS builds (workspace/project)

docs/PLUGIN_DEVELOPMENT.md

@@ -8,10 +8,11 @@ This guide provides comprehensive instructions for creating new tools and workfl
 2. [Plugin Architecture](#plugin-architecture)
 3. [Creating New Tools](#creating-new-tools)
 4. [Creating New Workflow Groups](#creating-new-workflow-groups)
-5. [Auto-Discovery System](#auto-discovery-system)
-6. [Testing Guidelines](#testing-guidelines)
-7. [Development Workflow](#development-workflow)
-8. [Best Practices](#best-practices)
+5. [Creating MCP Resources](#creating-mcp-resources)
+6. [Auto-Discovery System](#auto-discovery-system)
+7. [Testing Guidelines](#testing-guidelines)
+8. [Development Workflow](#development-workflow)
+9. [Best Practices](#best-practices)
 
 ## Overview
 
@@ -304,6 +305,95 @@ export { default } from '../simulator-shared/boot_sim.js';
 3. Each tool maintains project or workspace specificity
 4. Implementation shared, interfaces remain unique
 
+## Creating MCP Resources
+
+MCP Resources provide efficient URI-based data access for clients that support the MCP resource specification (VS Code, Claude Code, Claude Desktop).
+
+### 1. Resource Structure
+
+Resources are located in `src/resources/` and follow this pattern:
+
+```typescript
+// src/resources/example.ts
+export default {
+  uri: 'mcp://xcodebuild/example',
+  description: 'Description of the resource data',
+  mimeType: 'text/plain',
+  async handler(executor: CommandExecutor = getDefaultCommandExecutor()) {
+    // Resource implementation
+    return {
+      contents: [{ type: 'text', text: 'resource data' }]
+    };
+  }
+};
+```
+
+### 2. Resource Implementation Guidelines
+
+**Reuse Existing Logic**: Resources should reuse existing tool logic for consistency:
+
+```typescript
+// src/resources/simulators.ts
+import { list_simsLogic } from '../plugins/simulator-shared/list_sims.js';
+
+export default {
+  uri: 'mcp://xcodebuild/simulators',
+  description: 'Available iOS simulators with UUIDs and states',
+  mimeType: 'text/plain',
+  async handler(executor = getDefaultCommandExecutor()) {
+    const result = await list_simsLogic({}, executor);
+    return {
+      contents: [{ type: 'text', text: result.content[0].text }]
+    };
+  }
+};
+```
+
+### 3. Tool Redundancy Management
+
+When creating resources, update the redundancy filter:
+
+```typescript
+// src/core/resources.ts
+export function getRedundantToolNames(): string[] {
+  return [
+    'list_sims',      // Redundant with simulators resource
+    'your_new_tool',  // Add new redundant tools here
+  ];
+}
+```
+
+### 4. Resource Testing
+
+Create tests in `src/resources/__tests__/`:
+
+```typescript
+// src/resources/__tests__/example.test.ts
+import exampleResource from '../example.js';
+import { createMockExecutor } from '../../utils/test-common.js';
+
+describe('example resource', () => {
+  it('should return resource data', async () => {
+    const mockExecutor = createMockExecutor({
+      success: true,
+      output: 'test data'
+    });
+    
+    const result = await exampleResource.handler(mockExecutor);
+    
+    expect(result.contents[0].text).toContain('expected data');
+  });
+});
+```
+
+### 5. Auto-Discovery
+
+Resources are automatically discovered and loaded by the build system. After creating a resource:
+
+1. Run `npm run build` to regenerate resource loaders
+2. The resource will be available at its URI for supported clients
+3. Redundant tools will be automatically filtered for resource-capable clients
+
 ## Auto-Discovery System
 
 ### How Auto-Discovery Works

docs/TOOLS.md

@@ -1,6 +1,16 @@
 # XcodeBuildMCP Tools Reference
 
-This document provides a comprehensive list of all 84 tools available in XcodeBuildMCP, organized by functionality.
+This document provides a comprehensive list of all 105+ tools available in XcodeBuildMCP, organized by functionality.
+
+## MCP Resources
+
+For clients that support MCP resources (VS Code, Claude Code, Claude Desktop), XcodeBuildMCP also provides efficient URI-based data access:
+
+| Resource URI | Description | Replaces Tool |
+|--------------|-------------|---------------|
+| `mcp://xcodebuild/simulators` | Available iOS simulators with UUIDs and states | `list_sims` |
+
+**Note**: Resources provide the same data as their corresponding tools but through efficient URI access. XcodeBuildMCP automatically detects client capabilities and filters out redundant tools when resources are available.
 
 ## Tool Categories