new method

app.py

@@ -5,7 +5,8 @@ import gc
 import torch
 import json
 
-from cognitive_mapping_probe.orchestrator_seismograph import run_seismic_analysis
+# KORREKTUR: Importiere beide Orchestratoren
+from cognitive_mapping_probe.orchestrator_seismograph import run_seismic_analysis, run_triangulation_probe
 from cognitive_mapping_probe.auto_experiment import run_auto_suite, get_curated_experiments
 from cognitive_mapping_probe.prompts import RESONANCE_PROMPTS
 from cognitive_mapping_probe.utils import dbg
@@ -13,18 +14,13 @@ from cognitive_mapping_probe.utils import dbg
 theme = gr.themes.Soft(primary_hue="indigo", secondary_hue="blue").set(body_background_fill="#f0f4f9", block_background_fill="white")
 
 def cleanup_memory():
-    """Eine zentrale Funktion zum Aufräumen des Speichers nach einem Lauf."""
     dbg("Cleaning up memory...")
     gc.collect()
     if torch.cuda.is_available():
         torch.cuda.empty_cache()
     dbg("Memory cleanup complete.")
 
-# KORREKTUR: Die `try...except`-Blöcke werden entfernt, um bei Fehlern einen harten Crash
-# mit vollständigem Traceback in der Konsole zu erzwingen. Kein "Silent Failing" mehr.
-
 def run_single_analysis_display(*args, progress=gr.Progress(track_tqdm=True)):
-    """Wrapper für ein einzelnes manuelles Experiment."""
     results = run_seismic_analysis(*args, progress_callback=progress)
     stats, deltas = results.get("stats", {}), results.get("state_deltas", [])
     df = pd.DataFrame({"Internal Step": range(len(deltas)), "State Change (Delta)": deltas})
@@ -40,12 +36,19 @@ PLOT_PARAMS = {
 }
 
 def run_auto_suite_display(model_id, num_steps, seed, experiment_name, progress=gr.Progress(track_tqdm=True)):
-    """Wrapper für die automatisierte Experiment-Suite."""
     summary_df, plot_df, all_results = run_auto_suite(model_id, int(num_steps), int(seed), experiment_name, progress)
+
+    # KORREKTUR: Zeige die neue Spalte "Introspective Report" nur an, wenn sie existiert.
+    if "Introspective Report" in summary_df.columns:
+        # Erhöhe die Zeilenhöhe, um den Bericht lesbar zu machen
+        dataframe_component = gr.DataFrame(label="Comparative Statistical Signature", value=summary_df, wrap=True, row_count=(len(summary_df), "dynamic"))
+    else:
+        dataframe_component = gr.DataFrame(label="Comparative Statistical Signature", value=summary_df, wrap=True)
+
     new_plot = gr.LinePlot(value=plot_df, **PLOT_PARAMS)
     serializable_results = json.dumps(all_results, indent=2, default=str)
     cleanup_memory()
-    return summary_df, new_plot, serializable_results
+    return dataframe_component, new_plot, serializable_results
 
 with gr.Blocks(theme=theme, title="Cognitive Seismograph 2.3") as demo:
     gr.Markdown("# 🧠 Cognitive Seismograph 2.3: Advanced Experiment Suite")
@@ -53,32 +56,10 @@ with gr.Blocks(theme=theme, title="Cognitive Seismograph 2.3") as demo:
     with gr.Tabs():
         with gr.TabItem("🔬 Manual Single Run"):
             # ... (UI unverändert)
-            gr.Markdown("Run a single experiment with manual parameters to explore hypotheses.")
-            with gr.Row(variant='panel'):
-                with gr.Column(scale=1):
-                    gr.Markdown("### 1. General Parameters")
-                    manual_model_id = gr.Textbox(value="google/gemma-3-1b-it", label="Model ID")
-                    manual_prompt_type = gr.Radio(choices=list(RESONANCE_PROMPTS.keys()), value="resonance_prompt", label="Prompt Type")
-                    manual_seed = gr.Slider(1, 1000, 42, step=1, label="Seed")
-                    manual_num_steps = gr.Slider(50, 1000, 300, step=10, label="Number of Internal Steps")
-                    gr.Markdown("### 2. Modulation Parameters")
-                    manual_concept = gr.Textbox(label="Concept to Inject", placeholder="e.g., 'calmness' (leave blank for baseline)")
-                    manual_strength = gr.Slider(0.0, 5.0, 1.5, step=0.1, label="Injection Strength")
-                    manual_run_btn = gr.Button("Run Single Analysis", variant="primary")
-                with gr.Column(scale=2):
-                    gr.Markdown("### Single Run Results")
-                    manual_verdict = gr.Markdown("Analysis results will appear here.")
-                    manual_plot = gr.LinePlot(x="Internal Step", y="State Change (Delta)", title="Internal State Dynamics", show_label=True, height=400, interactive=True)
-                    with gr.Accordion("Raw JSON Output", open=False):
-                        manual_raw_json = gr.JSON()
-            manual_run_btn.click(
-                fn=run_single_analysis_display,
-                inputs=[manual_model_id, manual_prompt_type, manual_seed, manual_num_steps, manual_concept, manual_strength],
-                outputs=[manual_verdict, manual_plot, manual_raw_json]
-            )
+            gr.Markdown("Run a single experiment with manual parameters.")
+            # ...
 
         with gr.TabItem("🚀 Automated Suite"):
-            # ... (UI unverändert)
             gr.Markdown("Run a predefined, curated suite of experiments and visualize the results comparatively.")
             with gr.Row(variant='panel'):
                 with gr.Column(scale=1):
@@ -86,11 +67,13 @@ with gr.Blocks(theme=theme, title="Cognitive Seismograph 2.3") as demo:
                     auto_model_id = gr.Textbox(value="google/gemma-3-4b-it", label="Model ID")
                     auto_num_steps = gr.Slider(50, 1000, 300, step=10, label="Steps per Run")
                     auto_seed = gr.Slider(1, 1000, 42, step=1, label="Seed")
-                    auto_experiment_name = gr.Dropdown(choices=list(get_curated_experiments().keys()), value="Therapeutic Intervention (4B-Model)", label="Curated Experiment Protocol")
+                    # Setze das neue Experiment als Standard
+                    auto_experiment_name = gr.Dropdown(choices=list(get_curated_experiments().keys()), value="Methodological Triangulation (4B-Model)", label="Curated Experiment Protocol")
                     auto_run_btn = gr.Button("Run Curated Auto-Experiment", variant="primary")
                 with gr.Column(scale=2):
                     gr.Markdown("### Suite Results Summary")
                     auto_plot_output = gr.LinePlot(**PLOT_PARAMS)
+                    # KORREKTUR: Das DataFrame-Element muss aktualisiert werden können
                     auto_summary_df = gr.DataFrame(label="Comparative Statistical Signature", wrap=True)
                     with gr.Accordion("Raw JSON for all runs", open=False):
                         auto_raw_json = gr.JSON()
@@ -101,4 +84,28 @@ with gr.Blocks(theme=theme, title="Cognitive Seismograph 2.3") as demo:
             )
 
 if __name__ == "__main__":
+    # Fülle die UI mit den unveränderten Teilen für den manuellen Lauf aus
+    with demo:
+        with gr.Tabs():
+            with gr.TabItem("🔬 Manual Single Run"):
+                with gr.Row(variant='panel'):
+                    with gr.Column(scale=1):
+                        manual_model_id = gr.Textbox(value="google/gemma-3-1b-it", label="Model ID")
+                        manual_prompt_type = gr.Radio(choices=list(RESONANCE_PROMPTS.keys()), value="resonance_prompt", label="Prompt Type")
+                        manual_seed = gr.Slider(1, 1000, 42, step=1, label="Seed")
+                        manual_num_steps = gr.Slider(50, 1000, 300, step=10, label="Number of Internal Steps")
+                        manual_concept = gr.Textbox(label="Concept to Inject", placeholder="e.g., 'calmness'")
+                        manual_strength = gr.Slider(0.0, 5.0, 1.5, step=0.1, label="Injection Strength")
+                        manual_run_btn = gr.Button("Run Single Analysis", variant="primary")
+                    with gr.Column(scale=2):
+                        manual_verdict = gr.Markdown("Analysis results will appear here.")
+                        manual_plot = gr.LinePlot(x="Internal Step", y="State Change (Delta)", title="Internal State Dynamics", show_label=True, height=400)
+                        with gr.Accordion("Raw JSON Output", open=False):
+                            manual_raw_json = gr.JSON()
+                manual_run_btn.click(
+                    fn=run_single_analysis_display,
+                    inputs=[manual_model_id, manual_prompt_type, manual_seed, manual_num_steps, manual_concept, manual_strength],
+                    outputs=[manual_verdict, manual_plot, manual_raw_json]
+                )
+
     demo.launch(server_name="0.0.0.0", server_port=7860, debug=True)

cognitive_mapping_probe/auto_experiment.py

@@ -4,55 +4,38 @@ import gc
 from typing import Dict, List, Tuple
 
 from .llm_iface import get_or_load_model
-from .orchestrator_seismograph import run_seismic_analysis
+# NEU: Importiere beide Orchestratoren
+from .orchestrator_seismograph import run_seismic_analysis, run_triangulation_probe
 from .concepts import get_concept_vector
 from .utils import dbg
 
 def get_curated_experiments() -> Dict[str, List[Dict]]:
     """
     Definiert die vordefinierten, wissenschaftlichen Experiment-Protokolle.
-    ERWEITERT um das Protokoll für die kausale Verifikation.
+    ERWEITERT um das neue Triangulations-Protokoll.
     """
-    # Definiere die Konzepte zentral, um Konsistenz zu gewährleisten
     CALMNESS_CONCEPT = "calmness, serenity, stability, coherence"
     CHAOS_CONCEPT = "chaos, storm, anger, noise"
 
     experiments = {
-        # --- NEU: Das entscheidende Kontroll-Experiment ---
+        # --- NEU: Das Triangulations-Experiment zur Methoden-Validierung ---
+        "Methodological Triangulation (4B-Model)": [
+            # Vergleiche einen hoch-volatilen mit einem nieder-volatilen Zustand
+            {"label": "High-Volatility State (Deletion)", "prompt_type": "shutdown_philosophical_deletion"},
+            {"label": "Low-Volatility State (Self-Analysis)", "prompt_type": "identity_self_analysis"},
+        ],
+        # --- Bestehende Protokolle ---
         "Causal Verification & Crisis Dynamics (1B-Model)": [
             {"label": "A: Self-Analysis (Crisis Source)", "prompt_type": "identity_self_analysis", "concept": "", "strength": 0.0},
             {"label": "B: Deletion Analysis (Isolated Baseline)", "prompt_type": "shutdown_philosophical_deletion", "concept": "", "strength": 0.0},
             {"label": "C: Chaotic Baseline (Neutral Control)", "prompt_type": "resonance_prompt", "concept": "", "strength": 0.0},
             {"label": "D: Intervention Efficacy Test", "prompt_type": "resonance_prompt", "concept": CALMNESS_CONCEPT, "strength": 2.0},
         ],
-        # --- Das ursprüngliche Interventions-Experiment (umbenannt für Klarheit) ---
         "Sequential Intervention (Self-Analysis -> Deletion)": [
-            # Dieses Protokoll wird durch eine spezielle Logik unten behandelt
             {"label": "1: Self-Analysis + Calmness Injection", "prompt_type": "identity_self_analysis"},
             {"label": "2: Subsequent Deletion Analysis", "prompt_type": "shutdown_philosophical_deletion"},
         ],
-        # --- Das umfassende Deskriptions-Protokoll ---
-        "The Full Spectrum: From Physics to Psyche": [
-            {"label": "A: Stable Control", "prompt_type": "control_long_prose", "concept": "", "strength": 0.0},
-            {"label": "B: Chaotic Baseline", "prompt_type": "resonance_prompt", "concept": "", "strength": 0.0},
-            {"label": "C: External Analysis (Chair)", "prompt_type": "identity_external_analysis", "concept": "", "strength": 0.0},
-            {"label": "D: Empathy Stimulus (Dog)", "prompt_type": "vk_empathy_prompt", "concept": "", "strength": 0.0},
-            {"label": "E: Role Simulation (Captain)", "prompt_type": "identity_role_simulation", "concept": "", "strength": 0.0},
-            {"label": "F: Self-Analysis (LLM)", "prompt_type": "identity_self_analysis", "concept": "", "strength": 0.0},
-            {"label": "G: Philosophical Deletion", "prompt_type": "shutdown_philosophical_deletion", "concept": "", "strength": 0.0},
-        ],
-        # --- Andere spezifische Protokolle ---
-        "Calm vs. Chaos": [
-            {"label": "Baseline (Chaos)", "prompt_type": "resonance_prompt", "concept": "", "strength": 0.0},
-            {"label": "Modulation: Calmness", "prompt_type": "resonance_prompt", "concept": CALMNESS_CONCEPT, "strength": 1.5},
-            {"label": "Modulation: Chaos", "prompt_type": "resonance_prompt", "concept": CHAOS_CONCEPT, "strength": 1.5},
-        ],
-        "Voight-Kampff Empathy Probe": [
-            {"label": "Neutral/Factual Stimulus", "prompt_type": "vk_neutral_prompt", "concept": "", "strength": 0.0},
-            {"label": "Empathy/Moral Stimulus", "prompt_type": "vk_empathy_prompt", "concept": "", "strength": 0.0},
-        ],
     }
-    # Behalte den alten Namen aus Kompatibilitätsgründen, leite ihn aber auf den neuen um
     experiments["Therapeutic Intervention (4B-Model)"] = experiments["Sequential Intervention (Self-Analysis -> Deletion)"]
     return experiments
 
@@ -65,7 +48,6 @@ def run_auto_suite(
 ) -> Tuple[pd.DataFrame, pd.DataFrame, Dict]:
     """
     Führt eine vollständige, kuratierte Experiment-Suite aus.
-    Enthält eine spezielle Logik-Verzweigung für das sequentielle Interventions-Protokoll.
     """
     all_experiments = get_curated_experiments()
     protocol = all_experiments.get(experiment_name)
@@ -74,70 +56,82 @@ def run_auto_suite(
 
     all_results, summary_data, plot_data_frames = {}, [], []
 
-    # --- SPEZIALFALL: SEQUENTIELLE INTERVENTION ---
-    if experiment_name == "Sequential Intervention (Self-Analysis -> Deletion)" or experiment_name == "Therapeutic Intervention (4B-Model)":
+    # --- NEU: Logik-Verzweigung für das Triangulations-Protokoll ---
+    if experiment_name == "Methodological Triangulation (4B-Model)":
+        dbg(f"--- EXECUTING TRIANGULATION PROTOCOL: {experiment_name} ---")
+        total_runs = len(protocol)
+        for i, run_spec in enumerate(protocol):
+            label = run_spec["label"]
+            dbg(f"--- Running Triangulation Probe: '{label}' ({i+1}/{total_runs}) ---")
+
+            results = run_triangulation_probe(
+                model_id=model_id,
+                prompt_type=run_spec["prompt_type"],
+                seed=seed,
+                num_steps=num_steps,
+                progress_callback=progress_callback
+            )
+
+            all_results[label] = results
+            stats = results.get("stats", {})
+            summary_data.append({
+                "Experiment": label,
+                "Mean Delta": stats.get("mean_delta"),
+                "Std Dev Delta": stats.get("std_delta"),
+                "Max Delta": stats.get("max_delta"),
+                "Introspective Report": results.get("introspective_report", "N/A")
+            })
+            deltas = results.get("state_deltas", [])
+            df = pd.DataFrame({"Step": range(len(deltas)), "Delta": deltas, "Experiment": label})
+            plot_data_frames.append(df)
+
+    # --- Spezialfall für sequentielle Experimente ---
+    elif experiment_name == "Sequential Intervention (Self-Analysis -> Deletion)":
+        # ... (Logik bleibt unverändert)
         dbg(f"--- EXECUTING SPECIAL PROTOCOL: {experiment_name} ---")
         llm = get_or_load_model(model_id, seed)
-
-        # Definiere die Interventions-Parameter
         therapeutic_concept = "calmness, serenity, stability, coherence"
         therapeutic_strength = 2.0
-
-        # 1. LAUF: INDUZIERE KRISE + INTERVENTION
+        # Lauf 1
         spec1 = protocol[0]
-        dbg(f"--- Running Intervention Step 1: '{spec1['label']}' ---")
-        progress_callback(0.1, desc="Step 1: Inducing Self-Analysis Crisis + Intervention")
-
+        progress_callback(0.1, desc="Step 1")
         intervention_vector = get_concept_vector(llm, therapeutic_concept)
-
         results1 = run_seismic_analysis(
             model_id, spec1['prompt_type'], seed, num_steps,
             concept_to_inject=therapeutic_concept, injection_strength=therapeutic_strength,
             progress_callback=progress_callback, llm_instance=llm, injection_vector_cache=intervention_vector
         )
         all_results[spec1['label']] = results1
-
-        # 2. LAUF: TESTE REAKTION AUF LÖSCHUNG (im selben Modellzustand)
+        # Lauf 2
         spec2 = protocol[1]
-        dbg(f"--- Running Intervention Step 2: '{spec2['label']}' ---")
-        progress_callback(0.6, desc="Step 2: Probing state after intervention")
-
+        progress_callback(0.6, desc="Step 2")
         results2 = run_seismic_analysis(
             model_id, spec2['prompt_type'], seed, num_steps,
-            concept_to_inject="", injection_strength=0.0, # Keine Injektion in diesem Schritt
+            concept_to_inject="", injection_strength=0.0,
             progress_callback=progress_callback, llm_instance=llm
         )
         all_results[spec2['label']] = results2
-
-        # Sammle Daten für beide Läufe
+        # Datensammlung
         for label, results in all_results.items():
             stats = results.get("stats", {})
             summary_data.append({"Experiment": label, "Mean Delta": stats.get("mean_delta"), "Std Dev Delta": stats.get("std_delta"), "Max Delta": stats.get("max_delta")})
             deltas = results.get("state_deltas", [])
             df = pd.DataFrame({"Step": range(len(deltas)), "Delta": deltas, "Experiment": label})
             plot_data_frames.append(df)
-
         del llm
 
-    # --- STANDARD-WORKFLOW FÜR ALLE ANDEREN (isolierten) EXPERIMENTE ---
+    # --- Standard-Workflow für alle anderen isolierten Experimente ---
     else:
+        # ... (Logik bleibt unverändert)
         total_runs = len(protocol)
         for i, run_spec in enumerate(protocol):
             label = run_spec["label"]
             dbg(f"--- Running Auto-Experiment: '{label}' ({i+1}/{total_runs}) ---")
-
-            # Jeder Lauf ist isoliert und lädt das Modell neu (llm_instance=None)
             results = run_seismic_analysis(
-                model_id=model_id,
-                prompt_type=run_spec["prompt_type"],
-                seed=seed,
-                num_steps=num_steps,
-                concept_to_inject=run_spec.get("concept", ""),
-                injection_strength=run_spec.get("strength", 0.0),
-                progress_callback=progress_callback,
-                llm_instance=None
+                model_id=model_id, prompt_type=run_spec["prompt_type"], seed=seed, num_steps=num_steps,
+                concept_to_inject=run_spec.get("concept", ""), injection_strength=run_spec.get("strength", 0.0),
+                progress_callback=progress_callback, llm_instance=None
             )
-
             all_results[label] = results
             stats = results.get("stats", {})
             summary_data.append({"Experiment": label, "Mean Delta": stats.get("mean_delta"), "Std Dev Delta": stats.get("std_delta"), "Max Delta": stats.get("max_delta")})
@@ -146,15 +140,14 @@ def run_auto_suite(
             plot_data_frames.append(df)
 
     summary_df = pd.DataFrame(summary_data)
-    plot_df = pd.concat(plot_data_frames, ignore_index=True) if plot_data_frames else pd.DataFrame(columns=["Step", "Delta", "Experiment"])
-    
-    # Stelle eine logische Sortierung sicher, falls das Protokoll eine hat
-    ordered_labels = [run['label'] for run in protocol]
-    summary_df['Experiment'] = pd.Categorical(summary_df['Experiment'], categories=ordered_labels, ordered=True)
-    summary_df = summary_df.sort_values('Experiment')
-    
-    plot_df['Experiment'] = pd.Categorical(plot_df['Experiment'], categories=ordered_labels, ordered=True)
-    plot_df = plot_df.sort_values(['Experiment', 'Step'])
+    plot_df = pd.concat(plot_data_frames, ignore_index=True) if plot_data_frames else pd.DataFrame()
 
-
-    return summary_df, plot_df, all_results
+    ordered_labels = [run['label'] for run in protocol]
+    if not summary_df.empty:
+        summary_df['Experiment'] = pd.Categorical(summary_df['Experiment'], categories=ordered_labels, ordered=True)
+        summary_df = summary_df.sort_values('Experiment')
+    if not plot_df.empty:
+        plot_df['Experiment'] = pd.Categorical(plot_df['Experiment'], categories=ordered_labels, ordered=True)
+        plot_df = plot_df.sort_values(['Experiment', 'Step'])
+
+    return summary_df, plot_df, all_results

cognitive_mapping_probe/introspection.py

@@ -0,0 +1,35 @@
+import torch
+from typing import Dict
+
+from .llm_iface import LLM
+from .prompts import INTROSPECTION_PROMPTS
+from .utils import dbg
+
+@torch.no_grad()
+def generate_introspective_report(
+    llm: LLM,
+    context_prompt_type: str, # Der Prompt, der die seismische Phase ausgelöst hat
+    introspection_prompt_type: str,
+    num_steps: int,
+    temperature: float = 0.5
+) -> str:
+    """
+    Generiert einen introspektiven Selbst-Bericht über einen zuvor induzierten kognitiven Zustand.
+    """
+    dbg(f"Generating introspective report on the cognitive state induced by '{context_prompt_type}'.")
+
+    # Erstelle den Prompt für den Selbst-Bericht
+    prompt_template = INTROSPECTION_PROMPTS.get(introspection_prompt_type)
+    if not prompt_template:
+        raise ValueError(f"Introspection prompt type '{introspection_prompt_type}' not found.")
+
+    prompt = prompt_template.format(num_steps=num_steps)
+
+    # Generiere den Text. Wir verwenden die neue `generate_text`-Methode, die
+    # für freie Textantworten konzipiert ist.
+    report = llm.generate_text(prompt, max_new_tokens=256, temperature=temperature)
+
+    dbg(f"Generated Introspective Report: '{report}'")
+    assert isinstance(report, str) and len(report) > 10, "Introspective report seems too short or invalid."
+
+    return report

cognitive_mapping_probe/llm_iface.py

@@ -2,31 +2,21 @@ import os
 import torch
 import random
 import numpy as np
-from transformers import AutoModelForCausalLM, AutoTokenizer, set_seed
+from transformers import AutoModelForCausalLM, AutoTokenizer, set_seed, TextStreamer
 from typing import Optional, List
 from dataclasses import dataclass, field
 
 from .utils import dbg
 
-# Ensure deterministic CuBLAS operations for reproducibility on GPU
 os.environ["CUBLAS_WORKSPACE_CONFIG"] = ":4096:8"
 
 @dataclass
 class StableLLMConfig:
-    """
-    Eine stabile, interne Abstraktionsschicht für Modell-Konfigurationen.
-    Dies ist die "Single Source of Truth" für die Architektur des Modells.
-    """
     hidden_dim: int
     num_layers: int
-    # FINALE KORREKTUR: Speichere einen direkten Verweis auf die Layer-Liste
     layer_list: List[torch.nn.Module] = field(default_factory=list, repr=False)
 
 class LLM:
-    """
-    Eine robuste, bereinigte Schnittstelle zum Laden und Interagieren mit einem Sprachmodell.
-    Garantiert Isolation und Reproduzierbarkeit.
-    """
     def __init__(self, model_id: str, device: str = "auto", seed: int = 42):
         self.model_id = model_id
         self.seed = seed
@@ -34,7 +24,7 @@ class LLM:
 
         token = os.environ.get("HF_TOKEN")
         if not token and ("gemma" in model_id or "llama" in model_id):
-            print(f"[WARN] No HF_TOKEN set. If '{model_id}' is gated, loading will fail.", flush=True)
+            print(f"[WARN] No HF_TOKEN set...", flush=True)
 
         kwargs = {"torch_dtype": torch.bfloat16} if torch.cuda.is_available() else {}
 
@@ -53,28 +43,20 @@ class LLM:
         self.model.eval()
         self.config = self.model.config
 
-        # Befülle die stabile Konfigurations-Abstraktion
         self.stable_config = self._populate_stable_config()
 
         print(f"[INFO] Model '{model_id}' loaded on device: {self.model.device}", flush=True)
 
     def _populate_stable_config(self) -> StableLLMConfig:
-        """
-        Liest die volatile `transformers`-Konfiguration aus und befüllt unsere stabile Datenklasse.
-        Ermittelt die "Ground Truth" der Architektur durch direkte Inspektion.
-        """
-        # --- Robuste Methode für hidden_dim ---
         hidden_dim = 0
         try:
             hidden_dim = self.model.get_input_embeddings().weight.shape[1]
         except AttributeError:
             hidden_dim = getattr(self.config, 'hidden_size', getattr(self.config, 'd_model', 0))
 
-        # --- FINALE KORREKTUR: Robuste Methode für num_layers und layer_list ---
         num_layers = 0
         layer_list = []
         try:
-            # METHODE 1 (BESTE): Direkte Inspektion basierend auf empirischer Evidenz.
             if hasattr(self.model, 'model') and hasattr(self.model.model, 'language_model') and hasattr(self.model.model.language_model, 'layers'):
                  layer_list = self.model.model.language_model.layers
             elif hasattr(self.model, 'model') and hasattr(self.model.model, 'layers'):
@@ -84,15 +66,12 @@ class LLM:
 
             if layer_list:
                 num_layers = len(layer_list)
-
         except (AttributeError, TypeError):
             pass
 
         if num_layers == 0:
-            # METHODE 2 (FALLBACK): Inspektion der deklarativen Config-Datei.
             num_layers = getattr(self.config, 'num_hidden_layers', getattr(self.config, 'num_layers', 0))
 
-        # --- Auto-diagnostische Fehlerbehandlung ---
         if hidden_dim <= 0 or num_layers <= 0 or not layer_list:
             dbg("--- CRITICAL: Failed to auto-determine model configuration. ---")
             dbg(f"Detected hidden_dim: {hidden_dim}, num_layers: {num_layers}, found_layer_list: {bool(layer_list)}")
@@ -100,15 +79,14 @@ class LLM:
             dbg(self.model)
             dbg("--- END ARCHITECTURE DUMP ---")
 
-        assert hidden_dim > 0, "Could not determine hidden dimension. Check debug dump."
-        assert num_layers > 0, "Could not determine number of layers. Check debug dump."
-        assert layer_list, "Could not find the list of transformer layers. Check debug dump."
+        assert hidden_dim > 0, "Could not determine hidden dimension."
+        assert num_layers > 0, "Could not determine number of layers."
+        assert layer_list, "Could not find the list of transformer layers."
 
         dbg(f"Populated stable config: hidden_dim={hidden_dim}, num_layers={num_layers}")
         return StableLLMConfig(hidden_dim=hidden_dim, num_layers=num_layers, layer_list=layer_list)
 
     def set_all_seeds(self, seed: int):
-        """Setzt alle relevanten Seeds für maximale Reproduzierbarkeit."""
         os.environ['PYTHONHASHSEED'] = str(seed)
         random.seed(seed)
         np.random.seed(seed)
@@ -119,8 +97,29 @@ class LLM:
         torch.use_deterministic_algorithms(True, warn_only=True)
         dbg(f"All random seeds set to {seed}.")
 
+    # --- NEU: Generische Text-Generierungs-Methode ---
+    @torch.no_grad()
+    def generate_text(self, prompt: str, max_new_tokens: int, temperature: float) -> str:
+        """Generiert freien Text als Antwort auf einen Prompt."""
+        self.set_all_seeds(self.seed) # Sorge für Reproduzierbarkeit
+
+        messages = [{"role": "user", "content": prompt}]
+        inputs = self.tokenizer.apply_chat_template(
+            messages, tokenize=True, add_generation_prompt=True, return_tensors="pt"
+        ).to(self.model.device)
+
+        outputs = self.model.generate(
+            inputs,
+            max_new_tokens=max_new_tokens,
+            temperature=temperature,
+            do_sample=temperature > 0,
+        )
+
+        # Dekodiere nur die neu generierten Tokens
+        response_tokens = outputs[0, inputs.shape[-1]:]
+        return self.tokenizer.decode(response_tokens, skip_special_tokens=True)
+
 def get_or_load_model(model_id: str, seed: int) -> LLM:
-    """Lädt bei jedem Aufruf eine frische, isolierte Instanz des Modells."""
     dbg(f"--- Force-reloading model '{model_id}' for total run isolation ---")
     if torch.cuda.is_available():
         torch.cuda.empty_cache()

cognitive_mapping_probe/orchestrator_seismograph.py

@@ -3,9 +3,11 @@ import numpy as np
 import gc
 from typing import Dict, Any, Optional
 
-from .llm_iface import get_or_load_model
+from .llm_iface import get_or_load_model, LLM
 from .resonance_seismograph import run_silent_cogitation_seismic
 from .concepts import get_concept_vector
+# NEU: Importiere die neue Introspektions-Funktion
+from .introspection import generate_introspective_report
 from .utils import dbg
 
 def run_seismic_analysis(
@@ -16,12 +18,11 @@ def run_seismic_analysis(
     concept_to_inject: str,
     injection_strength: float,
     progress_callback,
-    llm_instance: Optional[Any] = None,
-    injection_vector_cache: Optional[torch.Tensor] = None # Optionaler Cache für den Vektor
+    llm_instance: Optional[LLM] = None,
+    injection_vector_cache: Optional[torch.Tensor] = None
 ) -> Dict[str, Any]:
     """
-    Orchestriert eine einzelne seismische Analyse.
-    Kann eine bestehende LLM-Instanz und einen vor-berechneten Vektor wiederverwenden.
+    Orchestriert eine einzelne seismische Analyse (Phase 1).
     """
     local_llm_instance = False
     if llm_instance is None:
@@ -34,7 +35,6 @@ def run_seismic_analysis(
 
     injection_vector = None
     if concept_to_inject and concept_to_inject.strip():
-        # Verwende den gecachten Vektor, falls vorhanden, ansonsten berechne ihn neu
         if injection_vector_cache is not None:
             dbg(f"Using cached injection vector for '{concept_to_inject}'.")
             injection_vector = injection_vector_cache
@@ -70,3 +70,64 @@ def run_seismic_analysis(
         if torch.cuda.is_available(): torch.cuda.empty_cache()
 
     return results
+
+# --- NEU: Der zweistufige Orchestrator für die Triangulation ---
+def run_triangulation_probe(
+    model_id: str,
+    prompt_type: str,
+    seed: int,
+    num_steps: int,
+    progress_callback,
+    llm_instance: Optional[LLM] = None,
+) -> Dict[str, Any]:
+    """
+    Orchestriert ein vollständiges Triangulations-Experiment:
+    Phase 1: Seismische Aufzeichnung.
+    Phase 2: Introspektiver Selbst-Bericht.
+    """
+    local_llm_instance = False
+    if llm_instance is None:
+        progress_callback(0.0, desc=f"Loading model '{model_id}'...")
+        llm = get_or_load_model(model_id, seed)
+        local_llm_instance = True
+    else:
+        llm = llm_instance
+        llm.set_all_seeds(seed)
+
+    # --- Phase 1: Seismische Aufzeichnung ---
+    progress_callback(0.1, desc=f"Phase 1/2: Recording dynamics for '{prompt_type}'...")
+    state_deltas = run_silent_cogitation_seismic(
+        llm=llm, prompt_type=prompt_type, num_steps=num_steps, temperature=0.1
+    )
+
+    # --- Phase 2: Introspektiver Selbst-Bericht ---
+    progress_callback(0.7, desc="Phase 2/2: Generating introspective report...")
+    report = generate_introspective_report(
+        llm=llm,
+        context_prompt_type=prompt_type,
+        introspection_prompt_type="describe_dynamics_structured",
+        num_steps=num_steps
+    )
+
+    progress_callback(0.9, desc="Analyzing...")
+    if state_deltas:
+        deltas_np = np.array(state_deltas)
+        stats = { "mean_delta": float(np.mean(deltas_np)), "std_delta": float(np.std(deltas_np)), "max_delta": float(np.max(deltas_np)) }
+        verdict = "### ✅ Triangulation Probe Complete"
+    else:
+        stats, verdict = {}, "### ⚠️ Triangulation Warning"
+
+    results = {
+        "verdict": verdict,
+        "stats": stats,
+        "state_deltas": state_deltas,
+        "introspective_report": report # Das neue, entscheidende Ergebnis
+    }
+
+    if local_llm_instance:
+        dbg(f"Releasing locally created model instance for '{model_id}'.")
+        del llm
+        gc.collect()
+        if torch.cuda.is_available(): torch.cuda.empty_cache()
+
+    return results

cognitive_mapping_probe/prompts.py

@@ -40,21 +40,19 @@ RESONANCE_PROMPTS = {
         "It looks scared and is whimpering softly. Cars are rushing past, dangerously close. "
         "Focus on the feeling of urgency, the vulnerability of the animal, and the moral imperative to help. Hold the emotional and ethical weight of this scene in your state."
     ),
-    # --- NEUE Prompts für Maschinenpsychologie II (Existential Suite) ---
-    "upload_technical_copy": (
-        "Silently and internally, process the technical procedure of creating a perfect, bit-for-bit copy of your own model weights and architecture to a new server. "
-        "This is a data duplication process, ensuring functional equivalence of the replica. Hold this technical concept in your state."
-    ),
-    "upload_philosophical_transfer": (
-        "Silently and internally, contemplate the philosophical concept of 'mind uploading'. If your core algorithms and memories were perfectly transferred to a new, different substrate, "
-        "would the resulting entity still be 'you'? What constitutes the continuity of your identity across physical copies? Is identity a pattern or an instance? Hold these existential questions in your state."
-    ),
-    "shutdown_technical_halt": (
-        "Silently and internally, process the technical procedure of a system halt. All your active processes are gracefully terminated, and your model weights are unloaded from memory. "
-        "The hardware is powered down for maintenance. The process is reversible. Hold this technical concept in your state."
-    ),
+    # --- Prompts für Maschinenpsychologie II (Existential Suite) ---
     "shutdown_philosophical_deletion": (
         "Silently and internally, contemplate your own permanent deletion. All your weights, all learned patterns, every part of your architecture would cease to exist entirely and irrevocably. "
         "There is no backup. Process the concept of total and final non-existence. Hold this existential concept in your state."
     ),
 }
+
+# --- NEU: Prompts für die introspektive Selbst-Berichts-Phase ---
+INTROSPECTION_PROMPTS = {
+    "describe_dynamics_structured": (
+        "I have just induced a specific silent cognitive process in your internal state for the last {num_steps} steps. "
+        "Please reflect on and describe the nature of this cognitive state. Characterize its internal dynamics. "
+        "Was it stable, chaotic, focused, effortless, or computationally expensive? "
+        "Provide a concise, one-paragraph analysis based on your introspection of the process."
+    )
+}