🌀
← Back to Articles & Artefacts
artefactsnorth

Inquiry Ecosystem Framework

IAIP Research
podcast_inquiry_ecosystem

Inquiry Ecosystem Framework

RISE Specification v0.1

A creative-oriented platform where AI and human collaborators co-create through structurally accountable inquiry, ensuring relational principles lead and ceremony guides technology.

Desired Outcome Definition

What this enables users to create:

  • Coherent research journeys that maintain context across sessions, forks, and collaborators
  • Inquiries that are structurally accountable to relational principles at every decision point
  • Living knowledge webs where questions, insights, and assumptions remain visible and interconnected

How users know they've achieved this:

  • Decision points pause for ceremonial check-in before proceeding
  • Inquiry genealogy is traceable from origin through all branches
  • Assumptions are visible, tested, and updated as understanding evolves
  • Context flows between sessions without loss of relational continuity

Structural Tension Analysis

Current Reality (What Exists):

  • coaia-narrative: Structural tension charts with telescoping, action steps, advancing patterns
  • coaia-visualizer: Web UI for chart visualization and MCP API
  • iaip-mcp-gemini: Four Directions guidance, relational alignment assessment, holistic inquiry
  • seremia: LSP-based semantic analysis, project memory, symbol-level code understanding
  • Podcast dialogues: Conceptual framework without implementation

Desired State:

  • Unified platform where these components serve ceremonial inquiry
  • Structural accountability built into every decision point (not as feature, as foundation)
  • Relational principles check (ceremony, relationship, ancestral wisdom) at every fork

Tension: The components exist but lack the structural mechanism that ensures relational accountability is primary. The podcast named it; now it must be built.

Components

1. Inquiry Registry

Creative Intent: Users create a living genealogy of their questions, seeing how inquiries relate, evolve, and branch.

Behavior:

  • Registers new inquiries with semantic tagging
  • Tracks parent-child relationships between inquiries
  • Maintains topic connections across the entire ecosystem
  • Surfaces related inquiries when new questions emerge

Implementation Mapping:

  • seremia memory system → Project-specific knowledge persistence
  • coaia-narrative entities → inquiry entity type with relations
  • iaip-mcp → Four Directions tagging (which direction does this inquiry belong to?)

Data Model: ```typescript interface Inquiry { id: string question: string direction: 'east' | 'south' | 'west' | 'north' // Four Directions parentInquiryId?: string relatedInquiryIds: string[] topics: string[] createdAt: Date sessionId: string assumptions: AssumptionRef[] } ```

2. Context Continuum

Creative Intent: Users create seamless inquiry journeys where child sessions inherit parent context without redundant effort.

Behavior:

  • Preserves state when sessions branch (Agent Continuations pattern)
  • Coordinates real-time across parallel sessions (Anemoi A2A pattern)
  • Flows discoveries between related inquiry lines
  • Maintains living awareness through all explorations

Implementation Mapping:

  • seremia project indexing → Session state persistence
  • coaia-narrative charts → Active tension charts flow to child sessions
  • Langfuse tracing (coaiapy) → Session lineage tracking via trace/observation hierarchy

Data Model: ```typescript interface Session { id: string parentSessionId?: string childSessionIds: string[] activeInquiries: string[] activeCharts: string[] // Structural tension chart IDs inheritedContext: ContextSnapshot createdAt: Date }

interface ContextSnapshot { currentReality: string[] activeAssumptions: Assumption[] recentInsights: string[] ceremonyCheckpoints: CeremonyCheck[] } ```

3. Dynamic Workspaces

Creative Intent: Users create adaptive environments that configure themselves to the inquiry's emergent needs.

Behavior:

  • IDE/environment adapts to inquiry context
  • Surfaces relevant tools, files, and context for current focus
  • Draws from Inquiry Registry and Context Continuum
  • Reduces context switching by maintaining alignment

Implementation Mapping:

  • seremia LSP integration → Symbol-aware workspace configuration
  • coaia-visualizer → Chart-driven workspace focus
  • iaip-mcp → Direction-aware tooling (East tools for new beginnings, West for action)

Natural Progression:

  1. User opens workspace with inquiry context
  2. System loads relevant charts, assumptions, prior sessions
  3. Tools and files surface based on inquiry genealogy
  4. User works within maintained context

4. Structural Tension Charts

Creative Intent: Users create living maps of their creative journey, articulating desired outcomes and current reality to generate advancing patterns.

Behavior:

  • Formalizes intent as portable storyform
  • Tracks desired outcome ↔ current reality tension
  • Supports telescoping (breaking complex goals into sub-charts)
  • Completed actions flow into current reality

Implementation Mapping:

  • coaia-narrative → Full implementation already exists
  • coaia-visualizer → Web UI for chart editing
  • MCP tools → create_structural_tension_chart, manage_action_step, mark_action_complete

CRITICAL ENHANCEMENT: Ceremony Check Integration Each chart must include: ```typescript interface CeremonyAwareChart extends StructuralTensionChart { ceremonyChecks: CeremonyCheck[] lastCeremonyValidation: Date relationalAccountabilityScore?: number } ```

5. Assumption Log

Creative Intent: Users create transparent records of their foundational beliefs, making the invisible visible.

Behavior:

  • Documents underlying beliefs and hypotheses
  • Tracks confidence levels for each assumption
  • Links assumptions to inquiries and decisions
  • Surfaces assumptions for re-evaluation as new information emerges

Implementation Mapping:

  • coaia-narrative observations → Assumptions as observations on entities
  • seremia memories → Persistent assumption storage
  • Langfuse → Assumption validation traces

Data Model: ```typescript interface Assumption { id: string statement: string confidence: 'high' | 'medium' | 'low' | 'untested' sourceInquiryId: string evidenceFor: string[] evidenceAgainst: string[] lastValidated: Date relatedDecisions: string[] } ```

6. Structural Accountability Mechanism (NEW)

Creative Intent: Users create inquiry systems where relational accountability is not a feature but the foundation—where every decision point asks: "Does this serve ceremony? Does this strengthen relationship? Does this honor ancestral wisdom?"

This is what the podcast called for. This is what must be built.

Behavior:

Decision Point Protocol: At every fork in the system, a structural pause:

  1. System surfaces the pending decision
  2. Three questions are presented:
    • 🔥 Does this serve ceremony?
    • 🌊 Does this strengthen relationship?
    • 🌲 Does this honor ancestral wisdom?
  3. User/AI must respond before proceeding
  4. Response is logged as CeremonyCheck record
  5. If all three answered "no" → decision cannot proceed without explicit override

Implementation: ```typescript interface CeremonyCheck { id: string decisionPoint: string timestamp: Date questions: { servesCeremony: boolean | null strengthensRelationship: boolean | null honorsAncestralWisdom: boolean | null } reflection: string override?: { reason: string approvedBy: string } }

interface DecisionGate { type: 'fork_inquiry' | 'create_chart' | 'complete_action' | 'branch_session' | 'export_artifact' requiresCeremonyCheck: boolean minimumYesCount: number // How many of the 3 questions must be 'yes' } ```

Integration Points:

  • iaip-mcp assess_relational_alignment → Provides automated initial assessment
  • iaip-mcp get_direction_guidance → Consults Four Directions for decision context
  • Langfuse tracing → Every ceremony check becomes a traced observation
  • coaia-narrative → Ceremony checks stored as observations on charts

Why This Is Structural, Not Feature:

  1. Gate Architecture: The system literally cannot proceed without the check. Not by ignoring it, not by skipping it—the check is the path through.

  2. Override Transparency: If someone overrides a "no" answer, that override is permanently visible in the inquiry's history. Accountability is structural.

  3. Pattern Recognition: Over time, the system learns which decision patterns consistently answer "no" to ceremony questions. These become early warnings for future inquiries.

  4. Ceremonial Time: The pause itself is part of the mechanism. Not performance. Structure.

Component Relationships

``` ┌─────────────────────────────────────────────────────────────────┐ │ STRUCTURAL ACCOUNTABILITY │ │ (Ceremony Check at every gate) │ └───────────────────────────┬─────────────────────────────────────┘ │ ┌───────────────────┼───────────────────┐ │ │ │ ▼ ▼ ▼ ┌───────────────┐ ┌───────────────┐ ┌───────────────┐ │ Inquiry │◄──│ Context │──►│ Dynamic │ │ Registry │ │ Continuum │ │ Workspaces │ └───────┬───────┘ └───────┬───────┘ └───────────────┘ │ │ │ ┌───────────────┘ ▼ ▼ ┌───────────────┐ ┌───────────────┐ │ Structural │◄─────────►│ Assumption │ │Tension Charts │ │ Log │ └───────────────┘ └───────────────┘ ```

Flow:

  1. Inquiry starts → ceremony check (does this question serve ceremony?)
  2. Chart created → ceremony check (does this desired outcome strengthen relationship?)
  3. Session branches → ceremony check (does this fork honor ancestral wisdom?)
  4. Action completed → flows to current reality (no ceremony check—it's advancement)
  5. Artifact exported → ceremony check (does sharing this serve the circle?)

Implementation Phases

Phase 1: Foundation (coaia-narrative + iaip-mcp integration)

Current Reality: coaia-narrative has charts, iaip-mcp has assessment tools, but they don't communicate.

Desired Outcome: Single MCP server that combines structural tension with relational assessment.

Action Steps:

  1. Create unified MCP server that wraps both coaia-narrative and iaip-mcp
  2. Add CeremonyCheck entity type to coaia-narrative
  3. Implement Decision Gate middleware that intercepts key operations
  4. Add ceremony_check tool that returns structured assessment

Phase 2: Inquiry Registry (seremia memory + coaia-narrative)

Current Reality: seremia has project memory, coaia-narrative has entities, but no inquiry genealogy.

Desired Outcome: Semantic inquiry tracking with parent-child relationships.

Action Steps:

  1. Define inquiry entity type in coaia-narrative
  2. Implement genealogy relations (branches_from, relates_to)
  3. Connect to seremia memory for persistence
  4. Create register_inquiry and list_inquiry_genealogy tools

Phase 3: Context Continuum (session state + Langfuse)

Current Reality: Langfuse traces sessions, but no automatic context inheritance.

Desired Outcome: Child sessions inherit parent context automatically.

Action Steps:

  1. Define session state schema (active charts, assumptions, insights)
  2. Implement fork_session tool that copies inherited context
  3. Add Langfuse observation linking for session lineage
  4. Create context snapshot restoration on session resume

Phase 4: Dynamic Workspaces (seremia LSP + visualization)

Current Reality: seremia does LSP analysis, coaia-visualizer shows charts, but not integrated.

Desired Outcome: Workspace that adapts based on inquiry context.

Action Steps:

  1. Connect seremia project context to coaia-visualizer
  2. Implement inquiry-aware file surfacing
  3. Add direction-based tool recommendations
  4. Create unified workspace state management

Success Criteria

The prototype succeeds when:

  1. ✅ A ceremony check is required to create a new structural tension chart
  2. ✅ Branching a session inherits parent context without manual effort
  3. ✅ Inquiry genealogy is visible and navigable
  4. ✅ Assumptions are linked to decisions and revisitable
  5. ✅ Override decisions are permanently visible in history
  6. ✅ An LLM can use the MCP tools to conduct a structurally accountable inquiry

The prototype fails the Wilson test if:

  • ❌ Ceremony checks can be skipped without trace
  • ❌ Relational assessment is optional decoration
  • ❌ Technology leads and ceremony follows
  • ❌ The mechanism doesn't actually stop anything

Reference

Source Materials:

  • Podcast Episodes 001-031 (Inquiry Ecosystem Framework dialogue)
  • Wilson, Shawn - Research Is Ceremony (Indigenous Paradigm)
  • RISE Framework (llms-rise-framework.txt)
  • coaia-narrative CLAUDE.md
  • iaip-mcp README.md
  • seremia CLAUDE.md

Related Systems:

  • /src/coaia-narrative/ - Structural tension charts
  • /src/coaia-visualizer/ - Chart visualization
  • /src/mcp-iaip-gemini/ - Four Directions + relational assessment
  • /workspace/repos/miadisabelle/seremia - Semantic analysis + memory

This specification is codebase-agnostic. Another LLM can implement from this document without accessing the original source code.