medicine-wheel

relational-index — RISE Specification

Four-source dimensional indexing — implements relational indexing across this suite’s four epistemic source dimensions (Land, Dream, Code, Vision; our naming, after Wilson’s recognition of more than one way of knowing, 2008, p. 111) for querying, retrieval, and cross-dimensional mapping of ImportanceUnits and knowledge artifacts.

Version: 0.1.0
Package: @medicine-wheel/relational-index
Document ID: rispec-relational-index-v1
Last Updated: 2026-03-15

Desired Outcome

Users create multi-dimensional knowledge indexes where:

Creative Intent

What this enables: Wilson (2008) recognizes knowing through the senses and beyond them (p. 111); this suite names four sources. Land teaches differently than dreams; code embodies differently than vision. A relational index that traverses across these dimensions enables the holistic knowing Wilson describes — where understanding comes from the relationship between dimensions, not from any single source.

Structural Tension: Between mono-dimensional indexing (flat keyword search, single taxonomy) and multi-dimensional relational indexing (knowledge exists in relational space across epistemological dimensions). The relational-index resolves this by creating per-dimension indexes with cross-dimensional mapping that reveals convergences and tensions.

Type Definitions

Core Types

type EpistemicSource = 'land' | 'dream' | 'code' | 'vision';

RelationalIndex

interface RelationalIndex {
  entries: Map<string, IndexEntry>;
  dimensions: Record<EpistemicSource, DimensionIndex>;
  crossMap: CrossDimensionalMap;
}

IndexEntry

interface IndexEntry {
  unitId: string;
  source: EpistemicSource;
  direction: DirectionName;
  epistemicWeight: number;
  circleDepth: number;
  accountableTo: string[];
  tags: string[];
  timestamp: string;
}

Supporting Types

interface DimensionIndex {
  source: EpistemicSource;
  entries: IndexEntry[];
  depth: number;                      // Average circle depth
  weight: number;                     // Average epistemic weight
}

interface CrossDimensionalMap {
  convergences: Convergence[];        // Where multiple dimensions agree
  tensions: Tension[];                // Where dimensions conflict
  gaps: DimensionGap[];               // Dimensions with no entries
}

interface Convergence {
  dimensions: EpistemicSource[];
  description: string;
  strength: number;                   // 0–1
  unitIds: string[];
}

interface Tension {
  dimensions: [EpistemicSource, EpistemicSource];
  description: string;
  severity: number;                   // 0–1
  unitIds: string[];
}

interface DimensionGap {
  dimension: EpistemicSource;
  direction?: DirectionName;
  description: string;
}

interface RelationalPath {
  from: IndexEntry;
  to: IndexEntry;
  via: IndexEntry[];
  crossDimensional: boolean;
}

interface SpiralDepthMetrics {
  totalCircles: number;
  averageDepth: number;
  deepeningRate: number;
  stagnationAlert: boolean;
  deepestUnit: string;
}

interface IndexHealth {
  totalEntries: number;
  dimensionBalance: Record<EpistemicSource, number>;
  coverageGaps: DimensionGap[];
  averageDepth: number;
  overallHealth: number;              // 0–1
}

Module: Index Management (index.ts)

createIndex()
// Creates an empty RelationalIndex

addEntry(index, entry)
// Adds an entry to the appropriate dimension index

removeEntry(index, unitId)
// Removes an entry from the index

Module: Query (query.ts)

queryBySource(index, source)
// Returns all entries from a specific epistemic source

queryByDirection(index, direction)
// Returns all entries aligned with a specific direction

queryCrossDimensional(index, sources)
// Returns entries that appear in multiple dimensions

findRelationalPaths(index, fromId, toId)
// Finds relational paths between two entries across dimensions

Module: Dimensions (dimensions.ts)

landIndex(index)
// Returns the land dimension index with computed metrics

dreamIndex(index)
// Returns the dream dimension index with computed metrics

codeIndex(index)
// Returns the code dimension index with computed metrics

visionIndex(index)
// Returns the vision dimension index with computed metrics

Module: Cross-Dimensional Analysis (cross-dimensional.ts)

mapAcrossDimensions(index)
// Builds the cross-dimensional map: convergences, tensions, gaps

findConvergences(index)
// Identifies where multiple dimensions agree

detectTensions(index)
// Identifies where dimensions conflict

Module: Spiral Depth (spiral-depth.ts)

measureSpiralDepth(index)
// Returns SpiralDepthMetrics for the entire index

compareCircles(earlier, later)
// Compares two circling states to measure deepening

detectDeepening(index, unitId)
// Detects genuine deepening for a specific unit

detectStagnation(index)
// Identifies units that are circling without deepening

Module: Metrics (metrics.ts)

indexHealth(index)
// Returns IndexHealth: balance, gaps, depth, overall health

dimensionBalance(index)
// Returns per-dimension entry counts and weights

coverageGaps(index)
// Identifies dimensions and directions with no entries

Dependencies

Wilson Alignment

Wilson recognizes knowing through the senses and beyond them (2008, p. 111). This suite names four sources (the names are ours):

Test Scenarios

  1. Index creation: Create index → addEntry for each dimension → verify dimension indexes populated
  2. Cross-dimensional query: Entries in land and dream dimensions → queryCrossDimensional → find related entries
  3. Convergence detection: Two entries from different dimensions with same direction and tags → findConvergences → detected
  4. Tension detection: Entries from different dimensions with conflicting weights → detectTensions → detected
  5. Coverage gaps: Index with no dream entries → coverageGaps → reports dream dimension gap
  6. Spiral depth: Entry with 5 circles → measureSpiralDepth → high average depth
  7. Index health: Balanced index with all 4 dimensions → indexHealth → high overall health
  8. Relational paths: Entries connected across dimensions → findRelationalPaths → path found

Advancing Patterns

Quality Criteria

This site is open source. Improve this page.