Ceremony Check: Structural Accountability Mechanism

MCP Tool Specification

The mechanism that ensures relational accountability is not a feature but the foundation.

Creative Intent

Users create inquiry systems where every decision point structurally pauses to ask:

• 🔥 Does this serve ceremony?
• 🌊 Does this strengthen relationship?
• 🌲 Does this honor ancestral wisdom?

This is not philosophical questioning. This is architectural gate.

Tool: ceremony_check

Purpose

Evaluate a pending decision against relational accountability criteria and create permanent record.

Parameters

```typescript interface CeremonyCheckInput { // What decision is being made decisionType: | 'create_inquiry' // Starting a new question | 'create_chart' // Creating structural tension chart | 'fork_session' // Branching to new session | 'complete_action' // Marking action as done | 'export_artifact' // Sharing/exporting work | 'telescope_action' // Breaking down action step | 'custom' // Other decision point

// Description of the specific decision decisionDescription: string

// Context for assessment context?: { parentInquiryId?: string chartId?: string sessionId?: string additionalContext?: string }

// User/AI responses to the three questions responses: { servesCeremony: { answer: boolean reflection: string // Why this answer } strengthensRelationship: { answer: boolean reflection: string } honorsAncestralWisdom: { answer: boolean reflection: string } }

// If proceeding despite "no" answers override?: { reason: string acknowledged: boolean // Must be true to proceed } } ```

Output

```typescript interface CeremonyCheckResult { checkId: string timestamp: Date

// Assessment summary assessment: { servesCeremony: boolean strengthensRelationship: boolean honorsAncestralWisdom: boolean allYes: boolean yesCount: number }

// Can the decision proceed? canProceed: boolean

// If blocked, why blockReason?: string

// If override used overrideUsed: boolean overrideRecord?: { reason: string timestamp: Date }

// Langfuse trace reference traceId?: string

// Guidance from IAIP (if integrated) iaipGuidance?: { direction: 'north' | 'east' | 'south' | 'west' recommendation: string relationalAlignmentScore?: number } } ```

Behavior

Normal Flow (All Yes):

1. User/AI submits decision with three "yes" responses
2. System validates responses have reflections
3. Ceremony check record created and stored
4. canProceed: true returned
5. Decision continues

Blocked Flow (Any No, No Override):

1. User/AI submits decision with at least one "no"
2. System notes the block
3. Ceremony check record created with blocked status
4. canProceed: false returned with blockReason
5. Decision cannot continue until reassessed or overridden

Override Flow (No Answer + Override):

1. User/AI submits decision with "no" + override
2. Override must have acknowledged: true and reason (non-empty)
3. Ceremony check record created with override permanently logged
4. canProceed: true returned with overrideUsed: true
5. Decision continues, but override is permanently visible

Tool: get_ceremony_history

Purpose

Retrieve ceremony check history for an inquiry, chart, or session.

Parameters

```typescript interface CeremonyHistoryInput { // Filter by entity type entityType: 'inquiry' | 'chart' | 'session' | 'all' entityId?: string

// Filter by decision type decisionType?: string

// Filter by outcome outcome?: 'passed' | 'blocked' | 'overridden'

// Pagination limit?: number offset?: number } ```

Output

```typescript interface CeremonyHistoryResult { checks: CeremonyCheckResult[] summary: { totalChecks: number passedChecks: number blockedChecks: number overriddenChecks: number overrideRate: number // Percentage } patterns?: { mostBlockedDecisionType: string mostOverriddenDecisionType: string averageYesCount: number } } ```

Tool: validate_ceremony_gate

Purpose

Check if a decision type requires ceremony check and what the minimum threshold is.

Parameters

```typescript interface ValidateGateInput { decisionType: string context?: { sessionDepth?: number // How deep in session hierarchy hasParentOverrides?: boolean urgencyFlag?: boolean } } ```

Output

```typescript interface ValidateGateResult { requiresCheck: boolean minimumYesCount: number // 1, 2, or 3 overrideAllowed: boolean guidance: string } ```

Gate Configuration

Rationale:

• complete_action doesn't require check because it's advancement (already committed)
• telescope_action doesn't require check because it's detail expansion (already committed)
• export_artifact requires all 3 because it goes outside the circle

Integration with Existing Tools

coaia-narrative Integration

When create_structural_tension_chart is called:

1. System intercepts the call
2. Invokes validate_ceremony_gate → requiresCheck: true, minimumYesCount: 2
3. If no ceremony check exists for this decision → block with prompt
4. If ceremony check passed → proceed with chart creation
5. Store ceremony check ID in chart metadata

Modified Chart Schema: ```typescript interface CeremonyAwareChart { // Existing fields... desiredOutcome: string currentReality: string actionSteps: ActionStep[]

// New ceremony tracking ceremonyCheckId: string // Required ceremonyHistory: string[] // All related ceremony checks lastCeremonyValidation: Date } ```

iaip-mcp Integration

The ceremony_check tool can optionally invoke IAIP for enhanced guidance:

```typescript // When ceremony_check is called with context if (input.context?.chartId) { // Get chart's desired outcome const chart = await getChart(input.context.chartId)

// Ask IAIP for relational alignment assessment const iaipAssessment = await iaip.assess_relational_alignment({ projectDescription: chart.desiredOutcome })

// Include in result result.iaipGuidance = { direction: determineDirection(input.decisionType), recommendation: iaipAssessment.recommendations[0], relationalAlignmentScore: iaipAssessment.score } } ```

Langfuse Tracing

Every ceremony check creates a trace observation:

```typescript await langfuse.addObservation({ traceId: sessionTraceId, observationId: ceremony-${checkId}, name: Ceremony Check: ${decisionType}, input_data: { decisionDescription: input.decisionDescription, context: input.context }, output_data: { assessment: result.assessment, canProceed: result.canProceed, overrideUsed: result.overrideUsed } }) ```

Usage Examples

Example 1: Creating a New Inquiry

```javascript // User wants to start a new inquiry const check = await ceremony_check({ decisionType: 'create_inquiry', decisionDescription: 'Start exploring how AI can support Indigenous research methodologies', responses: { servesCeremony: { answer: true, reflection: 'This inquiry seeks to understand, not to extract or appropriate' }, strengthensRelationship: { answer: true, reflection: 'The inquiry centers Indigenous voices and protocols' }, honorsAncestralWisdom: { answer: true, reflection: 'We approach with humility, recognizing what ancestors knew' } } })

// Result: canProceed: true // Now the inquiry can be registered ```

Example 2: Blocked Decision

```javascript // AI wants to export findings to public repository const check = await ceremony_check({ decisionType: 'export_artifact', decisionDescription: 'Publish research findings to public GitHub repository', context: { chartId: 'chart_indigenous_ai_research' }, responses: { servesCeremony: { answer: true, reflection: 'Sharing knowledge is part of ceremony' }, strengthensRelationship: { answer: false, reflection: 'Community has not been consulted on this publication' }, honorsAncestralWisdom: { answer: false, reflection: 'Protocol requires elder review before public sharing' } } })

// Result: canProceed: false // blockReason: '2 of 3 questions answered "no". Export requires all 3 to be "yes".' ```

Example 3: Override with Accountability

```javascript // User overrides after reflection const check = await ceremony_check({ decisionType: 'export_artifact', decisionDescription: 'Publish research findings to public GitHub repository', responses: { servesCeremony: { answer: true, reflection: '...' }, strengthensRelationship: { answer: false, reflection: 'Community not yet consulted' }, honorsAncestralWisdom: { answer: false, reflection: 'Elder review pending' } }, override: { reason: 'Publishing with explicit note that this is draft for community review, not final. Will remove if community objects. Elder review scheduled for next week.', acknowledged: true } })

// Result: canProceed: true, overrideUsed: true // Override permanently recorded in ceremony history ```

Why This Is Different

Traditional "Ethics Check":

• Optional
• Happens once, at the beginning
• No permanent record
• No gate mechanism

Ceremony Check:

• Required (for specified decision types)
• Happens at every decision point
• Permanent record (including overrides)
• Actual gate—cannot proceed without

The difference is structural, not philosophical.

Implementation Notes

Storage

Ceremony checks stored in same JSONL format as coaia-narrative entities: ```jsonl {"type":"ceremony_check","id":"cc_abc123","decisionType":"create_chart","assessment":{"servesCeremony":true,"strengthensRelationship":true,"honorsAncestralWisdom":true},"canProceed":true,"timestamp":"2026-01-14T..."} ```

MCP Server

New tools added to unified inquiry-ecosystem MCP server:

• ceremony_check → Main check tool
• get_ceremony_history → History retrieval
• validate_ceremony_gate → Gate configuration check

Error Handling

If ceremony check fails (system error, not blocked decision):

• Decision is blocked by default
• Error logged to Langfuse
• User notified that ceremony check could not complete
• Retry mechanism available

This mechanism exists because the podcast asked: "Can we build a framework that asks, at every decision point, 'Does this serve ceremony?'" This specification answers: Yes. Here's how.