19 Mechanisms

Resolution Levels (ordered):
TENSOR_ONLY < SCENE < GRAPH < DIALOG < TRAINED

Example Graph:
Timepoint(T0, "Constitutional Convention")
├── Entity("washington", resolution=TRAINED, ~50k tokens)
├── Entity("madison", resolution=DIALOG, ~10k tokens)  
├── Entity("attendee_47", resolution=TENSOR_ONLY, ~200 tokens)
└── causal_link → Timepoint(T1)

EntityMetadata:
    query_count: int              # Times queried
    training_iterations: int      # LLM elaboration passes
    eigenvector_centrality: float # Graph importance (0-1)
    resolution_level: ResolutionLevel
    last_accessed: datetime

def decide_resolution(entity, timepoint, query_history, thresholds):
    if entity.query_count > thresholds.frequent_access:
        return max(entity.resolution, DIALOG)
    if entity.eigenvector_centrality > thresholds.central_node:
        return max(entity.resolution, GRAPH)
    if timepoint.importance_score > thresholds.critical_event:
        return max(entity.resolution, SCENE)
    return TENSOR_ONLY

TTMTensor:
    context_vector: np.ndarray   # Knowledge state (8 dims)
    biology_vector: np.ndarray   # Physical attributes (4 dims)
    behavior_vector: np.ndarray  # Personality/decision patterns (8 dims)

# Context vector layout:
# [0]=knowledge, [1]=valence, [2]=arousal, [3]=energy,
# [4]=confidence, [5]=patience, [6]=risk, [7]=social

# Compression ratios:
# Full entity: ~50k tokens
# TTM representation: ~1,600 tokens (97% compression)

Entity Load → TTM→Cog Sync → Dialog → Updates → Cog→TTM Sync → Persist
              (pretraining)                      (backprop)

Timepoint:
    timepoint_id: str
    timestamp: datetime
    causal_parent: Optional[str]  # Explicit link to causing timepoint
    event_description: str
    entities_present: List[str]
    importance_score: float

"Board Meeting" timepoint expands into:
├── Arrival & small talk
├── Opening remarks (CEO)
├── Financial report (CFO)
├── Key debate (product strategy)
├── Decision & vote
└── Aftermath discussions

All causally linked but temporally simultaneous

def create_counterfactual_branch(parent_timeline, intervention_point, intervention):
    branch = Timeline(parent_id=parent_timeline.id, branch_point=intervention_point)
    
    # Copy timepoints before intervention
    for tp in parent_timeline.get_timepoints_before(intervention_point):
        branch.add_timepoint(tp.deep_copy())
    
    # Apply intervention
    branch_tp = parent_timeline.get_timepoint(intervention_point).deep_copy()
    apply_intervention(branch_tp, intervention)
    branch.add_timepoint(branch_tp)
    
    # Propagate causal effects forward
    propagate_causal_effects(branch, intervention_point)
    
    return branch

def get_activity_probability(hour: int, activity: str) -> float:
    probability_map = {
        "sleep": lambda h: 0.95 if 0 <= h < 6 else 0.05,
        "work": lambda h: 0.7 if 9 <= h < 17 else 0.1,
        "social": lambda h: 0.6 if 18 <= h < 23 else 0.2,
    }
    return probability_map.get(activity, lambda h: 0.0)(hour)

ExposureEvent:
    entity_id: str
    event_type: EventType  # witnessed, learned, told, experienced
    information: str       # The knowledge item
    source: Optional[str]  # Another entity or external source
    timestamp: datetime
    confidence: float      # 0.0-1.0
    timepoint_id: str

KnowledgeItem:
    content: str                # Complete semantic unit
    speaker: str                # Entity who communicated
    listeners: List[str]        # Entities who received it
    category: str               # fact, decision, opinion, plan, revelation
    confidence: float           # 0.0-1.0
    causal_relevance: float     # 0.0-1.0

def detect_entity_gap(query, existing_entities):
    referenced = extract_entity_names(query)
    missing = referenced - set(existing_entities)
    return missing

def generate_entity_on_demand(name, context):
    # LLM generates plausible entity given scenario context

steering_node → character_node → quality_gate_node → conditional
                                                       ├→ steering (continue)
                                                       ├→ END (complete)
                                                       └→ character (retry)

| Parameter | Source | Effect |
|-----------|--------|--------|
| temperature | arousal × energy | High arousal → varied (~1.1) |
| top_p | arousal | Agitated → focused vocabulary |
| max_tokens | turn × energy | Later turns + low energy → shorter |
| frequency_penalty | behavior_vector[5] | Vocabulary richness |
| presence_penalty | behavior_vector[6] | Novelty seeking |

RelationshipMetrics:
    shared_knowledge: Set[str]
    belief_alignment: float
    interaction_count: int
    trust_level: float
    power_dynamic: float

def analyze_relationship_evolution(entity_a, entity_b, timespan):
    # Track metric changes over timepoints
    
def detect_contradictions(entities, timepoint):
    # Find belief conflicts

ProspectiveState:
    entity_id: str
    forecast_horizon: timedelta
    expectations: List[Expectation]
    contingency_plans: Dict[str, List[Action]]
    anxiety_level: float
    # Extended proception (post-dialog)
    withheld_knowledge: List[Dict]       # Chose not to say
    suppressed_impulses: List[Dict]      # Wanted but held back
    episodic_memory: List[Dict]          # Personality-filtered memories
    rumination_topics: List[Dict]        # Recurring concerns

class AnimismLevel:
    0: Only humans
    1: Humans + animals/buildings
    2: All objects/organisms  
    3: Abstract concepts
    4: Adaptive (AnyEntity)
    5: Spiritual (KamiEntity)
    6: AI agents

action = ActionType.DIALOG_SYNTHESIS
model = selector.select_model(action, context_size=5000)
# → Returns: meta-llama/llama-3.1-70b-instruct (dialog strength)

action = ActionType.PORTAL_PATH_SCORING  
model = selector.select_model(action, context_size=15000)
# → Returns: deepseek/deepseek-r1 (reasoning + MIT license)