Dependency Graph

The dependency relationships between all components in the 88.pi ecosystem.

Core Dependencies

                    ┌─────────────────┐
                    │   88.pi root    │
                    └────────┬────────┘
                             │
                    ┌────────▼────────┐
                    │  pi-mono-main   │
                    └────────┬────────┘
                             │
                    ┌────────▼────────┐
                    │ pi-coding-agent │
                    └───┬─────┬───┬───┘
                        │     │   │
           ┌────────────▼┐  ┌▼───▼──────────┐
           │   nity/     │  │ nity-memory/  │
           │ (17 files)  │  │ (5 modules)   │
           └──┬───┬───┬──┘  └───┬───────┬───┘
              │   │   │         │       │
    ┌─────────▼┐ ┌▼───▼──┐  ┌──▼───┐ ┌─▼──────────┐
    │  brand/  │ │ tui/  │  │brain │ │ episodes   │
    └──┬───┬──┘ └───────┘  └──────┘ └────────────┘
       │   │
  ┌────▼┐ ┌▼──────────┐
  │voice│ │state-to-  │
  │     │ │ brand     │
  └─────┘ └───────────┘

Dependency Matrix

Component	Depends On	Depended By
`coordinator.ts`	task-analyzer, strategy-planner, execution-router, quality-gates, self-reflection, progress-tracker	bridge/session.ts
`task-analyzer.ts`	skill-registry	coordinator
`strategy-planner.ts`	ralph-universal, skill-registry	coordinator
`execution-router.ts`	loop-engine, standalone-runner	coordinator
`loop-engine.ts`	circuit-breaker, response-analyzer	execution-router
`circuit-breaker.ts`	(none)	loop-engine
`response-analyzer.ts`	(none)	loop-engine
`quality-gates.ts`	(none)	coordinator
`self-reflection.ts`	episode-recorder	coordinator
`episode-recorder.ts`	simplemem-bridge	self-reflection
`brain-manager.ts`	simplemem-bridge	coordinator
`ralph-universal.ts`	simplemem-bridge	strategy-planner
`voice.ts`	state-to-brand	tui components
`state-to-brand.ts`	(none)	voice.ts, tui components
`presence-indicator.ts`	voice, state-to-brand	(consumed by TUI)
`loop-status.ts`	loop-engine status	(consumed by TUI)
`memory-banner.ts`	brain-manager, episode-recorder	(consumed by TUI)
`progress-tracker.ts`	(none)	coordinator, bridge
`skill-registry.ts`	(none)	task-analyzer, strategy-planner
`quantumreef-bridge.ts`	execution-router	coordinator

Critical Path

coordinator
  → task-analyzer (needs skill-registry)
  → strategy-planner (needs ralph-universal, skill-registry)
  → execution-router
      → loop-engine
          → circuit-breaker
          → response-analyzer
      → standalone-runner (simple tasks, no loop)
  → quality-gates
  → self-reflection
      → episode-recorder (needs simplemem-bridge)
  → progress-tracker → bridge (streams to external client)

⚠️

The critical path has no circular dependencies. If you find one, it's a design error. coordinator.ts is the only component that connects to all others — it's the hub. Everything else is a spoke or leaf.

Isolation Boundaries

Boundary	Components	Can import from	Cannot import from
Nity Core	coordinator, task-analyzer, strategy-planner, execution-router	nity-memory, nity-loop	bridge (inward)
Nity Memory	brain-manager, episode-recorder, ralph-universal, simplemem-bridge, memory-recall	(none)	nity-core, nity-loop
Nity Loop	loop-engine, circuit-breaker, response-analyzer	(none)	nity-core, nity-memory
Nity Brand	voice, state-to-brand, tui components	nity-core (status only)	nity-memory, nity-loop
Bridge	session, types, stream	nity-core	nity-memory, nity-loop, nity-brand

Ecosystem Map Data Flows