svrnty-mcp-server/docs/implementation-plan.md

OpenHarbor.MCP - Detailed Implementation Plan

Project: Standalone, Reusable MCP Library for .NET Status: Planned (Not Yet Started) Created: 2025-10-19 Version: 1.0.0 Estimated Effort: 3-4 weeks (24-32 hours active work)

---

Executive Summary

OpenHarbor.MCP is a standalone .NET library implementing the Model Context Protocol (MCP) server functionality. It is designed to be:

• Reusable across any .NET project
• Modular with clean separation of concerns
• Scalable with built-in permission and rate limiting
• Secure with deny-by-default security model
• Self-contained with complete documentation and examples

First Use Case: CODEX MCP Gateway (makes CODEX knowledge accessible to all AI agents)

Future Use Cases: Any .NET application wanting to expose tools/resources via MCP protocol

---

Table of Contents

• Architecture
• Project Structure
• Implementation Phases
• Test-Driven Development Strategy
• AGENT-PRIMER.md Specifications
• CODEX Integration
• Technology Stack
• Success Criteria

---

Architecture

Clean Architecture Layers

┌─────────────────────────────────────────────┐
│         OpenHarbor.MCP.Core                 │
│  (Pure Abstractions - Zero Dependencies)    │
│                                             │
│  IMcpServer, IMcpTool, IMcpResource         │
│  IPermissionProvider, IRateLimiter          │
│  McpRequest, McpResponse, McpTool           │
└─────────────────┬───────────────────────────┘
                  │ Depends On
┌─────────────────┴───────────────────────────┐
│    OpenHarbor.MCP.Infrastructure            │
│  (Implementation + Transport)               │
│                                             │
│  McpServer, ToolRegistry, StdioTransport    │
│  PermissionProvider, TokenBucketRateLimiter │
│  McpProtocolHandler, AuditLogger            │
└─────────────────┬───────────────────────────┘
                  │ Depends On
┌─────────────────┴───────────────────────────┐
│     OpenHarbor.MCP.AspNetCore               │
│  (ASP.NET Core Integration)                 │
│                                             │
│  ServiceCollectionExtensions                │
│  McpMiddleware, AuditMiddleware             │
│  McpOptions (Configuration)                 │
└─────────────────────────────────────────────┘

┌─────────────────────────────────────────────┐
│      OpenHarbor.MCP.Cli                     │
│  (Standalone CLI Runner)                    │
│                                             │
│  Program.cs (Entry Point)                   │
│  Configuration Loading                      │
│  Stdio Transport Execution                  │
└─────────────────────────────────────────────┘

Component Responsibilities

Core (Abstractions):

• IMcpServer - Server lifecycle and tool registration
• IMcpTool - Tool interface with execute method
• IMcpResource - Resource interface (future)
• IPermissionProvider - Permission checking abstraction
• IRateLimiter - Rate limiting abstraction
• Models: Request, Response, Tool metadata, Errors

Infrastructure (Implementation):

• McpServer - Concrete server implementation
• ToolRegistry - Dynamic tool registration and discovery
• McpProtocolHandler - Protocol message parsing and routing
• StdioTransport - Process stdin/stdout communication
• PermissionProvider - Permission checking logic
• TokenBucketRateLimiter - Rate limiting implementation
• AuditLogger - Audit trail for security

AspNetCore (Integration):

• AddMcpServer() - DI extension method
• McpMiddleware - HTTP transport middleware
• McpOptions - Configuration model
• AuditMiddleware - Audit logging middleware

Cli (Runtime):

• Program.cs - CLI entry point
• Configuration loading from JSON
• HTTP transport runner

---

Project Structure

/home/svrnty/codex/OpenHarbor.MCP/
├── OpenHarbor.MCP.sln
├── README.md
├── AGENT-PRIMER.md                          # AI-assisted configuration
├── LICENSE                                   # MIT
├── .gitignore
├── .editorconfig
│
├── src/
│   ├── OpenHarbor.MCP.Core/
│   │   ├── Abstractions/
│   │   │   ├── IMcpServer.cs
│   │   │   ├── IMcpTool.cs
│   │   │   ├── IMcpResource.cs
│   │   │   ├── IPermissionProvider.cs
│   │   │   └── IRateLimiter.cs
│   │   ├── Models/
│   │   │   ├── McpRequest.cs
│   │   │   ├── McpResponse.cs
│   │   │   ├── McpTool.cs
│   │   │   ├── McpResource.cs
│   │   │   ├── PermissionScope.cs
│   │   │   └── RateLimitPolicy.cs
│   │   ├── Exceptions/
│   │   │   ├── McpException.cs
│   │   │   ├── PermissionDeniedException.cs
│   │   │   ├── RateLimitExceededException.cs
│   │   │   └── ToolNotFoundException.cs
│   │   └── OpenHarbor.MCP.Core.csproj
│   │
│   ├── OpenHarbor.MCP.Infrastructure/
│   │   ├── Server/
│   │   │   ├── McpServer.cs
│   │   │   ├── ToolRegistry.cs
│   │   │   └── McpProtocolHandler.cs
│   │   ├── Security/
│   │   │   ├── PermissionProvider.cs
│   │   │   ├── TokenBucketRateLimiter.cs
│   │   │   └── AuditLogger.cs
│   │   ├── Transport/
│   │   │   ├── StdioTransport.cs
│   │   │   └── HttpTransport.cs
│   │   └── OpenHarbor.MCP.Infrastructure.csproj
│   │
│   ├── OpenHarbor.MCP.AspNetCore/
│   │   ├── Extensions/
│   │   │   └── ServiceCollectionExtensions.cs
│   │   ├── Middleware/
│   │   │   ├── McpMiddleware.cs
│   │   │   └── AuditMiddleware.cs
│   │   ├── Configuration/
│   │   │   └── McpOptions.cs
│   │   └── OpenHarbor.MCP.AspNetCore.csproj
│   │
│   └── OpenHarbor.MCP.Cli/
│       ├── Program.cs
│       └── OpenHarbor.MCP.Cli.csproj
│
├── tests/
│   ├── OpenHarbor.MCP.Core.Tests/
│   │   ├── Abstractions/
│   │   ├── Models/
│   │   └── Exceptions/
│   ├── OpenHarbor.MCP.Infrastructure.Tests/
│   │   ├── Server/
│   │   ├── Security/
│   │   └── Transport/
│   └── OpenHarbor.MCP.Integration.Tests/
│       ├── EndToEnd/
│       └── Scenarios/
│
├── samples/
│   └── CodexMcpServer/                      # CODEX example
│       ├── Program.cs
│       ├── CodexMcpServer.cs
│       ├── Tools/
│       │   ├── SearchCodexTool.cs
│       │   ├── GetDocumentTool.cs
│       │   ├── ListDocumentsTool.cs
│       │   ├── SearchByTagTool.cs
│       │   ├── GetDocumentSectionsTool.cs
│       │   └── ListTagsTool.cs
│       ├── Permissions/
│       │   └── CodexPermissionProvider.cs
│       ├── codex-mcp-config.json
│       └── CodexMcpServer.csproj
│
├── docs/
│   ├── getting-started.md
│   ├── architecture.md
│   ├── creating-tools.md
│   ├── permission-model.md
│   ├── rate-limiting.md
│   └── deployment.md
│
└── templates/                               # For AGENT-PRIMER.md
    ├── appsettings.json.template
    ├── mcp-config.json.template
    ├── Program.cs.template
    └── sample-tool.cs.template

---

Implementation Phases

Phase 1: Core Abstractions (Week 1, 6-8 hours)

Goal: Define core interfaces and models with zero dependencies

Step 1.1: Project Setup (30 minutes)

TDD: Not applicable (infrastructure setup)

Tasks:

• Create solution: dotnet new sln -n OpenHarbor.MCP
• Create Core project: dotnet new classlib -n OpenHarbor.MCP.Core --framework net8.0
• Configure: Enable nullable, ImplicitUsings
• Add to solution

Deliverables:

• OpenHarbor.MCP.sln
• OpenHarbor.MCP.Core.csproj
• .editorconfig (C# formatting)

Step 1.2: Core Interfaces (2 hours)

TDD: Write interface tests first (behavior validation via mocks)

Tests FIRST:

// OpenHarbor.MCP.Core.Tests/Abstractions/IMcpServerTests.cs
[Fact]
public async Task RegisterTool_WithValidTool_AddsToRegistry()
{
    var server = new Mock<IMcpServer>();
    var tool = new Mock<IMcpTool>();

    server.Setup(s => s.RegisterTool(tool.Object))
          .Returns(Task.CompletedTask);

    await server.Object.RegisterTool(tool.Object);

    server.Verify(s => s.RegisterTool(tool.Object), Times.Once);
}

Implementation:

// OpenHarbor.MCP.Core/Abstractions/IMcpServer.cs
public interface IMcpServer
{
    Task RegisterTool(IMcpTool tool);
    Task<IEnumerable<IMcpTool>> GetTools();
    Task<McpResponse> HandleRequest(McpRequest request);
    Task Start(CancellationToken cancellationToken = default);
    Task Stop();
}

// OpenHarbor.MCP.Core/Abstractions/IMcpTool.cs
public interface IMcpTool
{
    string Name { get; }
    string Description { get; }
    McpToolSchema Schema { get; }
    Task<McpResponse> Execute(McpRequest request);
}

// OpenHarbor.MCP.Core/Abstractions/IPermissionProvider.cs
public interface IPermissionProvider
{
    Task<bool> HasPermission(string agentId, string action, string? resource = null);
    Task<IEnumerable<string>> GetPermissions(string agentId);
}

// OpenHarbor.MCP.Core/Abstractions/IRateLimiter.cs
public interface IRateLimiter
{
    Task<bool> TryAcquire(string agentId);
    Task<RateLimitInfo> GetLimitInfo(string agentId);
}

Deliverables:

• 5 core interfaces
• 10+ interface behavior tests

Step 1.3: Core Models (2 hours)

TDD: Write model tests first (validation, serialization)

Tests FIRST:

[Fact]
public void McpRequest_WithValidData_Serializes()
{
    var request = new McpRequest
    {
        Method = "tools/call",
        Params = new { tool = "search", query = "test" }
    };

    var json = JsonSerializer.Serialize(request);
    var deserialized = JsonSerializer.Deserialize<McpRequest>(json);

    Assert.Equal(request.Method, deserialized.Method);
}

Implementation:

// OpenHarbor.MCP.Core/Models/McpRequest.cs
public record McpRequest
{
    public string Method { get; init; } = string.Empty;
    public object? Params { get; init; }
    public string? Id { get; init; }
}

// OpenHarbor.MCP.Core/Models/McpResponse.cs
public record McpResponse
{
    public object? Result { get; init; }
    public McpError? Error { get; init; }
    public string? Id { get; init; }
}

// OpenHarbor.MCP.Core/Models/McpTool.cs
public record McpTool
{
    public string Name { get; init; } = string.Empty;
    public string Description { get; init; } = string.Empty;
    public McpToolSchema Schema { get; init; } = new();
}

Deliverables:

• 7 core models
• 15+ model tests (validation, serialization)

Step 1.4: Exceptions (1 hour)

TDD: Write exception tests first

Tests FIRST:

[Fact]
public void PermissionDeniedException_WithAgentAndAction_ContainsDetails()
{
    var ex = new PermissionDeniedException("agent1", "read", "/docs");

    Assert.Contains("agent1", ex.Message);
    Assert.Contains("read", ex.Message);
    Assert.Equal("agent1", ex.AgentId);
}

Implementation:

public class PermissionDeniedException : McpException
{
    public string AgentId { get; }
    public string Action { get; }
    public string? Resource { get; }

    public PermissionDeniedException(string agentId, string action, string? resource = null)
        : base($"Agent '{agentId}' denied permission to '{action}' on resource '{resource ?? "any"}'")
    {
        AgentId = agentId;
        Action = action;
        Resource = resource;
    }
}

Deliverables:

• 4 exception classes
• 8+ exception tests

Phase 1 Checkpoint:

• Total tests: ~35
• All passing: ✅
• Zero dependencies: ✅
• Code coverage: >90% ✅

---

Phase 2: Server Implementation (Week 1-2, 8-10 hours)

Goal: Implement MCP server with permission, rate limiting, and transport

Step 2.1: Infrastructure Project Setup (30 minutes)

• Create Infrastructure project
• Reference Core project
• Configure test project

Step 2.2: McpServer Implementation (3 hours)

TDD: Write server tests first

Tests FIRST:

[Fact]
public async Task RegisterTool_WithValidTool_AddsToRegistry()
{
    var server = new McpServer();
    var tool = new MockSearchTool();

    await server.RegisterTool(tool);
    var tools = await server.GetTools();

    Assert.Contains(tools, t => t.Name == tool.Name);
}

[Fact]
public async Task HandleRequest_WithRegisteredTool_ExecutesTool()
{
    var server = new McpServer();
    var tool = new Mock<IMcpTool>();
    tool.Setup(t => t.Name).Returns("test_tool");
    tool.Setup(t => t.Execute(It.IsAny<McpRequest>()))
        .ReturnsAsync(new McpResponse { Result = "success" });

    await server.RegisterTool(tool.Object);
    var request = new McpRequest { Method = "tools/call", Params = new { tool = "test_tool" } };

    var response = await server.HandleRequest(request);

    Assert.NotNull(response.Result);
    tool.Verify(t => t.Execute(It.IsAny<McpRequest>()), Times.Once);
}

Implementation:

public class McpServer : IMcpServer
{
    private readonly IToolRegistry _toolRegistry;
    private readonly IPermissionProvider _permissionProvider;
    private readonly IRateLimiter _rateLimiter;

    public async Task RegisterTool(IMcpTool tool)
    {
        await _toolRegistry.Add(tool);
    }

    public async Task<McpResponse> HandleRequest(McpRequest request)
    {
        // Permission check
        // Rate limit check
        // Route to tool
        // Return response
    }
}

Deliverables:

• McpServer implementation
• ToolRegistry implementation
• 20+ server tests

Step 2.3: Permission Provider (2 hours)

TDD: Permission tests first

Tests FIRST:

[Fact]
public async Task HasPermission_WithAllowedAction_ReturnsTrue()
{
    var config = new PermissionConfig
    {
        Agents = new Dictionary<string, AgentPermissions>
        {
            ["agent1"] = new() { Permissions = new[] { "read", "search" } }
        }
    };
    var provider = new PermissionProvider(config);

    var result = await provider.HasPermission("agent1", "read");

    Assert.True(result);
}

Implementation:

public class PermissionProvider : IPermissionProvider
{
    private readonly PermissionConfig _config;

    public async Task<bool> HasPermission(string agentId, string action, string? resource = null)
    {
        // Check agent permissions
        // Check scopes
        // Return result
    }
}

Deliverables:

• PermissionProvider implementation
• 15+ permission tests

Step 2.4: Rate Limiter (2 hours)

TDD: Rate limiter tests first

Tests:

• Token bucket algorithm tests
• Concurrent request tests
• Limit exceeded scenarios

Deliverables:

• TokenBucketRateLimiter implementation
• 12+ rate limiter tests

Step 2.5: Stdio Transport (1.5 hours)

TDD: Transport tests first

Tests:

• Read from stdin
• Write to stdout
• Handle malformed input

Deliverables:

• StdioTransport implementation
• 10+ transport tests

Phase 2 Checkpoint:

• Total tests: ~90
• All passing: ✅
• Integration test: MCP server end-to-end ✅

---

Phase 3: ASP.NET Core Integration (Week 2, 6-8 hours)

Goal: Enable MCP server in ASP.NET Core applications

Step 3.1: Service Extensions (2 hours)

TDD: Extension tests first

Tests:

[Fact]
public void AddMcpServer_RegistersServices()
{
    var services = new ServiceCollection();

    services.AddMcpServer(options => {
        options.ServerName = "test";
    });

    var provider = services.BuildServiceProvider();
    Assert.NotNull(provider.GetService<IMcpServer>());
}

Implementation:

public static IServiceCollection AddMcpServer(
    this IServiceCollection services,
    Action<McpOptions> configure)
{
    services.Configure(configure);
    services.AddSingleton<IMcpServer, McpServer>();
    services.AddSingleton<IPermissionProvider, PermissionProvider>();
    services.AddSingleton<IRateLimiter, TokenBucketRateLimiter>();
    return services;
}

Deliverables:

• ServiceCollectionExtensions
• 8+ extension tests

Step 3.2: MCP Middleware (3 hours)

TDD: Middleware tests first

Tests:

• HTTP POST handling
• Permission enforcement
• Rate limiting
• Error responses

Deliverables:

• McpMiddleware implementation
• 15+ middleware tests

Step 3.3: Configuration (1 hour)

TDD: Configuration tests

Deliverables:

• McpOptions model
• Configuration validation tests

Phase 3 Checkpoint:

• Total tests: ~120
• ASP.NET Core integration working ✅

---

Phase 4: CLI Runner & Documentation (Week 3, 4-6 hours)

Goal: Standalone CLI for HTTP transport + complete documentation

Step 4.1: CLI Program (1 hour)

TDD: CLI behavior tests

Deliverables:

• Program.cs with configuration loading
• HTTP transport runner
• 5+ CLI tests

Step 4.2: CODEX Sample (2 hours)

TDD: Sample implementation tests

Deliverables:

• CodexMcpServer sample
• 6 CODEX tools implemented
• Integration test with CODEX API

Step 4.3: Documentation (1.5 hours)

Not TDD (documentation doesn't need tests)

Deliverables:

• Complete README.md
• Getting started guide
• Architecture documentation
• Tool creation guide
• Deployment guide

Phase 4 Checkpoint:

• Total tests: ~140
• Sample working with CODEX ✅
• Documentation complete ✅

---

Test-Driven Development Strategy

TDD Principles (CODEX RULE #3)

Mandatory workflow:

1. RED: Write test that fails
2. Verify RED: Run test, confirm failure
3. GREEN: Write minimal code to pass
4. Verify GREEN: Run test, confirm success
5. REFACTOR: Improve code, keep tests green
6. REPEAT: Next requirement

Test Organization

tests/
├── OpenHarbor.MCP.Core.Tests/
│   ├── Abstractions/           # Interface behavior tests
│   ├── Models/                 # Model validation tests
│   └── Exceptions/             # Exception tests
├── OpenHarbor.MCP.Infrastructure.Tests/
│   ├── Server/                 # Server logic tests
│   ├── Security/               # Permission & rate limit tests
│   └── Transport/              # Transport tests
└── OpenHarbor.MCP.Integration.Tests/
    └── EndToEnd/               # Full MCP server scenarios

Test Coverage Goals

• Core: >95% (pure logic, easy to test)
• Infrastructure: >90% (some I/O dependencies)
• AspNetCore: >85% (middleware has framework dependencies)
• Overall: >90%

Testing Tools

• xUnit: Test framework (CODEX-approved)
• Moq: Mocking library (CODEX-approved)
• FluentAssertions: Assertion library (optional, check approval)

---

AGENT-PRIMER.md Specifications

Purpose

Enable AI agents to automatically configure OpenHarbor.MCP for any target system by:

1. Analyzing the system
2. Generating configuration
3. Creating sample tools
4. Setting up environment

Structure

# OpenHarbor.MCP Agent Primer

**For AI Agents:** This file guides automated setup of OpenHarbor.MCP.

## Step 1: System Analysis

**Commands to run:**
```bash
dotnet --version                              # Check .NET SDK
ls -la [target-project-path]                  # Analyze structure
cat [target-project]/*.csproj                 # Read dependencies
cat [target-project]/appsettings.json         # Check configuration

Detect:

• .NET SDK version (require 8.0+)
• Project type (Console, ASP.NET Core, Worker)
• Database (PostgreSQL, SQL Server, None)
• Authentication (Keycloak, JWT, None)
• Operating system

Step 2: Generate Configuration

Based on analysis, generate:

For ASP.NET Core Projects:

• appsettings.json MCP section
• Program.cs AddMcpServer() call
• Sample controller integration

For Console Projects:

• mcp-config.json
• Program.cs standalone server
• HTTP transport setup

Templates: See templates/ folder

Step 3: Create Sample Tools

Generate based on detected features:

If database detected:

// Tools/QueryDatabaseTool.cs
public class QueryDatabaseTool : IMcpTool
{
    public string Name => "query_database";
    // ... implementation
}

If API detected:

// Tools/CallApiTool.cs
public class CallApiTool : IMcpTool
{
    public string Name => "call_api";
    // ... implementation
}

If git repository detected:

// Tools/SearchRepositoryTool.cs
public class SearchRepositoryTool : IMcpTool
{
    public string Name => "search_repo";
    // ... implementation
}

Step 4: Setup Development Environment

Generate:

• .editorconfig (if not exists)
• launchSettings.json (for debugging)
• README.md (project-specific)
• run-mcp-server.sh (startup script)

Step 5: Validation

Run automated tests:

dotnet build                        # Compile
dotnet test                         # Run tests
./run-mcp-server.sh --test         # Test connectivity

Example: CODEX Integration

Detected:

• ASP.NET Core 8 project
• PostgreSQL database
• REST API at http://localhost:5050
• Semantic search capability

Generated:

• CodexMcpServer.cs
• 6 tools: search_codex, get_document, list_documents, search_by_tag, get_document_sections, list_tags
• codex-mcp-config.json with permission model
• Integration tests

Output: samples/CodexMcpServer/ ready to run

### Implementation

The AGENT-PRIMER.md will include:
- Detailed system analysis commands
- Decision trees for configuration generation
- Complete templates for all scenarios
- Validation procedures
- Example outputs for common cases

---

## CODEX Integration

### Integration Approach

**Option 1: NuGet Package (Production)**
```bash
dotnet add package OpenHarbor.MCP.AspNetCore

Option 2: Project Reference (Development)

dotnet add reference ../OpenHarbor.MCP/src/OpenHarbor.MCP.AspNetCore/OpenHarbor.MCP.AspNetCore.csproj

CODEX MCP Server Structure

src/Codex.Mcp/
├── Program.cs
├── CodexMcpServer.cs
├── Tools/
│   ├── SearchCodexTool.cs
│   ├── GetDocumentTool.cs
│   ├── ListDocumentsTool.cs
│   ├── SearchByTagTool.cs
│   ├── GetDocumentSectionsTool.cs
│   └── ListTagsTool.cs
├── Permissions/
│   └── CodexPermissionProvider.cs
└── codex-mcp-config.json

Sample Tool Implementation

using OpenHarbor.MCP.Core.Abstractions;

public class SearchCodexTool : IMcpTool
{
    private readonly HttpClient _httpClient;

    public string Name => "search_codex";
    public string Description => "Search CODEX knowledge base";

    public async Task<McpResponse> Execute(McpRequest request)
    {
        var query = request.Params["query"];
        var limit = request.Params["limit"] ?? 10;

        var response = await _httpClient.PostAsJsonAsync(
            "http://localhost:5050/api/search/hybrid",
            new { query, limit }
        );

        var result = await response.Content.ReadFromJsonAsync<SearchResult>();
        return new McpResponse { Result = result };
    }
}

---

Technology Stack

Core Dependencies (CODEX-Approved)

• .NET 8.0 SDK
• C# 11
• System.Text.Json (built-in)
• xUnit (testing)
• Moq (mocking)

New Dependencies (Require Approval via ADR)

• MCP SDK (if available for .NET)

  • Alternative: Implement MCP protocol directly
  • License: Verify open source
  • Tier: Core (essential for protocol)

• FluentAssertions (optional, testing)

  • License: Apache 2.0
  • Purpose: Better test assertions
  • Tier: Development only

CODEX RULE #1 Compliance

All new dependencies must be:

1. Documented in ADR
2. Added to CODEX tech stack
3. Approved before use
4. CODEX-approved alternatives used if available

---

Success Criteria

Module-Level Criteria

Functionality:

• MCP server starts and accepts connections
• Tools can be registered dynamically
• Permission model enforces access control
• Rate limiting prevents abuse
• Audit logging tracks all operations
• HTTP transport works
• HTTP transport works (ASP.NET Core)

Quality:

• >90% test coverage
• All tests passing
• Zero compiler warnings
• TDD followed for all code
• Clean Architecture respected

Usability:

• Complete README with examples
• API documentation generated
• Sample implementations working
• AGENT-PRIMER.md tested
• Easy to copy to new projects

Performance:

• <10ms overhead per request
• Handles 1000+ req/sec
• Rate limiting accurate

CODEX Integration Criteria

CODEX MCP Server:

• All 6 tools implemented
• Integration tests passing
• Permission model configured
• Can be called from Claude Code
• Can be called from Cursor
• Returns valid MCP responses

Documentation:

• Updated future-mcp-integration-plan.md
• Completion notes in registry.json
• CODEX_INDEX.md references OpenHarbor.MCP

---

Timeline & Milestones

Week 1

• Day 1-2: Phase 1 (Core abstractions)
• Day 3-5: Phase 2 (Server implementation start)

Week 2

• Day 1-3: Phase 2 (Server implementation complete)
• Day 4-5: Phase 3 (ASP.NET Core integration)

Week 3

• Day 1-2: Phase 4 (CLI + CODEX sample)
• Day 3-4: Documentation
• Day 5: Testing & validation

Week 4 (Buffer)

• Refinement
• Additional samples
• NuGet packaging
• Final testing

---

Next Steps

1. Get approval for this plan
2. Create folder structure: /home/svrnty/codex/OpenHarbor.MCP/
3. Write AGENT-PRIMER.md
4. Begin Phase 1: Core abstractions with TDD
5. Track progress: Use TodoWrite for each phase

---

Status: Planned (Awaiting Approval) Created: 2025-10-19 Version: 1.0.0 Related: scratch/future-mcp-integration-plan.md (Appendix B)