RISE Specification: Wisdom Ledger

Desired Outcome

A temporal, queryable record of how IAIP framework concepts are used, referenced, and evolved across sessions, agents, and ceremonies. The Wisdom Ledger reveals emergent patterns: which concepts are most alive, which relationships are most traversed, where directional imbalances exist, and how the framework itself grows over time.

Current Reality

• Concept usage is ephemeral — once a session ends, no record of which concepts were queried
• No way to see concept evolution over time (when definitions changed, why, by whom)
• The Ceremonial Inquiry Ecosystem Framework describes a Wisdom Ledger as a linked database/knowledge graph, but no implementation exists
• Agents cannot learn from each other's concept usage patterns
• No mechanism to detect concept drift or terminology evolution

Structural Tension

Between ephemeral concept interactions that vanish with each session and a living record that accumulates wisdom, reveals patterns, and guides the framework's evolution as a community practice.

Key Features

1. Usage Event Tracking

Every concept access is logged (opt-in, respecting OCAP):

```python class UsageEvent(BaseModel): id: str # UUID timestamp: datetime concept_id: str # Which concept was accessed event_type: str # "lookup" | "relationship_query" | "validation" | "suggestion" agent_id: str # Which agent or user queried session_id: Optional[str] # Session context direction_context: Optional[str] # Which direction the query serves query_context: Optional[str] # Brief description of why response_depth: str # "brief" | "full" | "relational" ocap_result: str # "granted" | "partial" | "ceremony_needed" ```

2. Concept Evolution History

Track how concept definitions change over time:

```python class ConceptVersion(BaseModel): concept_id: str version: int timestamp: datetime definition: str indigenous_connections: dict ocap_flags: dict changed_by: str ceremony_id: Optional[str] change_reason: Optional[str] previous_version: Optional[int] ```

3. Pattern Queries

The Wisdom Ledger supports queries that reveal emergent patterns:

```sql -- Most accessed concepts this week SELECT concept_id, COUNT(*) as access_count FROM usage_events WHERE timestamp > date('now', '-7 days') GROUP BY concept_id ORDER BY access_count DESC;

-- Concept pairs frequently queried together SELECT e1.concept_id, e2.concept_id, COUNT(*) as pair_count FROM usage_events e1 JOIN usage_events e2 ON e1.session_id = e2.session_id AND e1.concept_id < e2.concept_id AND abs(julianday(e1.timestamp) - julianday(e2.timestamp)) < 0.01 GROUP BY e1.concept_id, e2.concept_id ORDER BY pair_count DESC;

-- Directional balance over time SELECT direction_context, strftime('%W', timestamp) as week, COUNT(*) as queries FROM usage_events WHERE direction_context IS NOT NULL GROUP BY direction_context, week;

-- Concepts that have never been accessed (dormant wisdom) SELECT c.id FROM concepts c LEFT JOIN usage_events u ON c.id = u.concept_id WHERE u.id IS NULL;

-- Agent-concept affinity (which agents use which concepts most) SELECT agent_id, concept_id, COUNT(*) as affinity FROM usage_events GROUP BY agent_id, concept_id ORDER BY affinity DESC; ```

4. Wisdom Summaries

Periodic summaries generated for the Steward's Compass:

```python class WisdomSummary(BaseModel): period: str # "week" | "moon_cycle" | "quarter" start_date: date end_date: date

# Usage patterns
total_queries: int
unique_concepts_accessed: int
most_active_concepts: list[tuple[str, int]]
dormant_concepts: list[str]

# Relationship patterns
most_traversed_relationships: list[tuple[str, str, int]]
emerging_relationships: list[tuple[str, str]]  # New pairs queried together

# Directional balance
direction_distribution: dict[str, int]
balance_assessment: str
balance_recommendation: Optional[str]

# Evolution
concepts_added: list[str]
concepts_modified: list[str]
ceremonies_held: int

# Agent ecosystem
active_agents: list[str]
agent_concept_affinities: dict[str, list[str]]

```

5. Integration with Ceremonial Inquiry Ecosystem

The Wisdom Ledger maps directly to the Six Thematic Suns:

```python class InquiryWisdomLink(BaseModel): """Links concept usage to Ceremonial Inquiry Ecosystem""" sun_name: str # Which Thematic Sun this usage relates to inquiry_id: Optional[str] # Which specific inquiry cycle_phase: Optional[str] # Opening | Dialogue | Integration | Closure reciprocity_note: Optional[str] # How this query contributes to the ecosystem ```

6. Advancing Pattern Detection

The Wisdom Ledger identifies whether concept usage patterns are advancing (spiraling forward) or oscillating (circling back):

```python class PatternDetector: def detect_pattern(self, concept_id: str, window: int = 30) -> PatternType: """Analyze usage pattern for a concept over N days""" usage = self.get_usage_timeline(concept_id, window)

    if self._is_deepening(usage):
        return PatternType.ADVANCING  # Queries go deeper over time
    
    if self._is_repeating(usage):
        return PatternType.OSCILLATING  # Same shallow queries repeating
    
    if self._is_dormant(usage):
        return PatternType.DORMANT  # Concept not being accessed
    
    return PatternType.EMERGING  # New concept starting to be used

```

Storage

SQLite database (wisdom.db) with tables:

```sql CREATE TABLE usage_events ( id TEXT PRIMARY KEY, timestamp TEXT NOT NULL, concept_id TEXT NOT NULL, event_type TEXT NOT NULL, agent_id TEXT, session_id TEXT, direction_context TEXT, query_context TEXT, response_depth TEXT, ocap_result TEXT );

CREATE TABLE concept_versions ( concept_id TEXT NOT NULL, version INTEGER NOT NULL, timestamp TEXT NOT NULL, definition TEXT NOT NULL, indigenous_connections TEXT, -- JSON ocap_flags TEXT, -- JSON changed_by TEXT, ceremony_id TEXT, change_reason TEXT, PRIMARY KEY (concept_id, version) );

CREATE TABLE ceremony_changes ( id TEXT PRIMARY KEY, timestamp TEXT NOT NULL, change_type TEXT NOT NULL, concept_id TEXT NOT NULL, ceremony_level TEXT NOT NULL, changed_by TEXT, witnessed_by TEXT, -- JSON array ceremony_id TEXT, direction_reviews TEXT, -- JSON reflection TEXT, reciprocity_note TEXT );

CREATE INDEX idx_usage_concept ON usage_events(concept_id); CREATE INDEX idx_usage_agent ON usage_events(agent_id); CREATE INDEX idx_usage_time ON usage_events(timestamp); CREATE INDEX idx_usage_direction ON usage_events(direction_context); ```

Success Metrics

• 100% of concept accesses logged (with opt-out for performance-sensitive loops)
• Pattern detection correctly identifies advancing vs. oscillating usage in ≥80% of test cases
• Wisdom Summaries generated automatically at configurable intervals
• Dormant concepts surfaced for community attention
• Directional balance assessed and recommendations actionable
• Concept version history enables "time travel" — query any concept as it was at any past date
• SQLite DB remains under 100MB after 6 months of typical usage

Dependencies

• Concept Registry (from rispecs.md)
• OCAP layer (from rispecs-ceremony-protocol.md)
• Four Directions metadata (from rispecs-ceremony-protocol.md)
• SQLite (stdlib, no additional dependency)