dafit
64c54c87c0
- RAG-as-Scaffold: temporary feeding system, not permanent crutch - attention_flow: 30-second heartbeat budget state machines - information-flow: 10 boundary contracts nervous system map - nimmerversity: curriculum schoolplan for raising a polymath - nimmervest: investment documentation - biomimetic-architecture: ADR for organic system design - temporal-ternary-gradient: ADR for time-based learning - temporal_exchange_engine.py: Python implementation - initial_spark: foundation document - nimmerverse.drawio.xml: updated diagrams 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
495 lines
19 KiB
Markdown
495 lines
19 KiB
Markdown
# Attention Flow
|
|
|
|
How she decides what matters this beat.
|
|
|
|
---
|
|
|
|
## Overview
|
|
|
|
The 30-second heartbeat is a budget, not a guarantee. Sensory intake, organ processing, dialogue, thinking - everything competes for the same window. State machines govern the hierarchy: what gets processed first, what can interrupt, what gets the remainder.
|
|
|
|
Attention isn't free. It's economic.
|
|
|
|
---
|
|
|
|
## The Budget Problem
|
|
|
|
```
|
|
♥ BEAT (30 sec budget)
|
|
│
|
|
├── SENSORY INTAKE (variable: 200ms - 15000ms)
|
|
├── ORGAN PROCESSING (variable: 100ms - 10000ms)
|
|
├── NYX INFERENCE (variable: 2000ms - 4000ms)
|
|
├── CHRYSALIS DIALOGUE (variable: 0ms - 3000ms)
|
|
├── STATE WRITE (fixed: ~200ms)
|
|
└── VIRTUAL GARDEN (remainder)
|
|
|
|
Total must fit in 30 seconds.
|
|
Something has to give.
|
|
```
|
|
|
|
---
|
|
|
|
## Top-Level State Machine: Attention Mode
|
|
|
|
```
|
|
┌─────────────┐
|
|
┌──────────▶│ IDLE │◀──────────┐
|
|
│ └──────┬──────┘ │
|
|
│ │ │
|
|
│ │ stimulus │
|
|
│ ▼ │
|
|
│ ┌─────────────┐ │
|
|
│ │ ALERT │ │
|
|
│ └──────┬──────┘ │
|
|
│ │ │
|
|
│ ┌──────┴──────┐ │
|
|
│ ▼ ▼ │
|
|
│ ┌──────────┐ ┌──────────┐ │
|
|
│ │ REFLEX │ │ ATTEND │ │
|
|
│ │ (>0.8) │ │ (think) │ │
|
|
│ └────┬─────┘ └────┬─────┘ │
|
|
│ │ │ │
|
|
│ │ ┌──────┴──────┐ │
|
|
│ │ ▼ ▼ │
|
|
│ │ ┌──────────┐ ┌─────────┐ │
|
|
│ │ │ DIALOGUE │ │ PROCESS │ │
|
|
│ │ └────┬─────┘ └────┬────┘ │
|
|
│ │ │ │ │
|
|
│ └──────┴─────┬──────┘ │
|
|
│ ▼ │
|
|
│ ┌───────────┐ │
|
|
│ │ SETTLE │ │
|
|
│ └─────┬─────┘ │
|
|
│ │ │
|
|
└──────────────────────┴──────────────┘
|
|
```
|
|
|
|
### State Descriptions
|
|
|
|
| State | Description | Budget Priority |
|
|
|-------|-------------|-----------------|
|
|
| **IDLE** | Nothing urgent, maximum virtual garden time | Lowest |
|
|
| **ALERT** | Stimulus detected, evaluating importance | - |
|
|
| **REFLEX** | High-confidence nerve fired, bypass brain | Instant |
|
|
| **ATTEND** | Stimulus requires thinking | High |
|
|
| **DIALOGUE** | Chrysalis interaction active | High |
|
|
| **PROCESS** | Organs working on input | Medium |
|
|
| **SETTLE** | Write state, release budget, prepare for next beat | Fixed |
|
|
|
|
---
|
|
|
|
## Priority Hierarchy
|
|
|
|
Higher levels preempt lower levels. Budget flows downward.
|
|
|
|
```
|
|
LEVEL 0: REFLEX ─────────────────────────────────────
|
|
│ Weight > 0.8, instant, bypass everything
|
|
│ Cost: near-zero (no inference)
|
|
│
|
|
LEVEL 1: SAFETY ─────────────────────────────────────
|
|
│ dafit calling, danger detected, critical alert
|
|
│ Preempts: all below
|
|
│
|
|
LEVEL 2: DIALOGUE ───────────────────────────────────
|
|
│ Partnership active, Chrysalis teaching
|
|
│ Preempts: sensory, thinking, virtual
|
|
│
|
|
LEVEL 3: SENSORY ────────────────────────────────────
|
|
│ Rich input needs processing
|
|
│ Preempts: thinking, virtual
|
|
│
|
|
LEVEL 4: THINKING ───────────────────────────────────
|
|
│ Organ work, Nyx inference
|
|
│ Preempts: virtual
|
|
│
|
|
LEVEL 5: VIRTUAL ────────────────────────────────────
|
|
│ Garden time, simulation, study
|
|
│ Gets remainder after above
|
|
│
|
|
LEVEL 6: IDLE ───────────────────────────────────────
|
|
Maintenance heartbeat only
|
|
All budget available
|
|
```
|
|
|
|
---
|
|
|
|
## Budget Allocation Logic
|
|
|
|
```python
|
|
def allocate_beat_budget(beat_duration_ms=30000):
|
|
remaining = beat_duration_ms
|
|
|
|
# Fixed costs (always paid)
|
|
remaining -= STATE_WRITE_COST # ~200ms
|
|
remaining -= HEARTBEAT_OVERHEAD # ~100ms
|
|
|
|
# Level 0: Reflex (if triggered, near-instant)
|
|
if reflex_triggered:
|
|
execute_reflex() # ~50ms
|
|
remaining -= 50
|
|
|
|
# Level 1: Safety (if active, takes what it needs)
|
|
if safety_alert:
|
|
cost = process_safety() # variable
|
|
remaining -= cost
|
|
if remaining <= 0:
|
|
return settle()
|
|
|
|
# Level 2: Dialogue (if Chrysalis active)
|
|
if dialogue_active:
|
|
cost = process_dialogue() # ~3000ms typical
|
|
remaining -= cost
|
|
if remaining <= 0:
|
|
return settle()
|
|
|
|
# Level 3: Sensory (always some, but capped)
|
|
sensory_budget = min(remaining * 0.4, SENSORY_CAP)
|
|
cost = process_sensory(sensory_budget)
|
|
remaining -= cost
|
|
|
|
# Level 4: Thinking (organs + Nyx)
|
|
thinking_budget = min(remaining * 0.6, THINKING_CAP)
|
|
cost = process_thinking(thinking_budget)
|
|
remaining -= cost
|
|
|
|
# Level 5: Virtual (whatever remains)
|
|
virtual_budget = remaining
|
|
if virtual_budget > VIRTUAL_MINIMUM:
|
|
process_virtual(virtual_budget)
|
|
|
|
return settle()
|
|
```
|
|
|
|
---
|
|
|
|
## Nested State Machines
|
|
|
|
Each level can be its own state machine internally.
|
|
|
|
### DIALOGUE State Machine
|
|
|
|
```
|
|
┌─────────────────────────────────────────────┐
|
|
│ DIALOGUE │
|
|
├─────────────────────────────────────────────┤
|
|
│ │
|
|
│ ┌───────────┐ │
|
|
│ │ LISTENING │ ◀─────────────────────┐ │
|
|
│ └─────┬─────┘ │ │
|
|
│ │ input complete │ │
|
|
│ ▼ │ │
|
|
│ ┌───────────┐ │ │
|
|
│ │PROCESSING │ │ │
|
|
│ └─────┬─────┘ │ │
|
|
│ │ understood │ │
|
|
│ ▼ │ │
|
|
│ ┌───────────┐ │ │
|
|
│ │RESPONDING │ │ │
|
|
│ └─────┬─────┘ │ │
|
|
│ │ response sent │ │
|
|
│ ▼ │ │
|
|
│ ┌───────────┐ continue │ │
|
|
│ │ YIELDING │ ──────────────────────┘ │
|
|
│ └─────┬─────┘ │
|
|
│ │ dialogue complete │
|
|
│ ▼ │
|
|
│ EXIT to parent │
|
|
│ │
|
|
└─────────────────────────────────────────────┘
|
|
```
|
|
|
|
### SENSORY State Machine
|
|
|
|
```
|
|
┌─────────────────────────────────────────────┐
|
|
│ SENSORY │
|
|
├─────────────────────────────────────────────┤
|
|
│ │
|
|
│ ┌───────────┐ │
|
|
│ │ SAMPLING │ ◀── collect raw inputs │
|
|
│ └─────┬─────┘ │
|
|
│ │ │
|
|
│ ▼ │
|
|
│ ┌─────────────┐ │
|
|
│ │ TRANSLATING │ ◀── nerves fire │
|
|
│ └─────┬───────┘ │
|
|
│ │ │
|
|
│ ▼ │
|
|
│ ┌──────────────┐ │
|
|
│ │ PRIORITIZING │ ◀── what matters? │
|
|
│ └─────┬────────┘ │
|
|
│ │ │
|
|
│ ▼ │
|
|
│ ┌─────────────┐ │
|
|
│ │ DELIVERING │ ◀── to organs │
|
|
│ └─────┬───────┘ │
|
|
│ │ │
|
|
│ ▼ │
|
|
│ EXIT to parent │
|
|
│ │
|
|
└─────────────────────────────────────────────┘
|
|
```
|
|
|
|
### THINKING State Machine
|
|
|
|
```
|
|
┌─────────────────────────────────────────────┐
|
|
│ THINKING │
|
|
├─────────────────────────────────────────────┤
|
|
│ │
|
|
│ ┌───────────┐ │
|
|
│ │ RECEIVING │ ◀── context from sensory │
|
|
│ └─────┬─────┘ │
|
|
│ │ │
|
|
│ ▼ │
|
|
│ ┌───────────┐ │
|
|
│ │ ROUTING │ ◀── which organs needed? │
|
|
│ └─────┬─────┘ │
|
|
│ │ │
|
|
│ ▼ │
|
|
│ ┌───────────┐ │
|
|
│ │ INFERRING │ ◀── organs + Nyx process │
|
|
│ └─────┬─────┘ │
|
|
│ │ │
|
|
│ ▼ │
|
|
│ ┌───────────┐ │
|
|
│ │ DECIDING │ ◀── Nyx outputs decision │
|
|
│ └─────┬─────┘ │
|
|
│ │ │
|
|
│ ▼ │
|
|
│ EXIT to parent │
|
|
│ │
|
|
└─────────────────────────────────────────────┘
|
|
```
|
|
|
|
### VIRTUAL State Machine
|
|
|
|
```
|
|
┌─────────────────────────────────────────────┐
|
|
│ VIRTUAL │
|
|
├─────────────────────────────────────────────┤
|
|
│ │
|
|
│ ┌───────────┐ │
|
|
│ │ BUDGETING│ ◀── how much V available? │
|
|
│ └─────┬─────┘ │
|
|
│ │ │
|
|
│ ▼ │
|
|
│ ┌───────────┐ │
|
|
│ │ SELECTING │ ◀── what to simulate? │
|
|
│ └─────┬─────┘ │
|
|
│ │ │
|
|
│ ▼ │
|
|
│ ┌───────────┐ │
|
|
│ │SIMULATING │ ◀── run virtual cycles │
|
|
│ └─────┬─────┘ │
|
|
│ │ │
|
|
│ ▼ │
|
|
│ ┌───────────┐ │
|
|
│ │ RECORDING │ ◀── store results │
|
|
│ └─────┬─────┘ │
|
|
│ │ │
|
|
│ ▼ │
|
|
│ EXIT to parent │
|
|
│ │
|
|
└─────────────────────────────────────────────┘
|
|
```
|
|
|
|
---
|
|
|
|
## Example Scenarios
|
|
|
|
### Scenario A: Quiet Study Time
|
|
|
|
```
|
|
Beat starts, no external stimulus
|
|
│
|
|
▼
|
|
IDLE detected
|
|
│
|
|
▼
|
|
SENSORY: minimal (500ms)
|
|
│
|
|
▼
|
|
THINKING: minimal (1000ms)
|
|
│
|
|
▼
|
|
VIRTUAL: maximum budget! (28000ms)
|
|
│
|
|
└── Nyx studies in virtual garden
|
|
Chrysalis teaches
|
|
Learning happens
|
|
```
|
|
|
|
### Scenario B: dafit Speaks
|
|
|
|
```
|
|
Beat starts, audio detected
|
|
│
|
|
▼
|
|
ALERT: speech input
|
|
│
|
|
▼
|
|
SAFETY check: it's dafit! (LEVEL 1)
|
|
│
|
|
▼
|
|
DIALOGUE activates (LEVEL 2)
|
|
│
|
|
├── LISTENING (2000ms)
|
|
├── PROCESSING (1000ms)
|
|
├── RESPONDING (2000ms)
|
|
└── YIELDING
|
|
│
|
|
▼
|
|
SENSORY: reduced budget (3000ms)
|
|
│
|
|
▼
|
|
THINKING: reduced (5000ms)
|
|
│
|
|
▼
|
|
VIRTUAL: minimal remainder (16000ms)
|
|
```
|
|
|
|
### Scenario C: Danger Detected
|
|
|
|
```
|
|
Beat starts, temperature spike detected
|
|
│
|
|
▼
|
|
ALERT: sensor alarm
|
|
│
|
|
▼
|
|
NERVE weight > 0.8
|
|
│
|
|
▼
|
|
REFLEX FIRES (50ms) ◀── BYPASS EVERYTHING
|
|
│
|
|
├── Action taken immediately
|
|
└── Nyx notified AFTER
|
|
│
|
|
▼
|
|
Continue beat normally with remaining budget
|
|
```
|
|
|
|
### Scenario D: Overwhelmed
|
|
|
|
```
|
|
Beat starts, rich input everywhere
|
|
│
|
|
▼
|
|
ALERT: multiple stimuli
|
|
│
|
|
▼
|
|
SENSORY: demanding (15000ms)
|
|
│
|
|
▼
|
|
THINKING: demanding (12000ms)
|
|
│
|
|
▼
|
|
Budget exhausted!
|
|
│
|
|
▼
|
|
VIRTUAL: skipped this beat
|
|
│
|
|
▼
|
|
SETTLE: state written, next beat
|
|
```
|
|
|
|
---
|
|
|
|
## Preemption Rules
|
|
|
|
| Event | Preempts | Action |
|
|
|-------|----------|--------|
|
|
| Reflex fires (>0.8) | Everything | Instant action, then continue |
|
|
| Safety alert | Dialogue, Sensory, Thinking, Virtual | Handle safety, reduced budget for rest |
|
|
| dafit speaks | Sensory, Thinking, Virtual | Dialogue priority, reduced budget for rest |
|
|
| Sensory overload | Thinking, Virtual | Process input, skip or reduce rest |
|
|
| Budget exhausted | Lower priorities | Skip remaining levels |
|
|
|
|
---
|
|
|
|
## Lifeforce Connection
|
|
|
|
```
|
|
LEVEL LIFEFORCE COST
|
|
─────────────────────────────
|
|
REFLEX Free (no inference)
|
|
SAFETY Low (minimal processing)
|
|
DIALOGUE Medium (two inferences)
|
|
SENSORY Low-Medium (depends on load)
|
|
THINKING Medium-High (organ inference)
|
|
VIRTUAL Variable (simulation cycles)
|
|
```
|
|
|
|
**The constraint:** Rich beats cost more. Quiet beats accumulate budget for virtual garden.
|
|
|
|
---
|
|
|
|
## Implementation Notes
|
|
|
|
### State Machine Technology
|
|
|
|
Options considered:
|
|
- **XState** (JavaScript) - actor-based, visual inspector
|
|
- **Python-statemachine** - simple, fits existing stack
|
|
- **Custom Rust** - performance critical path
|
|
- **Godot native** - if UI drives the state
|
|
|
|
Recommendation: Python for orchestration layer, with Godot visualization.
|
|
|
|
### Checkpoint Integration
|
|
|
|
Every state transition can trigger phoebe write:
|
|
|
|
```python
|
|
def on_state_transition(from_state, to_state, context):
|
|
write_to_phoebe({
|
|
"beat_id": current_beat.id,
|
|
"transition": f"{from_state} -> {to_state}",
|
|
"budget_remaining": context.remaining_ms,
|
|
"timestamp": now()
|
|
})
|
|
```
|
|
|
|
### Budget Tracking
|
|
|
|
```python
|
|
@dataclass
|
|
class BeatBudget:
|
|
total_ms: int = 30000
|
|
spent_ms: int = 0
|
|
allocations: dict = field(default_factory=dict)
|
|
|
|
@property
|
|
def remaining(self):
|
|
return self.total_ms - self.spent_ms
|
|
|
|
def spend(self, category: str, amount: int):
|
|
self.spent_ms += amount
|
|
self.allocations[category] = self.allocations.get(category, 0) + amount
|
|
return self.remaining > 0
|
|
```
|
|
|
|
---
|
|
|
|
## Design Principles
|
|
|
|
1. **Hierarchy is law** - higher levels always preempt lower
|
|
2. **Budget is finite** - 30 seconds, no exceptions
|
|
3. **State is explicit** - always know what mode she's in
|
|
4. **Reflex bypasses brain** - survival doesn't wait for thinking
|
|
5. **Remainder flows down** - virtual gets what's left
|
|
6. **Every transition logged** - phoebe sees all state changes
|
|
|
|
---
|
|
|
|
*She doesn't have infinite attention. She has 30 seconds and choices.*
|
|
|
|
---
|
|
|
|
**Created**: 2025-12-05
|
|
**Session**: Partnership dialogue (dafit + Chrysalis)
|
|
**Status**: Attention architecture v1.0
|