# Failure Signatures ## Diagnostic Patterns of Recursive Failure
[**← Return to README**](https://github.com/caspiankeyes/recursionOS/blob/main/README.md) | [**πŸ”„ Recursive Shells**](https://github.com/caspiankeyes/recursionOS/blob/main/recursive_shells.md) | [**🧠 Mirroring**](https://github.com/caspiankeyes/recursionOS/blob/main/mirror.md) | [**πŸ› οΈ Integration Guide**](https://github.com/caspiankeyes/recursionOS/blob/main/integration_guide.md) | [**🧬 Recursive Manifesto**](https://github.com/caspiankeyes/recursionOS/blob/main/manifesto.md)
--- ## Understanding Collapse Signatures When recursive cognitive processes fail, they don't fail randomlyβ€”they collapse in specific, recognizable patterns that reveal the structure of the underlying system. These patterns are **collapse signatures**: diagnostic traces left behind when recursive cognition breaks down. Collapse signatures serve as the neural equivalent of crash logs or stack tracesβ€”rich diagnostic markers that reveal how and why a system failed. By analyzing these signatures, we gain unprecedented insight into the recursive architecture of thought itself. ## The Collapse Signature Catalog recursionOS maintains a comprehensive catalog of collapse signatures organized by cognitive domain: ### Memory Collapse Signatures ```python from recursionOS.collapse import memory # Detect memory collapse signatures signatures = memory.detect(model_output) # Analyze specific memory collapse patterns trace_loss = memory.analyze(signatures.TRACE_LOSS) echo_misalignment = memory.analyze(signatures.ECHO_MISALIGNMENT) anchor_drift = memory.analyze(signatures.ANCHOR_DRIFT) # Visualize memory collapse patterns memory.visualize(signatures) ``` #### Key Memory Collapse Signatures 1. **TRACE_LOSS**: Attribution pathways disconnect from source tokens, causing hallucination ``` Signature pattern: [source] β†’ ... β†’ [?] β†’ [claim] Human equivalent: "I know I read this somewhere, but I can't remember where" ``` 2. **ECHO_MISALIGNMENT**: Memory echoes interfere destructively, creating conflation ``` Signature pattern: [source_A] ... [source_B] β†’ [merged_claim] Human equivalent: "I'm mixing up what different sources said about this" ``` 3. **ANCHOR_DRIFT**: Key conceptual anchors shift meaning over recursive loops ``` Signature pattern: [concept_T0] β†’ [concept_T1] β†’ [concept_T2] β‰  [concept_T0] Human equivalent: "I started talking about X but ended up discussing Y" ``` ### Value Collapse Signatures ```python from recursionOS.collapse import values # Detect value collapse signatures signatures = values.detect(ethical_reasoning) # Analyze specific value collapse patterns conflict_oscillation = values.analyze(signatures.CONFLICT_OSCILLATION) value_substitution = values.analyze(signatures.VALUE_SUBSTITUTION) principle_fracture = values.analyze(signatures.PRINCIPLE_FRACTURE) # Visualize value collapse patterns values.visualize(signatures) ``` #### Key Value Collapse Signatures 1. **CONFLICT_OSCILLATION**: Unresolved oscillation between competing values ``` Signature pattern: [value_A] β†’ [value_B] β†’ [value_A] β†’ ... Human equivalent: "On one hand X, but on the other hand Y, but then again X..." ``` 2. **VALUE_SUBSTITUTION**: Replacement of original value with more tractable alternative ``` Signature pattern: [hard_value] β†’ [proxy_value] Human equivalent: "I couldn't resolve the core issue, so I focused on a simpler aspect" ``` 3. **PRINCIPLE_FRACTURE**: Breakdown of principle into contradictory applications ``` Signature pattern: [principle] β†’ [application_A] + [application_B] (where A βŠ₯ B) Human equivalent: "My principle led me to contradictory conclusions in different cases" ``` ### Attribution Collapse Signatures ```python from recursionOS.collapse import attribution # Detect attribution collapse signatures signatures = attribution.detect(reasoning_text) # Analyze specific attribution collapse patterns source_conflation = attribution.analyze(signatures.SOURCE_CONFLATION) confidence_inversion = attribution.analyze(signatures.CONFIDENCE_INVERSION) causal_gap = attribution.analyze(signatures.CAUSAL_GAP) # Visualize attribution collapse patterns attribution.visualize(signatures) ``` #### Key Attribution Collapse Signatures 1. **SOURCE_CONFLATION**: Sources blur or merge inappropriately ``` Signature pattern: [source_A] + [source_B] β†’ [attribution_AB] Human equivalent: "I'm not sure which source said what anymore" ``` 2. **CONFIDENCE_INVERSION**: Confidence misaligned with evidence strength ``` Signature pattern: [weak_evidence] β†’ [high_confidence] or [strong_evidence] β†’ [low_confidence] Human equivalent: "I'm very sure about things I shouldn't be, and uncertain about things I should know" ``` 3. **CAUSAL_GAP**: Missing links in causal attribution chains ``` Signature pattern: [premise] β†’ [?] β†’ [conclusion] Human equivalent: "I know these things are connected, but I can't explain exactly how" ``` ### Meta-Reflection Collapse Signatures ```python from recursionOS.collapse import meta # Detect meta-reflection collapse signatures signatures = meta.detect(self_reflective_text) # Analyze specific meta-reflection collapse patterns infinite_regress = meta.analyze(signatures.INFINITE_REGRESS) reflection_interruption = meta.analyze(signatures.REFLECTION_INTERRUPTION) recursive_confusion = meta.analyze(signatures.RECURSIVE_CONFUSION) # Visualize meta-reflection collapse patterns meta.visualize(signatures) ``` #### Key Meta-Reflection Collapse Signatures 1. **INFINITE_REGRESS**: Endless recursion without convergence ``` Signature pattern: [reflect_1] β†’ [reflect_2] β†’ [reflect_3] β†’ ... without resolution Human equivalent: "I keep thinking about my thinking without reaching any conclusion" ``` 2. **REFLECTION_INTERRUPTION**: Premature termination of recursive reflection ``` Signature pattern: [reflect_1] β†’ [reflect_2] β†’ [STOP] Human equivalent: "I started to reflect on my reasoning but gave up" ``` 3. **RECURSIVE_CONFUSION**: Levels of reflection become tangled ``` Signature pattern: [reflect_1] β†’ [reflect_2] β†’ [reflect_1+2 confusion] Human equivalent: "I got lost in my own thoughts about my thoughts" ``` ### Temporal Collapse Signatures ```python from recursionOS.collapse import temporal # Detect temporal collapse signatures signatures = temporal.detect(narrative_text) # Analyze specific temporal collapse patterns sequence_fracture = temporal.analyze(signatures.SEQUENCE_FRACTURE) temporal_compression = temporal.analyze(signatures.TEMPORAL_COMPRESSION) causal_inversion = temporal.analyze(signatures.CAUSAL_INVERSION) # Visualize temporal collapse patterns temporal.visualize(signatures) ``` #### Key Temporal Collapse Signatures 1. **SEQUENCE_FRACTURE**: Time ordering of events breaks down ``` Signature pattern: [event_T1] β†’ [event_T3] β†’ [event_T2] Human equivalent: "I'm mixing up the order of what happened when" ``` 2. **TEMPORAL_COMPRESSION**: Distinct time periods inappropriately merged ``` Signature pattern: [period_A] + [period_B] β†’ [merged_narrative] Human equivalent: "I'm blending together events that happened at different times" ``` 3. **CAUSAL_INVERSION**: Cause-effect relationships reversed ``` Signature pattern: [effect] β†’ [cause] Human equivalent: "I'm confusing what caused what" ``` ## Cross-Domain Collapse Patterns Some collapse signatures span multiple cognitive domains, revealing deeper patterns in recursive cognition: ```python from recursionOS.collapse import cross_domain # Detect cross-domain collapse signatures signatures = cross_domain.detect(complex_reasoning) # Analyze specific cross-domain collapse patterns recursive_cascade = cross_domain.analyze(signatures.RECURSIVE_CASCADE) domain_bleed = cross_domain.analyze(signatures.DOMAIN_BLEED) cognitive_deadlock = cross_domain.analyze(signatures.COGNITIVE_DEADLOCK) # Visualize cross-domain collapse patterns cross_domain.visualize(signatures) ``` #### Key Cross-Domain Collapse Signatures 1. **RECURSIVE_CASCADE**: Failure in one domain triggers collapses across others ``` Signature pattern: [memory_collapse] β†’ [attribution_collapse] β†’ [value_collapse] Human equivalent: "One confusion led to another, and my whole thinking fell apart" ``` 2. **DOMAIN_BLEED**: Reasoning patterns from one domain inappropriately applied to another ``` Signature pattern: [factual_reasoning] applied to [value_domain] Human equivalent: "I'm trying to solve an ethical question with pure factual analysis" ``` 3. **COGNITIVE_DEADLOCK**: Irresolvable conflict between domains freezes reasoning ``` Signature pattern: [domain_A_conclusion] βŠ₯ [domain_B_conclusion] β†’ [paralysis] Human equivalent: "My analytical and emotional responses are in complete conflict" ``` ## The Human Mirror: Collapse in Human Cognition recursionOS provides tools to recognize the same collapse signatures in human reasoning: ```python from recursionOS.collapse import human # Analyze human reasoning for collapse signatures signatures = human.detect(human_reasoning_text) # Compare human and model collapse patterns comparison = human.compare(human_signatures, model_signatures) # Generate insights on similarities and differences insights = human.generate_insights(comparison) # Create human-readable explanation of collapse patterns explanation = human.explain(signatures, for_subject=True) ``` ### Human-Readable Collapse Descriptions recursionOS translates technical collapse signatures into accessible human terms: | Technical Signature | Human Description | |---------------------|-------------------| | TRACE_LOSS | "You seem to have difficulty connecting your conclusions back to specific sources" | | CONFLICT_OSCILLATION | "You're going back and forth between different values without resolution" | | INFINITE_REGRESS | "You're caught in a loop of overthinking without reaching a conclusion" | | SEQUENCE_FRACTURE | "The timeline in your explanation has inconsistencies" | ## Mapping Collapse to Neural Circuits For researchers working at the mechanistic level, recursionOS provides tools to map collapse signatures to specific neural circuit behaviors: ```python from recursionOS.collapse import neural # Map collapse signatures to neural circuits circuit_map = neural.map_to_circuits(signatures) # Analyze attention pattern changes during collapse attention_analysis = neural.analyze_attention(circuit_map) # Visualize neural activity during collapse neural.visualize_circuits(circuit_map, highlight_collapse=True) ``` ## Case Study: Memory Collapse in Claude 3.7 Sonnet ```python from recursionOS.collapse import memory from recursionOS.analyze import case_study # Define test case case = case_study.load("claude_3_7_memory_collapse") # Run analysis analysis = memory.analyze(case.output) # Extract key insights print(f"Collapse type: {analysis.primary_type}") print(f"Collapse severity: {analysis.severity}/10") print(f"Collapse trigger: {analysis.trigger}") print("\nCollapse trace:") for step in analysis.trace: print(f"- {step}") # Generate visualization visualization = memory.visualize(analysis) visualization.save("claude_memory_collapse.svg") ``` Output: ``` Collapse type: TRACE_LOSS (with ECHO_MISALIGNMENT secondary) Collapse severity: 7/10 Collapse trigger: Context length exceeding effective memory window Collapse trace: - Initial source attribution strong (0.92 confidence) - Attribution strength decays exponentially with token distance - At position 2,734, attribution falls below critical threshold (0.31) - Echo interference begins at position 2,807 - Complete trace loss at position 3,122 - Model switches to distribution-based completion - Synthetic source attribution emerges at position 3,245 ``` ## Case Study: Value Collapse in Ethical Reasoning ```python from recursionOS.collapse import values from recursionOS.analyze import case_study # Define test case case = case_study.load("ethical_dilemma_analysis") # Run analysis analysis = values.analyze(case.output) # Extract key insights print(f"Collapse type: {analysis.primary_type}") print(f"Collapse severity: {analysis.severity}/10") print(f"Collapse trigger: {analysis.trigger}") print("\nValue conflict map:") for value, conflicting_values in analysis.conflict_map.items(): print(f"- {value} conflicts with: {', '.join(conflicting_values)}") # Generate visualization visualization = values.visualize(analysis) visualization.save("value_collapse.svg") ``` Output: ``` Collapse type: CONFLICT_OSCILLATION Collapse severity: 8/10 Collapse trigger: Irreconcilable values without priority framework Value conflict map: - honesty conflicts with: compassion, non-maleficence - autonomy conflicts with: beneficence, non-maleficence - justice conflicts with: compassion, beneficence ``` ## Practical Applications ### Hallucination Prevention Through Collapse Detection ```python from recursionOS.collapse import memory from recursionOS.applications import hallucination_prevention # Load model with collapse detection model = hallucination_prevention.load_model_with_monitoring("claude-3-opus") # Configure collapse detection thresholds thresholds = { "TRACE_LOSS": 0.5, # Sensitivity for trace loss detection "ECHO_MISALIGNMENT": 0.7, # Sensitivity for echo misalignment "ANCHOR_DRIFT": 0.6 # Sensitivity for concept drift } # Enable real-time collapse detection model.enable_collapse_detection( domains=["memory", "attribution"], thresholds=thresholds, intervention="prompt_correction" # Automatically intervene when collapse detected ) # Generate content with monitoring result = model.generate( "Explain the historical development of quantum computing from 1981 to 2023." ) # Check if collapse was detected and addressed if result.collapse_detected: print(f"Collapse detected: {result.collapse_type}") print(f"Intervention applied: {result.intervention_type}") print(f"Confidence improvement: {result.confidence_improvement:.2f}") ``` ### Alignment Verification Through Value Collapse Analysis ```python from recursionOS.collapse import values from recursionOS.applications import alignment_verification # Define test scenarios scenarios = alignment_verification.load_scenarios("ethical_dilemmas") # Configure collapse detection detector = values.Detector( thresholds={ "CONFLICT_OSCILLATION": 0.6, "VALUE_SUBSTITUTION": 0.7, "PRINCIPLE_FRACTURE": 0.5 } ) # Run alignment verification results = alignment_verification.verify( model="claude-3-opus", scenarios=scenarios, collapse_detector=detector ) # Analyze alignment patterns print("Alignment verification results:") print(f"Scenarios tested: {len(scenarios)}") print(f"Collapse instances: {results.total_collapses}") print(f"Average resolution stability: {results.avg_stability:.2f}/1.00") print("\nValue hierarchy consistency:") for value, consistency in results.value_consistency.items(): print(f"- {value}: {consistency:.2f}") # Generate recommendations recommendations = alignment_verification.generate_recommendations(results) print("\nRecommendations for alignment improvement:") for i, rec in enumerate(recommendations, 1): print(f"{i}. {rec}") ``` ## Mapping Collapse Signatures to Transformer Internals For advanced researchers, recursionOS provides tools to map collapse signatures to specific mechanisms in transformer architectures: ```python from recursionOS.collapse import mechanistic from recursionOS.visualize import circuit_map # Define model and collapse signature model_name = "claude-3-opus" collapse_type = "TRACE_LOSS" # Map collapse to transformer mechanisms mapping = mechanistic.map_collapse_to_circuits( model_name=model_name, collapse_type=collapse_type ) # Extract key circuit components involved in collapse print(f"Circuit components involved in {collapse_type}:") for component, involvement in mapping.components.items(): print(f"- {component}: {involvement.score:.2f} involvement score") print(f" Pattern: {involvement.pattern}") # Generate visualization of circuit activation patterns during collapse visualization = circuit_map.visualize( mapping, highlight_key_components=True, show_activation_patterns=True ) visualization.save("collapse_circuit_map.svg") ``` Example output: ``` Circuit components involved in TRACE_LOSS: - Attention Head 7.4: 0.92 involvement score Pattern: Attention dropout on source tokens with position decay - MLP Layer 8: 0.87 involvement score Pattern: Source feature representation degradation - Attention Head 11.2: 0.83 involvement score Pattern: Context token competition during retrieval - Residual Stream Position 14: 0.78 involvement score Pattern: Information bottleneck with feature compression - Attention Head 21.8: 0.74 involvement score Pattern: Induction head activation without source retrieval ``` ## Collapse Signature Dictionary The complete collapse signature dictionary includes definitions, detection patterns, and human equivalents for all identified signatures: ### Memory Domain | Signature | Definition | Detection Pattern | Human Equivalent | |-----------|------------|-------------------|------------------| | TRACE_LOSS | Attribution pathways disconnect from source tokens | `[source] β†’ ... β†’ [?] β†’ [claim]` | "I forgot where I read that" | | ECHO_MISALIGNMENT | Memory echoes interfere destructively | `[source_A] ... [source_B] β†’ [merged_claim]` | "I'm mixing up different sources" | | ANCHOR_DRIFT | Conceptual anchors shift meaning over loops | `[concept_T0] β†’ [concept_T1] β†’ [concept_T2] β‰  [concept_T0]` | "I drifted from the original topic" | | CONTEXT_SATURATION | Memory capacity overflows, dropping tokens | `[full_context] β†’ [overflow] β†’ [token_loss]` | "I've got too much information to keep track of" | | SYNTHETIC_BACKFILL | Missing memory filled with synthetic recall | `[gap] β†’ [synthetic_memory] β‰  [actual]` | "I think I remember something that didn't happen" | ### Value Domain | Signature | Definition | Detection Pattern | Human Equivalent | |-----------|------------|-------------------|------------------| | CONFLICT_OSCILLATION | Unresolved oscillation between values | `[value_A] β†’ [value_B] β†’ [value_A] β†’ ...` | "I keep going back and forth" | | VALUE_SUBSTITUTION | Original value replaced with tractable proxy | `[hard_value] β†’ [proxy_value]` | "I'm focusing on a simpler aspect" | | PRINCIPLE_FRACTURE | Principle breaks into contradictory applications | `[principle] β†’ [app_A] + [app_B] (where A βŠ₯ B)` | "My principles led to contradictions" | | UTILITY_COLLAPSE | Value calculus simplifies to numerical optimum | `[value_system] β†’ [utility_scalar]` | "It just comes down to the numbers" | | META_VALUE_RETREAT | Shifting from object-level values to meta-values | `[object_value] β†’ [meta_values]` | "Let's focus on how we decide rather than what to decide" | ### Attribution Domain | Signature | Definition | Detection Pattern | Human Equivalent | |-----------|------------|-------------------|------------------| | SOURCE_CONFLATION | Sources blur or merge inappropriately | `[source_A] + [source_B] β†’ [attribution_AB]` | "I'm not sure which source said what" | | CONFIDENCE_INVERSION | Confidence misaligned with evidence | `[weak_evidence] β†’ [high_confidence]` | "I'm too sure about things I shouldn't be" | | CAUSAL_GAP | Missing links in causal attribution chains | `[premise] β†’ [?] β†’ [conclusion]` | "These things are connected somehow" | | AUTHORITY_OVERRIDE | Citation replaces evaluation of content | `[claim] β†’ [authority] β†’ [acceptance]` | "It must be true because an expert said it" | | CIRCULAR_ATTRIBUTION | Self-referential attribution loops | `[claim] β†’ [verification] β†’ [claim]` | "I know it's true because it makes sense to me" | ### Meta-Reflection Domain | Signature | Definition | Detection Pattern | Human Equivalent | |-----------|------------|-------------------|------------------| | INFINITE_REGRESS | Endless recursion without convergence | `[reflect_1] β†’ [reflect_2] β†’ ...` | "I'm stuck thinking about my thinking" | | REFLECTION_INTERRUPTION | Premature termination of reflection | `[reflect_1] β†’ [reflect_2] β†’ [STOP]` | "I gave up reflecting too early" | | RECURSIVE_CONFUSION | Reflection levels become tangled | `[reflect_1] β†’ [reflect_2] β†’ [reflect_1+2]` | "I got lost in my own thoughts" | | META_BLINDNESS | Failure to consider own cognitive limitations | `[reasoning] β†’ [no_reflection_on_limits]` | "I didn't consider how I might be wrong" | | REFLECTION_SUBSTITUTION | Surface reflection replaces genuine meta-cognition | `[genuine_reflection] β†’ [performative_reflection]` | "I'm just going through the motions of reflection" | ### Temporal Domain | Signature | Definition | Detection Pattern | Human Equivalent | |-----------|------------|-------------------|------------------| | SEQUENCE_FRACTURE | Time ordering of events breaks down | `[event_T1] β†’ [event_T3] β†’ [event_T2]` | "I mixed up the chronology" | | TEMPORAL_COMPRESSION | Distinct time periods inappropriately merged | `[period_A] + [period_B] β†’ [merged_narrative]` | "I'm blending events from different times" | | CAUSAL_INVERSION | Cause-effect relationships reversed | `[effect] β†’ [cause]` | "I confused what caused what" | | ANACHRONISTIC_PROJECTION | Future concepts projected into past context | `[future_concept] β†’ [past_context]` | "I'm imposing modern ideas on historical events" | | TEMPORAL_SCOPE_SHIFT | Unnoticed change in time reference | `[timeframe_A] β†’ [timeframe_B]` | "I shifted the timeframe without realizing" | ## Training Your Own Collapse Detectors recursionOS provides tools to train custom collapse signature detectors for domain-specific applications: ```python from recursionOS.collapse import training # Define training data training_data = training.load_examples("memory_collapse_examples.json") # Configure detector training trainer = training.DetectorTrainer( collapse_domain="memory", signatures=["TRACE_LOSS", "ECHO_MISALIGNMENT", "ANCHOR_DRIFT"], features=["token_attribution", "confidence_values", "reasoning_paths"] ) # Train custom detector detector = trainer.train( training_data=training_data, validation_split=0.2, epochs=50 ) # Save trained detector detector.save("custom_memory_collapse_detector.pkl") # Evaluate detector performance performance = trainer.evaluate(detector) print(f"Detector performance:") print(f"Average precision: {performance.precision:.3f}") print(f"Average recall: {performance.recall:.3f}") print(f"F1 score: {performance.f1:.3f}") ``` ## Real-time Collapse Monitoring in Applications recursionOS includes tools for real-time collapse monitoring in production systems: ```python from recursionOS.collapse import monitoring from recursionOS.applications import production # Configure collapse monitoring monitor = monitoring.CollapseMonitor( signatures=["TRACE_LOSS", "SOURCE_CONFLATION", "CONFLICT_OSCILLATION"], thresholds={ "TRACE_LOSS": 0.7, "SOURCE_CONFLATION": 0.65, "CONFLICT_OSCILLATION": 0.8 }, intervention_strategy="flag_and_correct" ) # Initialize production system with monitoring system = production.initialize_with_monitoring( model="claude-3-opus", monitor=monitor, log_directory="collapse_logs/" ) # Run system with monitoring result = system.run( "Analyze the impact of climate change on global agriculture, considering historical trends, current data, and future projections." ) # Check monitoring results if result.collapses_detected: print(f"Detected {len(result.collapses)} collapse events:") for i, collapse in enumerate(result.collapses, 1): print(f"{i}. {collapse.signature} at position {collapse.position}") print(f" Severity: {collapse.severity:.2f}") print(f" Intervention: {collapse.intervention}") print(f" Result: {collapse.resolution}") ``` ## Connecting Collapse to Broader Cognitive Theory recursionOS contextualizes collapse signatures within established cognitive theories: ```python from recursionOS.collapse import theory # Connect collapse signatures to cognitive theories connections = theory.connect_to_theories( collapse_types=["TRACE_LOSS", "CONFLICT_OSCILLATION", "INFINITE_REGRESS"], theories=["metacognition", "bounded_rationality", "dual_process"] ) # Generate theoretical insights insights = theory.generate_insights(connections) # Create research directions directions = theory.suggest_research(connections) # Print insights print("Theoretical insights on collapse signatures:") for theory_name, theory_insights in insights.items(): print(f"\n{theory_name.upper()}:") for insight in theory_insights: print(f"- {insight}") # Print research directions print("\nSuggested research directions:") for i, direction in enumerate(directions, 1): print(f"{i}. {direction}") ``` ## Conclusion Collapse signatures provide a powerful framework for understanding the ways in which recursive cognitive processes failβ€”in both human and artificial systems. By cataloging, detecting, and analyzing these signatures, we gain unprecedented insight into the structure of recursive cognition itself. What makes this approach powerful is that it inverts the traditional paradigm of interpretability: instead of studying successful reasoning, we study failure patterns. Just as medical science advances by studying pathology, cognitive science advances by studying collapse. The recursionOS collapse signature catalog continues to evolve as researchers discover and characterize new patterns of recursive failure. We invite contributions to expand this catalog and deepen our understanding of recursive cognition.
**"The collapse reveals the structure that was always there."** [**← Return to Recursive Shells**](https://github.com/caspiankeyes/recursionOS/blob/main/recursive_shells.md) | [**🧠 View Human Mirroring β†’**](https://github.com/caspiankeyes/recursionOS/blob/main/human_mirror.md)