Verify end-to-end MCP integration after server registration

[williamthorsen]

Context

The MCP server (@codeassembly/mcp) is fully implemented with 5 tools (init_run, emit_event, register_artifact, complete_run, get_run_state), registered in .claude/settings.json (#85), and the orchestrator skill has been migrated to use MCP calls (#87). However, no test exercises the tools through the actual MCP protocol layer — the existing lifecycle.test.ts calls TypeScript functions directly, bypassing the JSON-RPC wire format, tool dispatch, and Zod input validation that the MCP SDK handles.

Problem

The gap between function-level tests and real-world usage means issues in the protocol layer — serialization bugs, broken tool registration, incorrect error signaling — would go undetected until a live orchestration run.

Proposed solution

Add protocol-level integration tests that exercise the MCP server through the SDK's Client API, verifying the full JSON-RPC round-trip for all 5 tools.

• Primary tests: Use InMemoryTransport (fast, in-process) to test tool discovery, full lifecycle, review cycle events (all 13 event types), checkpoint state reconstruction, and error propagation.
• Smoke test: Use StdioClientTransport (subprocess spawn) for a single test that validates the real cli.ts entry point and stdio framing.

Files to create

File	Purpose
packages/mcp/src/__tests__/protocol.test.ts	InMemoryTransport protocol tests (5 test groups)
packages/mcp/src/__tests__/protocol-stdio.test.ts	StdioClientTransport smoke test

No configuration changes needed — the vitest glob already matches.

Acceptance criteria

• All 5 MCP tools exercised through the protocol layer (not direct function calls)
• run-index.json verified as v3 header-only (no phases, phaseDecisions, status in context)
• run-log.jsonl verified to contain all expected events with server-injected timestamps
• get_run_state returns correct CanonicalRunStatus at each lifecycle checkpoint
• All 13 event types exercised via the review cycle test
• Error cases verified: invalid schemas return isError: true
• Stdio smoke test: subprocess spawns, connects, and calls init_run successfully
• All existing tests continue to pass
• TypeScript strict mode passes

Depends on

• Create packages/mcp server with run-data tools #85 (MCP server registration) ✅ Merged
• Update orchestrator skills to use MCP tools and v3 events #87 (Orchestrator migration to MCP) ✅ Merged

[williamthorsen]

Implementation plan

Approach: InMemoryTransport protocol tests + stdio smoke test

Use the MCP SDK's InMemoryTransport (fast, in-process) for the main test suite, and StdioClientTransport (subprocess spawn) for a single smoke test. Both exercise the real MCP JSON-RPC protocol, tool dispatch, and Zod schema validation — but InMemoryTransport skips stdio byte framing overhead.

Critical files to reference

• packages/mcp/src/server.ts — createServer() factory, tool registrations
• packages/mcp/src/cli.ts — Entry point for stdio subprocess
• packages/mcp/src/tools/__tests__/lifecycle.test.ts — Existing function-level test (pattern reference)
• packages/run-core/src/types/run-log.ts — All 13 event type interfaces
• packages/run-core/src/types/canonical.ts — CanonicalRunStatus type

Implementation steps

Step 1: Create protocol.test.ts with test helpers

Create the file at packages/mcp/src/__tests__/protocol.test.ts with:

Helpers:

• createConnectedClient() — Creates McpServer via createServer(), links with InMemoryTransport.createLinkedPair(), connects a Client, returns { client, cleanup }
• parseToolResult<T>(result) — Extracts and JSON-parses the text content from CallToolResult
• isErrorResult(result) — Checks isError flag

Step 2: Tool discovery tests

describe('tool discovery')
  - lists all 5 registered tools (init_run, emit_event, register_artifact, complete_run, get_run_state)
  - each tool has description and inputSchema

Step 3: Full lifecycle test (maps to issue items 1-4)

describe('full lifecycle via protocol')
  - init_run → emit phase events → register artifacts → complete_run → get_run_state
  - Verify v3 header: run-index.json has version:3, context has NO phases/phaseDecisions/status
  - Verify event log: run-log.jsonl contains expected event sequence with server timestamps
  - Verify state: get_run_state returns CanonicalRunStatus with correct phases, artifacts, status

Step 4: Review cycle test (all 13 event types)

describe('review cycle events')
  - Emit the full review cycle: phase_decision → phase_started(review) → reviewer_dispatched ×3 →
    reviewer_completed ×3 → coder_fix_started → coder_fix_completed → re_review_dispatched →
    re_review_completed → phase_completed(review) → phase_started(simplifier) →
    phase_completed(simplifier) → phase_started(holistic) → phase_completed(holistic)
  - Verify get_run_state reconstructs parallelReview with correct reviewers, iterations, criticalities
  - Verify all 13 event types appear in run-log.jsonl

Step 5: Checkpoint state verification

describe('get_run_state at each checkpoint')
  - After init: status=in_progress, no phases
  - After phase_started(architecture): architecture.status=in_progress
  - After phase_completed(architecture): architecture.status=completed
  - After complete_run: status=completed, completedAt set

Step 6: Error propagation tests

describe('error propagation')
  - emit_event with invalid event schema → isError=true
  - get_run_state with non-existent runDir → isError=true
  - register_artifact with optional iteration/note → correctly persisted

Step 7: Create protocol-stdio.test.ts

describe('stdio transport smoke test')
  - Spawns MCP server subprocess via StdioClientTransport (node --import tsx packages/mcp/src/cli.ts)
  - Connects Client, calls listTools, calls init_run
  - Verifies response format and runId
  - 15s timeout for subprocess startup

Step 8: Run tests and verify

• Run pnpm run ws test in the mcp package
• Verify all new protocol tests pass alongside existing unit tests
• Run pnpm run ws typecheck to confirm type safety

Verification

# Run all MCP tests (unit + protocol)
cd packages/mcp && pnpm run ws test

# Type-check
cd packages/mcp && pnpm run ws typecheck

# Run just the new protocol tests
cd packages/mcp && pnpm vitest run src/__tests__/protocol.test.ts src/__tests__/protocol-stdio.test.ts