schema.md — Relational Protocol Type Definitions

Overview

This document defines the eight relational protocol types that form the foundation of the Indigenous Relational Ontology System. Each protocol type is grounded in Wilson's (2008) four-element Indigenous Research Paradigm and structured through medicine-wheel relational patterns.

Unlike Western schema definitions that classify objects into hierarchical categories, these protocol types define relational patterns — ways of being in relationship with knowledge, communities, and the land. Each protocol is not a container for data but a description of how relationships are established, maintained, honored, and completed.

Design Principles

1. Relations over entities: Every schema element defines a relationship, not an object
2. Context is content: Relational context IS the knowledge, not metadata
3. Consent is structural: Consent is woven into the schema, not bolted on
4. Accountability is bidirectional: Every relationship carries mutual responsibilities
5. Sovereignty is foundational: Community governance underlies all protocol types

Protocol Type Architecture

``` ┌─────────────────────┐ │ SOVEREIGNTY │ │ (Foundation) │ └──────────┬──────────┘ │ ┌──────────────────┼──────────────────┐ │ │ │ ┌───────┴───────┐ ┌──────┴──────┐ ┌───────┴───────┐ │ KINSHIP │ │ CEREMONY │ │ CONSENT │ │ (Being) │ │ (Doing) │ │ (Choosing) │ └───────┬───────┘ └──────┬──────┘ └───────┬───────┘ │ │ │ ┌───────┴───────┐ ┌──────┴──────┐ ┌───────┴───────┐ │ TERRITORY │ │ STORY │ │ RECIPROCITY │ │ (Belonging) │ │ (Telling) │ │ (Balancing) │ └───────┬───────┘ └──────┬──────┘ └───────┬───────┘ │ │ │ └──────────────────┼──────────────────┘ │ ┌──────────┴──────────┐ │ ACCOUNTABILITY │ │ (Completing) │ └─────────────────────┘ ```

Protocol Type 1: Kinship Protocol

1.1 Purpose

The Kinship Protocol defines how relational connections are established and maintained between knowledge holders, communities, systems, and the land. In Indigenous epistemology, kinship is not limited to biological family — it encompasses all the relationships that constitute one's identity and place in the world.

Wilson (2008) writes: "Relationships do not merely shape reality, they ARE reality." The Kinship Protocol operationalizes this understanding.

1.2 Wilson Paradigm Alignment

• Ontology: Kinship defines what exists — entities exist through their relationships
• Epistemology: Knowing happens through kinship — you know someone by being in relation with them
• Axiology: Kinship carries values — relational responsibilities define what matters
• Methodology: Kinship is the method — establishing relations IS the research process

1.3 Medicine Wheel Alignment

• Primary Direction: South (Trust/Relationship)
• Patterns: Growth Pattern, Trust Pattern, Heart Pattern
• Seasonal Alignment: Summer — the time of building and nurturing

1.4 Schema Definition

```yaml kinship_protocol: type: relational_protocol version: "2.0" direction: south

A kinship relationship connects two or more relational entities

relationship: id: string # Unique relationship identifier type: enum # Type of kinship relationship values: - knowledge_sharing # Mutual knowledge exchange - mentorship # Elder-learner relationship - partnership # Collaborative partnership - stewardship # Caretaking responsibility - alliance # Political or governance alliance - kinship_adoption # Formal relational adoption - land_relation # Relationship with territory/land - spirit_relation # Relationship with spiritual entities - ancestor_relation # Relationship with ancestors - future_relation # Relationship with future generations

participants:
  - entity_id: string         # Reference to relational entity
    role: string              # Role in this relationship
    responsibilities: list    # Specific responsibilities
    gifts: list               # What this entity brings
    needs: list               # What this entity needs

established_date: datetime    # When relationship was formalized
ceremony_id: string           # Ceremony in which it was established
consent_ids: list             # Consent records for each participant
territory_id: string          # Territory where relationship lives

# Relational health indicators
health:
  trust_level: float          # 0.0 to 1.0, assessed by participants
  reciprocity_balance: float  # -1.0 to 1.0, 0 is balanced
  last_ceremony: datetime     # Last ceremony involving this relation
  last_contact: datetime      # Last interaction
  status: enum
    values:
      - active                # Relationship is active and healthy
      - dormant               # Relationship exists but is inactive
      - strained              # Relationship needs attention
      - healing               # Relationship is in repair
      - completed             # Relationship has run its course
      - severed               # Relationship has been formally ended

# Accountability structure
accountability:
  overseer: string            # Who oversees this relationship
  review_schedule: string     # How often relationship is reviewed
  dispute_protocol: string    # How disputes are resolved
  renewal_protocol: string    # How relationship is renewed

```

1.5 Operations

1.6 Extraction Detection Hooks

The Kinship Protocol monitors for:

• Instrumental relationships: Relationships formed solely to extract knowledge
• Asymmetric participation: One party doing all the giving
• Missing ceremony: Relationships formed without proper ceremony
• Consent decay: Relationships continuing beyond consent expiry

1.7 Example

```python kinship = KinshipProtocol() relationship = kinship.establish( type="knowledge_sharing", participants=[ { "entity_id": "community_001", "role": "knowledge_holder", "responsibilities": ["share_when_appropriate", "maintain_context"], "gifts": ["traditional_ecological_knowledge"], "needs": ["respect", "reciprocity", "accountability"] }, { "entity_id": "researcher_002", "role": "learner", "responsibilities": ["listen_deeply", "return_knowledge", "cite_properly"], "gifts": ["documentation_skills", "wider_dissemination"], "needs": ["guidance", "patience", "cultural_context"] } ], ceremony_id="opening_ceremony_2024_001", territory_id="anishinaabe_territory_001" ) ```

Protocol Type 2: Ceremony Protocol

2.1 Purpose

The Ceremony Protocol defines how knowledge interactions are opened, conducted, and closed. In Indigenous methodology, research is ceremony (Wilson, 2008) — every act of knowledge exchange is sacred and must be conducted with proper relational protocols.

A ceremony is not a metaphor or a UX pattern. It is a structural container that ensures all knowledge interactions occur within a relational context of intention, consent, reciprocity, and accountability.

2.2 Wilson Paradigm Alignment

• Ontology: Ceremony creates relational space — it brings relationships into being
• Epistemology: Ceremony IS the method of knowing — knowledge flows through ceremonial practice
• Axiology: Ceremony embodies values — it enacts relational accountability
• Methodology: Ceremony is the method — "Research Is Ceremony" (Wilson)

2.3 Medicine Wheel Alignment

• Primary Direction: East (Dawn/Beginning/Vision)
• Patterns: Emergence Pattern, Vision Pattern, Illumination Pattern
• Seasonal Alignment: Spring — the time of new beginnings

2.4 Schema Definition

```yaml ceremony_protocol: type: relational_protocol version: "2.0" direction: east

ceremony: id: string # Unique ceremony identifier type: enum values: - opening # Beginning a knowledge interaction - closing # Completing a knowledge interaction - renewal # Renewing relationships or consent - healing # Repairing damaged relationships - celebration # Honoring achievements and gifts - mourning # Acknowledging loss and transition - transfer # Transferring knowledge or responsibility - initiation # Beginning a new phase of relationship - seasonal # Regular seasonal ceremony - emergency # Urgent relational response

# Ceremony context
context:
  intention: string           # Why this ceremony is being held
  initiator: string           # Who called the ceremony
  participants: list          # All ceremony participants
  territory: string           # Where the ceremony takes place
  time: datetime              # When the ceremony begins
  duration: string            # Expected duration
  season: string              # Seasonal context

# Ceremony requirements
requirements:
  consent_verified: boolean   # All consents checked
  kinship_established: boolean # All relationships established
  reciprocity_offered: boolean # Reciprocity terms stated
  accountability_accepted: boolean # Responsibilities acknowledged
  territory_acknowledged: boolean  # Territory properly acknowledged
  elders_consulted: boolean   # Elder guidance obtained

# Ceremony state
state:
  status: enum
    values:
      - preparing             # Ceremony is being prepared
      - opening               # Opening protocols in progress
      - active                # Ceremony is underway
      - paused                # Ceremony is temporarily paused
      - closing               # Closing protocols in progress
      - completed             # Ceremony has been completed
      - abandoned             # Ceremony was abandoned (logged)
      - violated              # Ceremony protocols were violated

  opened_at: datetime
  closed_at: datetime
  operations_count: integer   # Number of operations performed
  violations: list            # Any protocol violations detected
  extraction_alerts: list     # Any extraction alerts raised

# Ceremony record (immutable after closing)
record:
  summary: string             # Summary of what occurred
  outcomes: list              # What was achieved
  reciprocity_status: object  # Current reciprocity state
  accountability_notes: list  # Accountability observations
  next_steps: list            # Agreed-upon next steps
  gratitude: string           # Closing gratitude statement

```

2.5 Operations

2.6 Ceremony Lifecycle

``` prepare → open → [active operations] → close → seal │ ├── pause → resume │ └── violation detected → close → review → heal ```

2.7 Example

```python ceremony = CeremonyProtocol() session = ceremony.open( type="opening", intention="Explore water governance knowledge", initiator="researcher_002", participants=["community_001", "researcher_002", "elder_003"], territory="great_lakes_territory", requirements={ "consent_verified": True, "kinship_established": True, "reciprocity_offered": True, "accountability_accepted": True, "territory_acknowledged": True, "elders_consulted": True } ) ```

Protocol Type 3: Consent Protocol

3.1 Purpose

The Consent Protocol defines how permission is obtained, recorded, verified, and renewed for all knowledge operations. Unlike Western informed consent (a one-time signature on a form), Indigenous consent is:

• Ongoing: Consent must be maintained throughout the relationship
• Community-governed: Individuals alone cannot consent for community knowledge
• Layered: Multiple levels of consent may be required
• Revocable: Consent can be withdrawn at any time
• Contextual: Consent is specific to purpose, time, and scope

3.2 Wilson Paradigm Alignment

• Ontology: Consent defines what is permissible in the relational field
• Epistemology: Knowing requires permission — there is knowledge you are not entitled to
• Axiology: Consent is a core value — it embodies respect and autonomy
• Methodology: Consent is methodological — it shapes what research can occur

3.3 Medicine Wheel Alignment

• Primary Direction: South (Heart/Trust)
• Patterns: Heart Pattern, Trust Pattern
• Seasonal Alignment: Summer — trust-building season

3.4 Schema Definition

```yaml consent_protocol: type: relational_protocol version: "2.0" direction: south

consent_record: id: string # Unique consent identifier type: enum values: - individual # Individual person's consent - community # Community governance consent - elder # Elder or knowledge keeper consent - institutional # Institutional consent - territorial # Territory-based consent - ceremonial # Ceremony-specific consent - temporal # Time-limited consent - conditional # Consent with specific conditions

# Who is granting consent
grantor:
  entity_id: string
  authority: string           # By what authority they consent
  governance_body: string     # Governance body they represent
  verification: string        # How their authority was verified

# What is being consented to
scope:
  knowledge_domains: list     # Which knowledge areas
  operations: list            # Which operations are permitted
  purposes: list              # For what purposes
  audiences: list             # Who can access
  territories: list           # In which territories
  timeframe:
    start: datetime
    end: datetime             # Null means ongoing with review
    review_interval: string   # How often consent is reviewed

# Consent conditions
conditions:
  reciprocity_required: boolean
  reciprocity_terms: string
  attribution_required: boolean
  attribution_format: string
  community_review: boolean
  community_review_schedule: string
  veto_rights: list           # Who can veto
  modification_rights: list   # Who can modify terms
  withdrawal_protocol: string # How consent can be withdrawn

# Consent chain (multiple consents may be required)
chain:
  parent_consent_id: string   # Parent consent in chain
  child_consent_ids: list     # Dependent consents
  chain_complete: boolean     # Is the full chain verified
  chain_verification_date: datetime

# Consent status
status:
  current: enum
    values:
      - pending               # Consent requested, not yet granted
      - active                # Consent is active and valid
      - expired               # Consent has expired (needs renewal)
      - suspended             # Consent temporarily suspended
      - revoked               # Consent has been revoked
      - violated              # Consent terms were violated
  granted_date: datetime
  last_reviewed: datetime
  expiry_date: datetime
  revocation_date: datetime
  revocation_reason: string

```

3.5 Operations

3.6 Consent Chain Verification

``` Community Council Consent │ ├── Elder Consent (knowledge domain specific) │ │ │ ├── Knowledge Keeper Consent (item specific) │ │ │ │ │ └── Verified: Can proceed with operation │ │ │ └── Missing: Cannot proceed (chain incomplete) │ └── Missing: Cannot proceed (chain incomplete) ```

3.7 Example

```python consent = ConsentProtocol() record = consent.request( type="community", grantor={ "entity_id": "anishinaabe_council_001", "authority": "community_governance", "governance_body": "Traditional Council of Elders" }, scope={ "knowledge_domains": ["water_governance", "seasonal_protocols"], "operations": ["read", "discuss", "learn"], "purposes": ["educational_research"], "audiences": ["research_collective_001"], "territories": ["great_lakes"], "timeframe": { "start": "2024-01-01", "end": "2024-12-31", "review_interval": "quarterly" } }, conditions={ "reciprocity_required": True, "reciprocity_terms": "Return all findings before publication", "attribution_required": True, "community_review": True, "veto_rights": ["anishinaabe_council_001", "elder_003"] } ) ```

Protocol Type 4: Territory Protocol

4.1 Purpose

The Territory Protocol defines how knowledge territories are mapped, respected, and governed. In Indigenous ontology, knowledge belongs to places — it is not abstract or universal but rooted in specific lands, waters, and communities. The Territory Protocol ensures that digital knowledge systems respect these territorial relationships.

4.2 Wilson Paradigm Alignment

• Ontology: Territory defines where knowledge exists — it is placed
• Epistemology: Knowing is territorial — place-based knowledge requires place-based relationship
• Axiology: Territory is sacred — land and water are relatives, not resources
• Methodology: Territory shapes method — research must honor territorial protocols

4.3 Medicine Wheel Alignment

• Primary Direction: North (Wisdom/Integration)
• Patterns: Wisdom Pattern, Integration Pattern
• Seasonal Alignment: Winter — the time of deep knowing

4.4 Schema Definition

```yaml territory_protocol: type: relational_protocol version: "2.0" direction: north

territory: id: string # Unique territory identifier name: string # Territory name type: enum values: - traditional_territory # Traditional Indigenous territory - knowledge_domain # Domain of knowledge (e.g., medicine) - language_territory # Language and dialect regions - ceremonial_ground # Sacred ceremonial spaces - digital_territory # Digital knowledge spaces - shared_territory # Overlapping/shared territories - restricted_territory # Access-restricted areas - healing_territory # Spaces designated for healing

# Territory governance
governance:
  sovereign_nation: string    # Governing nation/community
  governance_body: string     # Governing body
  protocols: list             # Territorial protocols
  access_policy: enum
    values:
      - open                  # Open to all with ceremony
      - restricted            # Restricted to specific relations
      - sacred                # Sacred — highly restricted
      - seasonal              # Access depends on season
      - invitation_only       # By invitation only
      - closed                # Closed to outside access

# Territory boundaries
boundaries:
  geographic: object          # Physical geographic boundaries
  knowledge_domains: list     # Knowledge areas within territory
  language_boundaries: list   # Languages spoken in territory
  temporal_boundaries: object # Time-based access restrictions
  relational_boundaries: list # Relationship requirements for access

# Territory relations
relations:
  neighboring_territories: list
  shared_territories: list
  allied_territories: list
  protected_within: list      # Sub-territories with special status

# Territory health
health:
  sovereignty_status: string
  threat_level: enum
    values:
      - safe                  # No current threats
      - monitored             # Being monitored for threats
      - threatened            # Active threats detected
      - under_siege           # Sovereignty actively threatened
      - compromised           # Sovereignty has been violated
  last_assessment: datetime
  assessor: string

```

4.5 Operations

4.6 Example

```python territory = TerritoryProtocol() land = territory.map( name="Anishinaabe Knowledge Territory — Water Governance", type="knowledge_domain", governance={ "sovereign_nation": "Anishinaabe Nation", "governance_body": "Traditional Council of Elders", "access_policy": "restricted" }, boundaries={ "knowledge_domains": ["water_governance", "water_ceremony", "water_medicine"], "language_boundaries": ["anishinaabemowin"], "relational_boundaries": ["must_have_kinship", "must_have_consent"] } ) ```

Protocol Type 5: Story Protocol

5.1 Purpose

The Story Protocol defines how narrative knowledge is preserved, shared, and honored in its full relational context. In Indigenous epistemology, stories are not just data or content — they are living beings with their own relationships, territories, and protocols. A story belongs to a teller, a place, a time, and a purpose. Removing any of these elements is an act of extraction.

5.2 Wilson Paradigm Alignment

• Ontology: Stories are beings — they exist in relationship
• Epistemology: Stories are ways of knowing — narrative IS knowledge
• Axiology: Stories carry values — they teach what matters
• Methodology: Storytelling is method — it is how knowledge is transmitted

5.3 Medicine Wheel Alignment

• Primary Direction: East (Illumination)
• Patterns: Illumination Pattern, Emergence Pattern
• Seasonal Alignment: Spring — stories emerge with new life

5.4 Schema Definition

```yaml story_protocol: type: relational_protocol version: "2.0" direction: east

story: id: string title: string type: enum values: - origin_story # How things came to be - teaching_story # Stories that teach - healing_story # Stories that heal - warning_story # Stories that warn - celebration_story # Stories of joy and achievement - prophecy_story # Stories of what is coming - personal_story # Individual experience narratives - community_story # Collective community narratives - land_story # Stories of places - seasonal_story # Stories tied to seasons

# Story context (THIS IS THE KNOWLEDGE)
context:
  teller: string              # Who told this story
  teller_authority: string    # By what authority they tell it
  received_from: string       # Who they received it from
  lineage: list               # Full telling lineage
  place: string               # Where the story was told
  time: datetime              # When the story was told
  season: string              # Seasonal context
  ceremony: string            # Ceremony context (if any)
  audience: list              # Who the story was told to
  purpose: string             # Why the story was told
  language: string            # Language of telling
  territory: string           # Territory the story belongs to

# Story permissions
permissions:
  retelling_allowed: boolean
  retelling_conditions: list
  recording_allowed: boolean
  recording_conditions: list
  translation_allowed: boolean
  translation_conditions: list
  publication_allowed: boolean
  publication_conditions: list
  digital_storage_allowed: boolean
  ai_training_allowed: boolean  # Almost always false

# Story content
content:
  narrative: string           # The story itself
  teachings: list             # Explicit teachings
  implicit_knowledge: list    # Knowledge carried implicitly
  related_stories: list       # Connected stories
  related_ceremonies: list    # Connected ceremonies
  related_territories: list   # Connected territories

```

5.5 Operations

5.6 Example

```python story = StoryProtocol() narrative = story.receive( title="The Water Keeper's Teaching", type="teaching_story", context={ "teller": "elder_003", "teller_authority": "hereditary_knowledge_keeper", "received_from": "elder_003_grandmother", "place": "Lake Superior shoreline", "season": "spring", "purpose": "Teaching water governance to next generation", "language": "anishinaabemowin", "territory": "great_lakes_territory" }, permissions={ "retelling_allowed": True, "retelling_conditions": ["must_acknowledge_teller", "must_include_context"], "ai_training_allowed": False } ) ```

Protocol Type 6: Reciprocity Protocol

6.1 Purpose

The Reciprocity Protocol tracks and balances the flow of knowledge exchange between relational entities. In Indigenous economies, reciprocity is not transactional — it is relational. The goal is not equal exchange of identical goods but a balanced flow of different gifts that strengthens the relationship over time.

6.2 Wilson Paradigm Alignment

• Ontology: Reciprocity is a fundamental property of relational existence
• Epistemology: Knowledge flows through reciprocal exchange
• Axiology: Balance and generosity are core values
• Methodology: Reciprocity is methodological — research must give back

6.3 Medicine Wheel Alignment

• Primary Direction: South (Growth)
• Patterns: Growth Pattern
• Seasonal Alignment: Summer — the season of abundance and sharing

6.4 Schema Definition

```yaml reciprocity_protocol: type: relational_protocol version: "2.0" direction: south

reciprocity_ledger: id: string relationship_id: string # Which relationship this tracks

# Exchange records
exchanges:
  - id: string
    date: datetime
    direction: enum
      values:
        - given               # Knowledge/gift given
        - received            # Knowledge/gift received
        - mutual              # Simultaneous exchange
    type: enum
      values:
        - knowledge           # Knowledge shared
        - ceremony            # Ceremonial participation
        - labor               # Work or service
        - material            # Material goods
        - financial           # Financial support
        - advocacy            # Political or social advocacy
        - acknowledgment      # Public acknowledgment
        - protection          # Protection of rights or knowledge
        - healing             # Healing services
        - mentorship          # Teaching and mentorship
    description: string
    value_assessment: string  # Qualitative, not quantitative
    ceremony_id: string       # Ceremony in which exchange occurred
    witnesses: list           # Who witnessed the exchange

# Balance assessment
balance:
  status: enum
    values:
      - balanced              # Reciprocity is in good balance
      - slight_imbalance      # Minor imbalance, normal fluctuation
      - imbalanced            # Significant imbalance, needs attention
      - critical              # Critical imbalance, relationship at risk
      - exploitative          # Pattern of extraction detected
  last_assessment: datetime
  assessor: string
  assessment_method: string   # How balance was assessed
  notes: string

# Reciprocity plan
plan:
  agreed_terms: string        # What reciprocity looks like
  timeline: string            # When reciprocity is expected
  review_schedule: string     # How often balance is reviewed
  rebalancing_actions: list   # Actions to restore balance

```

6.5 Operations

6.6 Example

```python reciprocity = ReciprocityProtocol() reciprocity.record_exchange( relationship_id="university_community_001", direction="received", type="knowledge", description="Traditional water governance protocols shared by Elder", ceremony_id="ceremony_2024_001", witnesses=["community_rep_001", "researcher_002"] )

balance = reciprocity.assess_balance("university_community_001") print(f"Status: {balance.status}")

Output: Status: imbalanced

The university has received knowledge but has not yet returned findings

```

Protocol Type 7: Accountability Protocol

7.1 Purpose

The Accountability Protocol maintains relational accountability through audit trails, lineage tracking, community oversight, and violation response. In Indigenous methodology, accountability is not bureaucratic compliance — it is relational responsibility. You are accountable to all your relations: human, non-human, past, present, and future.

7.2 Wilson Paradigm Alignment

• Ontology: Accountability is a relational property of existence
• Epistemology: Knowledge carries responsibility — knowing creates obligations
• Axiology: Relational accountability is the highest value
• Methodology: Accountability is built into every methodological step

7.3 Medicine Wheel Alignment

• Primary Direction: West (Reflection/Transformation)
• Patterns: Reflection Pattern, Transformation Pattern, Release Pattern
• Seasonal Alignment: Autumn — the time of harvest and accounting

7.4 Schema Definition

```yaml accountability_protocol: type: relational_protocol version: "2.0" direction: west

accountability_record: id: string entity_id: string # Who is being held accountable type: enum values: - relational # Accountability to relations - ceremonial # Accountability for ceremony - consent # Accountability for consent terms - reciprocity # Accountability for reciprocity - territorial # Accountability to territory - generational # Accountability to future generations - ancestral # Accountability to ancestors - ecological # Accountability to land and water

# What they are accountable for
obligations:
  - id: string
    description: string
    source: string            # Where this obligation comes from
    ceremony_id: string       # Ceremony in which it was accepted
    deadline: datetime
    status: enum
      values:
        - pending             # Not yet due
        - in_progress         # Being fulfilled
        - fulfilled           # Completed
        - overdue             # Past deadline
        - violated            # Terms violated
        - waived              # Waived by governance

# Audit trail
audit_trail:
  - timestamp: datetime
    action: string
    actor: string
    details: string
    witnesses: list
    ceremony_id: string

# Violation records
violations:
  - id: string
    date: datetime
    description: string
    severity: enum
      values:
        - minor               # Procedural violation
        - moderate            # Substantive violation
        - major               # Serious breach of protocol
        - critical            # Fundamental violation of sovereignty
    response: string
    resolution: string
    status: enum
      values:
        - detected            # Violation identified
        - investigating       # Under investigation
        - confirmed           # Violation confirmed
        - responding          # Response in progress
        - resolved            # Violation resolved
        - unresolved          # Violation remains unresolved
        - escalated           # Escalated to higher authority

# Community oversight
oversight:
  governance_body: string
  review_schedule: string
  last_review: datetime
  next_review: datetime
  reviewer: string

```

7.5 Operations

7.6 Extraction Detection Integration

The Accountability Protocol is the primary integration point for LLMS extraction detection:

``` Knowledge Operation │ ▼ [Accountability Check] │ ├── Consent valid? ──── No → BLOCK + log violation │ ├── Reciprocity balanced? ── No → WARNING + rebalance request │ ├── Territory respected? ── No → BLOCK + sovereignty alert │ ├── Context preserved? ── No → BLOCK + decontextualization alert │ ├── Volume anomaly? ──── Yes → PAUSE + review request │ └── All clear → PROCEED + log in audit trail ```

7.7 Example

```python accountability = AccountabilityProtocol() accountability.record_obligation( entity_id="researcher_002", type="reciprocity", description="Return all findings to community before publication", source="consent_record_2024_001", ceremony_id="ceremony_2024_001", deadline="2024-09-30" )

Later: check compliance

status = accountability.check_compliance("researcher_002") for obligation in status.obligations: print(f"{obligation.description}: {obligation.status}") ```

Protocol Type 8: Sovereignty Protocol

8.1 Purpose

The Sovereignty Protocol is the foundational protocol that asserts and enforces community control over cultural data, language, knowledge, and their digital representations. It implements the OCAP principles (Ownership, Control, Access, Possession) and the CARE principles (Collective benefit, Authority to control, Responsibility, Ethics) at the technical architecture level.

8.2 Wilson Paradigm Alignment

• Ontology: Sovereignty is an inherent property of Indigenous nationhood
• Epistemology: Communities are the ultimate authority on their knowledge
• Axiology: Self-determination is a core value
• Methodology: Sovereignty must be built into every methodological choice

8.3 Medicine Wheel Alignment

• Primary Direction: North (Wisdom/Integration/Elder Knowledge)
• Patterns: Wisdom Pattern, Integration Pattern, Completion Pattern
• Seasonal Alignment: Winter — the time of deep governance

8.4 Schema Definition

```yaml sovereignty_protocol: type: relational_protocol version: "2.0" direction: north

sovereignty_assertion: id: string nation: string # Sovereign nation or community type: enum values: - data_sovereignty # Control over community data - knowledge_sovereignty # Control over cultural knowledge - language_sovereignty # Control over language data - territorial_sovereignty # Control over knowledge territory - ceremonial_sovereignty # Control over ceremonial knowledge - digital_sovereignty # Control over digital representations - ai_sovereignty # Control over AI use of community data - genomic_sovereignty # Control over genetic data

# OCAP implementation
ocap:
  ownership:
    owner: string             # Who owns this knowledge
    ownership_type: string    # Type of ownership (collective, etc.)
    documentation: string     # How ownership is documented
  control:
    controller: string        # Who controls access
    control_mechanisms: list  # Technical control mechanisms
    override_authority: string # Who can override controls
  access:
    access_policy: string     # Who can access and how
    access_levels: list       # Different access levels
    access_log: boolean       # Whether access is logged
  possession:
    possessor: string         # Who possesses the data/knowledge
    storage_location: string  # Where it is stored
    backup_location: string   # Where backups are stored
    repatriation_plan: string # Plan for returning data if needed

# CARE implementation
care:
  collective_benefit:
    beneficiaries: list       # Who benefits
    benefit_assessment: string # How benefit is assessed
  authority:
    governing_body: string    # Who governs
    decision_process: string  # How decisions are made
  responsibility:
    responsible_parties: list # Who is responsible
    accountability_measures: list # How accountability is maintained
  ethics:
    ethical_framework: string # Ethical guidelines
    review_process: string    # Ethics review process

# Enforcement
enforcement:
  technical_controls: list    # Technical enforcement mechanisms
  legal_frameworks: list      # Legal protections
  community_protocols: list   # Community enforcement protocols
  violation_response: string  # How violations are handled
  escalation_path: list       # Escalation hierarchy

# Status
status:
  current: enum
    values:
      - asserted              # Sovereignty formally asserted
      - recognized            # Sovereignty recognized by others
      - contested             # Sovereignty being contested
      - violated              # Sovereignty has been violated
      - restored              # Sovereignty restored after violation
      - strengthened           # Sovereignty strengthened
  last_assessment: datetime
  threats: list               # Current threats to sovereignty

```

8.5 Operations

8.6 LLMS Sovereignty Integration

``` AI/ML System Request │ ▼ [Sovereignty Check] │ ├── Is data sovereign? → Verify sovereign nation approval │ ├── Is use within OCAP? → Check all four principles │ ├── Is use within CARE? → Check all four principles │ ├── Is AI training involved? → BLOCK unless explicit approval │ ├── Is commercial use? → BLOCK unless revenue-sharing agreed │ └── All checks pass → PROCEED with full audit logging ```

8.7 Example

```python sovereignty = SovereigntyProtocol() assertion = sovereignty.assert_sovereignty( nation="Anishinaabe Nation", type="knowledge_sovereignty", ocap={ "ownership": { "owner": "Anishinaabe Nation", "ownership_type": "collective_community" }, "control": { "controller": "Traditional Council of Elders", "control_mechanisms": ["consent_protocol", "ceremony_protocol"] }, "access": { "access_policy": "restricted_with_ceremony", "access_log": True }, "possession": { "possessor": "Anishinaabe Nation", "storage_location": "community_server_001", "repatriation_plan": "immediate_upon_request" } }, enforcement={ "technical_controls": ["encryption", "access_control", "audit_logging"], "legal_frameworks": ["UNDRIP", "national_legislation"], "violation_response": "immediate_access_revocation" } ) ```

Cross-Protocol Relationships

How Protocols Interact

The eight protocols are not independent — they form a relational web:

``` SOVEREIGNTY / |
/ |
TERRITORY CONSENT ACCOUNTABILITY | \ / | \ / | | / | / | | /\ | /\ | | / \ | / \ | STORY KINSHIP RECIPROCITY \ | / \ | / CEREMONY ```

• Ceremony requires Consent and activates Kinship
• Kinship enables Reciprocity and grounds Story
• Story belongs to Territory and carries Accountability
• Territory is governed by Sovereignty and accessed through Consent
• Reciprocity is tracked by Accountability and balanced through Ceremony
• Accountability enforces Consent and defends Sovereignty
• Sovereignty underlies all other protocols

Validation Rules

1. No operation can proceed without an active Ceremony
2. No knowledge access without verified Consent chain
3. No relationship without established Kinship
4. No knowledge sharing without Reciprocity terms
5. No data processing without Sovereignty check
6. No narrative without Story context
7. No access without Territory acknowledgment
8. All operations logged in Accountability trail

Schema Version History

References

• Wilson, S. (2008). Research Is Ceremony. Fernwood Publishing.
• FNIGC. (2014). OCAP™ Principles.
• Carroll, S. R., et al. (2020). "CARE Principles." Data Science Journal.
• Kukutai, T., & Taylor, J. (2016). Indigenous Data Sovereignty. ANU Press.