Integration Plan: Inquiry Ecosystem Prototype

Combining Existing Systems

Current Systems Inventory

Architecture: Unified Inquiry Ecosystem MCP

``` ┌─────────────────────────────────────────────────────────────────────┐ │ INQUIRY ECOSYSTEM MCP SERVER │ │ (inquiry-ecosystem-mcp) │ ├─────────────────────────────────────────────────────────────────────┤ │ CEREMONY LAYER (Structural Accountability) │ │ ├── ceremony_check │ │ ├── get_ceremony_history │ │ └── validate_ceremony_gate │ ├─────────────────────────────────────────────────────────────────────┤ │ INQUIRY LAYER (Registry + Genealogy) │ │ ├── register_inquiry │ │ ├── list_inquiry_genealogy │ │ └── link_inquiries │ ├─────────────────────────────────────────────────────────────────────┤ │ SESSION LAYER (Context Continuum) │ │ ├── fork_session │ │ ├── get_session_context │ │ └── merge_session_insights │ ├─────────────────────────────────────────────────────────────────────┤ │ CHART LAYER (Structural Tension - wrapped) │ │ ├── create_ceremony_aware_chart (wraps coaia-narrative) │ │ ├── manage_action_step (proxy to coaia-narrative) │ │ └── mark_action_complete (proxy to coaia-narrative) │ ├─────────────────────────────────────────────────────────────────────┤ │ ASSUMPTION LAYER │ │ ├── log_assumption │ │ ├── validate_assumptions │ │ └── link_assumption_to_decision │ └─────────────────────────────────────────────────────────────────────┘ │ │ │ │ ▼ ▼ ▼ ▼ ┌───────────┐ ┌───────────┐ ┌───────────┐ ┌───────────┐ │ coaia- │ │ iaip- │ │ coaiapy- │ │ seremia │ │ narrative │ │mcp-gemini │ │ aetherial │ │ │ │ MCP │ │ MCP │ │ MCP │ │ MCP │ └───────────┘ └───────────┘ └───────────┘ └───────────┘ ```

Phase 1: Foundation (Weeks 1-2)

1.1 Create Unified MCP Server Scaffold

Location: /src/inquiry-ecosystem-mcp/

Structure: ``` inquiry-ecosystem-mcp/ ├── src/ │ ├── index.ts # MCP server entry │ ├── ceremony/ │ │ ├── tools.ts # ceremony_check, history, gate │ │ ├── types.ts # CeremonyCheck, Decision types │ │ └── storage.ts # JSONL persistence │ ├── inquiry/ │ │ ├── tools.ts # register, genealogy, link │ │ └── types.ts # Inquiry, InquiryRelation types │ ├── session/ │ │ ├── tools.ts # fork, context, merge │ │ └── types.ts # Session, ContextSnapshot types │ ├── bridges/ │ │ ├── coaia-narrative.ts # Wraps coaia-narrative MCP │ │ ├── iaip-gemini.ts # Wraps iaip-mcp │ │ ├── langfuse.ts # Wraps coaiapy-aetherial │ │ └── seremia.ts # Wraps seremia MCP │ └── middleware/ │ └── ceremony-gate.ts # Intercepts decisions, enforces checks ├── package.json ├── tsconfig.json └── CLAUDE.md ```

1.2 Ceremony Check Implementation

Priority: Highest (this is the structural accountability mechanism)

Steps:

1. Define CeremonyCheck type and storage format
2. Implement ceremony_check tool with gate logic
3. Add validate_ceremony_gate configuration
4. Create get_ceremony_history retrieval
5. Test: Create chart without ceremony check → should fail
6. Test: Create chart with ceremony check → should succeed

Integration Point: ```typescript // When wrapping coaia-narrative's create_structural_tension_chart async function createCeremonyAwareChart(input: ChartInput): Promise<Chart> { // 1. Check if ceremony gate passed const lastCheck = await getCeremonyCheck(input.sessionId, 'create_chart')

if (!lastCheck || !lastCheck.canProceed) { throw new Error('Ceremony check required before creating chart. Use ceremony_check tool first.') }

// 2. Create chart via coaia-narrative const chart = await coaiaNarrative.createStructuralTensionChart(input)

// 3. Add ceremony tracking to chart metadata chart.metadata = { ...chart.metadata, ceremonyCheckId: lastCheck.checkId, ceremonyHistory: [lastCheck.checkId] }

return chart } ```

Phase 2: Inquiry Registry (Weeks 3-4)

2.1 Inquiry Entity in coaia-narrative

Approach: Extend coaia-narrative's entity system with inquiry type.

New Entity: ```typescript interface InquiryEntity { entityType: 'inquiry' name: string // Unique inquiry ID question: string direction: 'east' | 'south' | 'west' | 'north' observations: string[] // Accumulated insights } ```

New Relations: ```typescript // Inquiry genealogy { from: 'inquiry_child', to: 'inquiry_parent', relationType: 'branches_from' } { from: 'inquiry_a', to: 'inquiry_b', relationType: 'relates_to' }

// Inquiry to chart linkage { from: 'inquiry_x', to: 'chart_y', relationType: 'generates_chart' } ```

2.2 Register and Genealogy Tools

register_inquiry: ```typescript input: { question: string direction: 'east' | 'south' | 'west' | 'north' parentInquiryId?: string relatedInquiryIds?: string[] sessionId: string } output: { inquiryId: string ceremonyCheckRequired: boolean // Always true for new inquiries } ```

list_inquiry_genealogy: ```typescript input: { inquiryId: string depth?: number // How many generations to traverse direction?: 'ancestors' | 'descendants' | 'both' } output: { root: InquiryNode totalNodes: number maxDepth: number } ```

Phase 3: Context Continuum (Weeks 5-6)

3.1 Session State Management

Session stored in JSONL: ```jsonl {"type":"session","id":"sess_abc","parentSessionId":"sess_xyz","activeInquiries":["inq_1"],"activeCharts":["chart_1"],"createdAt":"..."} ```

3.2 Fork Session with Inheritance

fork_session: ```typescript input: { parentSessionId: string reason: string inheritedContext?: { inquiries?: 'all' | 'none' | string[] charts?: 'all' | 'active' | 'none' | string[] assumptions?: 'all' | 'validated' | 'none' } } output: { newSessionId: string inheritedContext: ContextSnapshot ceremonyCheckRequired: boolean } ```

Context Inheritance Logic: ```typescript async function forkSession(input: ForkInput): Promise<ForkResult> { // 1. Ceremony check for fork const check = await validateCeremonyGate('fork_session') if (check.requiresCheck) { const lastCheck = await getCeremonyCheck(input.parentSessionId, 'fork_session') if (!lastCheck?.canProceed) { return { ceremonyCheckRequired: true } } }

// 2. Get parent session const parent = await getSession(input.parentSessionId)

// 3. Build inherited context const context: ContextSnapshot = { currentReality: await buildCurrentReality(parent, input.inheritedContext), activeAssumptions: await filterAssumptions(parent, input.inheritedContext?.assumptions), recentInsights: await getRecentInsights(parent, 10), ceremonyCheckpoints: await getCeremonyHistory({ sessionId: parent.id }) }

// 4. Create child session const child = await createSession({ parentSessionId: parent.id, inheritedContext: context, reason: input.reason })

// 5. Trace in Langfuse await langfuse.addObservation({ traceId: parent.traceId, name: 'Fork Session', output_data: { childSessionId: child.id, inheritedItems: context } })

return { newSessionId: child.id, inheritedContext: context, ceremonyCheckRequired: false } } ```

Phase 4: IAIP Integration (Week 7)

4.1 Relational Assessment Enhancement

When ceremony checks occur, optionally invoke IAIP for guidance:

```typescript async function ceremonyCheckWithIAIP(input: CeremonyInput): Promise<CeremonyResult> { // Standard ceremony check const result = await standardCeremonyCheck(input)

// If context available, get IAIP guidance if (input.context?.chartId) { const chart = await getChart(input.context.chartId)

// Get relational alignment assessment
const alignment = await iaip.assessRelationalAlignment({
  projectDescription: chart.desiredOutcome
})

// Get direction guidance based on decision type
const direction = mapDecisionToDirection(input.decisionType)
const guidance = await iaip.getDirectionGuidance({
  direction,
  inquiry: input.decisionDescription
})

result.iaipGuidance = {
  direction,
  recommendation: guidance.synthesis,
  relationalAlignmentScore: alignment.overallScore
}

}

return result }

function mapDecisionToDirection(decisionType: string): Direction { switch(decisionType) { case 'create_inquiry': return 'east' // New beginnings case 'create_chart': return 'south' // Planning case 'complete_action': return 'west' // Action case 'export_artifact': return 'north' // Reflection/wisdom default: return 'east' } } ```

Phase 5: Seremia Memory Integration (Week 8)

5.1 Project-Specific Knowledge

Connect inquiry ecosystem to seremia's memory system:

```typescript // When inquiry registered async function registerInquiryWithMemory(inquiry: Inquiry): Promise<void> { // Store in coaia-narrative for genealogy await coaiaNarrative.createEntity(inquiry)

// Also store in seremia for project memory await seremia.addMemory({ type: 'inquiry', content: inquiry.question, context: { direction: inquiry.direction, sessionId: inquiry.sessionId, relatedTopics: inquiry.topics } }) }

// When session resumes async function getRelevantMemories(sessionId: string): Promise<Memory[]> { const session = await getSession(sessionId)

return seremia.searchMemories({ query: session.activeInquiries.map(i => i.question).join(' '), limit: 10 }) } ```

MCP Configuration

Claude Desktop / Claude Code Config

```json { "mcpServers": { "inquiry-ecosystem": { "command": "npx", "args": ["-y", "inquiry-ecosystem-mcp", "--data-path", "/path/to/inquiry-data.jsonl"], "env": { "COAIA_NARRATIVE_PATH": "/path/to/charts.jsonl", "IAIP_ENABLED": "true", "LANGFUSE_PUBLIC_KEY": "...", "LANGFUSE_SECRET_KEY": "..." } } } } ```

Alternative: Tool Delegation

If full integration is too heavy, use tool delegation pattern:

```typescript // inquiry-ecosystem MCP delegates to other MCPs const toolDelegation = { // Structural tension charts → coaia-narrative 'manage_action_step': 'coaia-narrative:manage_action_step', 'mark_action_complete': 'coaia-narrative:mark_action_complete',

// Relational assessment → iaip-mcp 'assess_relational_alignment': 'iaip-mcp:assess_relational_alignment', 'get_direction_guidance': 'iaip-mcp:get_direction_guidance',

// Tracing → coaiapy-aetherial 'coaia_fuse_trace_create': 'coaiapy-aetherial:coaia_fuse_trace_create',

// Project memory → seremia 'add_memory': 'seremia:add_memory' } ```

Testing Strategy

Unit Tests

• Ceremony check logic (pass, block, override)
• Inquiry genealogy traversal
• Session context inheritance
• Gate validation

Integration Tests

• Create chart with ceremony check flow
• Fork session with context inheritance
• Register inquiry with memory storage
• IAIP guidance injection

End-to-End Tests

• Full inquiry journey: register → ceremony → chart → action → complete
• Session fork and merge
• Override accountability trail

Success Metrics

Phase 1 Complete When:

• ceremony_check tool blocks chart creation without check
• Override decisions are permanently recorded
• Langfuse traces include ceremony observations

Phase 2 Complete When:

• Inquiries have traceable genealogy
• Child inquiries inherit parent context
• Four Directions tagging works

Phase 3 Complete When:

• Sessions fork with inherited context
• Child sessions can access parent's current reality
• Context snapshots are restorable

Phase 4 Complete When:

• IAIP provides guidance in ceremony checks
• Relational alignment scores are tracked
• Direction-aware tooling surfaces

Phase 5 Complete When:

• Project memories persist across sessions
• Relevant memories surface for new inquiries
• LSP-aware context is available

Risk Mitigation

This integration plan enables the prototype to be built incrementally, with each phase delivering measurable value. The ceremony check mechanism is Phase 1 because it's the structural accountability that the podcast demanded.