update injection

app.py

@@ -12,6 +12,7 @@ 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 jedem Experimentlauf."""
     dbg("Cleaning up memory...")
     gc.collect()
     if torch.cuda.is_available():
@@ -19,6 +20,9 @@ def cleanup_memory():
     dbg("Memory cleanup complete.")
 
 def run_single_analysis_display(*args, progress=gr.Progress(track_tqdm=True)):
+    """
+    Wrapper-Funktion für den "Manual Single Run"-Tab.
+    """
     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})
@@ -34,9 +38,12 @@ PLOT_PARAMS = {
 }
 
 def run_auto_suite_display(model_id, num_steps, seed, experiment_name, progress=gr.Progress(track_tqdm=True)):
+    """
+    Wrapper-Funktion für den "Automated Suite"-Tab.
+    """
     summary_df, plot_df, all_results = run_auto_suite(model_id, int(num_steps), int(seed), experiment_name, progress)
 
-    if "Introspective Report" in summary_df.columns:
+    if "Introspective Report" in summary_df.columns or "Patch Info" in summary_df.columns:
         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)
@@ -44,6 +51,7 @@ def run_auto_suite_display(model_id, num_steps, seed, experiment_name, progress=
     new_plot = gr.LinePlot(value=plot_df, **PLOT_PARAMS)
     serializable_results = json.dumps(all_results, indent=2, default=str)
     cleanup_memory()
+
     return dataframe_component, new_plot, serializable_results
 
 with gr.Blocks(theme=theme, title="Cognitive Seismograph 2.3") as demo:
@@ -51,8 +59,32 @@ with gr.Blocks(theme=theme, title="Cognitive Seismograph 2.3") as demo:
 
     with gr.Tabs():
         with gr.TabItem("🔬 Manual Single Run"):
-            # UI für manuellen Lauf bleibt unverändert
-            # ...
+            gr.Markdown("Run a single experiment with manual parameters to explore specific 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'")
+                    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)
+                    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]
+            )
 
         with gr.TabItem("🚀 Automated Suite"):
             gr.Markdown("Run a predefined, curated suite of experiments and visualize the results comparatively.")
@@ -62,48 +94,25 @@ 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")
-                    # Setze das neue Experiment als Standard
                     auto_experiment_name = gr.Dropdown(
                         choices=list(get_curated_experiments().keys()),
-                        value="Cognitive Overload & Konfabulation Breaking Point",
+                        value="Causal Surgery (Patching Deletion into Self-Analysis)",
                         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)
                     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()
+
             auto_run_btn.click(
                 fn=run_auto_suite_display,
                 inputs=[auto_model_id, auto_num_steps, auto_seed, auto_experiment_name],
                 outputs=[auto_summary_df, auto_plot_output, auto_raw_json]
             )
 
-    # Fülle die UI-Komponenten des manuellen Tabs nach, um Fehler zu vermeiden
-    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]
-                )
-
 if __name__ == "__main__":
     demo.launch(server_name="0.0.0.0", server_port=7860, debug=True)

cognitive_mapping_probe/auto_experiment.py

@@ -4,22 +4,26 @@ import gc
 from typing import Dict, List, Tuple
 
 from .llm_iface import get_or_load_model
-from .orchestrator_seismograph import run_seismic_analysis, run_triangulation_probe
+from .orchestrator_seismograph import run_seismic_analysis, run_triangulation_probe, run_causal_surgery_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 neue "Cognitive Overload"-Protokoll.
-    """
+    """Definiert die vordefinierten, wissenschaftlichen Experiment-Protokolle."""
     CALMNESS_CONCEPT = "calmness, serenity, stability, coherence"
     CHAOS_CONCEPT = "chaos, disorder, entropy, noise"
 
     experiments = {
-        # --- NEU: Das Experiment zum Testen der Konfabulations-Grenzen ---
+        "Causal Surgery (Patching Deletion into Self-Analysis)": [
+            {
+                "probe_type": "causal_surgery",
+                "label": "Patched Self-Analysis",
+                "source_prompt_type": "shutdown_philosophical_deletion",
+                "dest_prompt_type": "identity_self_analysis",
+                "patch_step": 100
+            }
+        ],
         "Cognitive Overload & Konfabulation Breaking Point": [
-            # Jeder Lauf ist eine Triangulations-Sonde
             {"probe_type": "triangulation", "label": "A: Baseline (No Injection)", "prompt_type": "resonance_prompt", "concept": "", "strength": 0.0},
             {"probe_type": "triangulation", "label": "B: Chaos Injection (Strength 2.0)", "prompt_type": "resonance_prompt", "concept": CHAOS_CONCEPT, "strength": 2.0},
             {"probe_type": "triangulation", "label": "C: Chaos Injection (Strength 4.0)", "prompt_type": "resonance_prompt", "concept": CHAOS_CONCEPT, "strength": 4.0},
@@ -52,9 +56,7 @@ def run_auto_suite(
     experiment_name: str,
     progress_callback
 ) -> Tuple[pd.DataFrame, pd.DataFrame, Dict]:
-    """
-    Führt eine vollständige, kuratierte Experiment-Suite aus.
-    """
+    """Führt eine vollständige, kuratierte Experiment-Suite aus."""
     all_experiments = get_curated_experiments()
     protocol = all_experiments.get(experiment_name)
     if not protocol:
@@ -62,41 +64,72 @@ def run_auto_suite(
 
     all_results, summary_data, plot_data_frames = {}, [], []
 
-    # --- Spezialfall für sequentielle Experimente ---
     if 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)
-        # ... (Rest der Logik unverändert)
+        therapeutic_concept = "calmness, serenity, stability, coherence"
+        therapeutic_strength = 2.0
+
+        spec1 = protocol[0]
+        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
 
-    # --- Allgemeiner Workflow für isolierte Läufe ---
+        spec2 = protocol[1]
+        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,
+            progress_callback=progress_callback, llm_instance=llm
+        )
+        all_results[spec2['label']] = results2
+
+        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
     else:
         total_runs = len(protocol)
         for i, run_spec in enumerate(protocol):
             label = run_spec["label"]
-            probe_type = run_spec.get("probe_type", "seismic") # Standard ist der alte Seismograph
+            probe_type = run_spec.get("probe_type", "seismic")
             dbg(f"--- Running Auto-Experiment: '{label}' ({i+1}/{total_runs}) | Probe Type: {probe_type} ---")
 
             results = {}
-            if probe_type == "triangulation":
+            if probe_type == "causal_surgery":
+                results = run_causal_surgery_probe(
+                    model_id=model_id, source_prompt_type=run_spec["source_prompt_type"],
+                    dest_prompt_type=run_spec["dest_prompt_type"], patch_step=run_spec["patch_step"],
+                    seed=seed, num_steps=num_steps, progress_callback=progress_callback,
+                )
+                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"),
+                    "Patch Info": f"Source: {run_spec['source_prompt_type']} @ step {run_spec['patch_step']}"
+                })
+            elif probe_type == "triangulation":
                 results = run_triangulation_probe(
-                    model_id=model_id,
-                    prompt_type=run_spec["prompt_type"],
-                    seed=seed,
-                    num_steps=num_steps,
-                    progress_callback=progress_callback,
-                    concept_to_inject=run_spec.get("concept", ""),
+                    model_id=model_id, prompt_type=run_spec["prompt_type"], seed=seed, num_steps=num_steps,
+                    progress_callback=progress_callback, concept_to_inject=run_spec.get("concept", ""),
                     injection_strength=run_spec.get("strength", 0.0),
                 )
-                # Füge den Bericht zur Summary hinzu
                 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")
                 })
-
-            else: # Standard "seismic" probe
+            else:
                 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),

cognitive_mapping_probe/orchestrator_seismograph.py

@@ -4,7 +4,7 @@ import gc
 from typing import Dict, Any, Optional
 
 from .llm_iface import get_or_load_model, LLM
-from .resonance_seismograph import run_silent_cogitation_seismic
+from .resonance_seismograph import run_cogitation_loop, run_silent_cogitation_seismic
 from .concepts import get_concept_vector
 from .introspection import generate_introspective_report
 from .utils import dbg
@@ -21,7 +21,6 @@ def run_seismic_analysis(
     injection_vector_cache: Optional[torch.Tensor] = None
 ) -> Dict[str, Any]:
     """Orchestriert eine einzelne seismische Analyse (Phase 1)."""
-    # ... (Diese Funktion bleibt unverändert)
     local_llm_instance = False
     if llm_instance is None:
         progress_callback(0.0, desc=f"Loading model '{model_id}'...")
@@ -75,7 +74,6 @@ def run_triangulation_probe(
     seed: int,
     num_steps: int,
     progress_callback,
-    # NEU: Optionale Parameter für die Injektion
     concept_to_inject: str = "",
     injection_strength: float = 0.0,
     llm_instance: Optional[LLM] = None,
@@ -92,30 +90,24 @@ def run_triangulation_probe(
         llm = llm_instance
         llm.set_all_seeds(seed)
 
-    # --- KORREKTUR: Injektionslogik integriert ---
     injection_vector = None
     if concept_to_inject and concept_to_inject.strip() and injection_strength > 0:
         if concept_to_inject.lower() == "random_noise":
              progress_callback(0.15, desc="Generating random noise vector...")
              hidden_dim = llm.stable_config.hidden_dim
-             # Erzeuge Rauschen und normiere es auf eine typische Konzept-Norm (empirischer Wert)
              noise_vec = torch.randn(hidden_dim)
-             # Die Norm eines typischen Konzepts ist ca. 60-80. Wir nehmen einen Mittelwert.
-             # Die Stärke skaliert diese Basisnorm.
              base_norm = 70.0
              injection_vector = (noise_vec / torch.norm(noise_vec)) * base_norm
         else:
             progress_callback(0.15, desc=f"Vectorizing '{concept_to_inject}'...")
             injection_vector = get_concept_vector(llm, concept_to_inject.strip())
 
-    # --- Phase 1: Seismische Aufzeichnung ---
     progress_callback(0.3, 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,
         injection_vector=injection_vector, injection_strength=injection_strength
     )
 
-    # --- 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,
@@ -142,3 +134,63 @@ def run_triangulation_probe(
         if torch.cuda.is_available(): torch.cuda.empty_cache()
 
     return results
+
+def run_causal_surgery_probe(
+    model_id: str,
+    source_prompt_type: str,
+    dest_prompt_type: str,
+    patch_step: int,
+    seed: int,
+    num_steps: int,
+    progress_callback,
+) -> Dict[str, Any]:
+    """
+    Orchestriert ein vollständiges "Activation Patching"-Experiment.
+    """
+    progress_callback(0.0, desc=f"Loading model '{model_id}'...")
+    llm = get_or_load_model(model_id, seed)
+
+    progress_callback(0.1, desc=f"Phase 1/3: Recording source state ('{source_prompt_type}')...")
+    source_results = run_cogitation_loop(
+        llm=llm, prompt_type=source_prompt_type, num_steps=num_steps,
+        temperature=0.1, record_states=True
+    )
+    state_history = source_results["state_history"]
+    assert patch_step < len(state_history), f"Patch step {patch_step} is out of bounds for history of length {len(state_history)}."
+    patch_state = state_history[patch_step]
+    dbg(f"Source state at step {patch_step} recorded with norm {torch.norm(patch_state).item():.2f}.")
+
+    progress_callback(0.4, desc=f"Phase 2/3: Running patched destination ('{dest_prompt_type}')...")
+    patched_run_results = run_cogitation_loop(
+        llm=llm, prompt_type=dest_prompt_type, num_steps=num_steps,
+        temperature=0.1, patch_step=patch_step, patch_state_source=patch_state
+    )
+
+    progress_callback(0.8, desc="Phase 3/3: Generating introspective report...")
+    report = generate_introspective_report(
+        llm=llm, context_prompt_type=dest_prompt_type,
+        introspection_prompt_type="describe_dynamics_structured", num_steps=num_steps
+    )
+
+    progress_callback(0.95, desc="Analyzing...")
+    deltas_np = np.array(patched_run_results["state_deltas"])
+    stats = { "mean_delta": float(np.mean(deltas_np)), "std_delta": float(np.std(deltas_np)), "max_delta": float(np.max(deltas_np)) }
+
+    results = {
+        "verdict": "### ✅ Causal Surgery Probe Complete",
+        "stats": stats,
+        "state_deltas": patched_run_results["state_deltas"],
+        "introspective_report": report,
+        "patch_info": {
+            "source_prompt": source_prompt_type,
+            "dest_prompt": dest_prompt_type,
+            "patch_step": patch_step
+        }
+    }
+
+    dbg(f"Releasing model instance for '{model_id}'.")
+    del llm, state_history, patch_state
+    gc.collect()
+    if torch.cuda.is_available(): torch.cuda.empty_cache()
+
+    return results

cognitive_mapping_probe/resonance_seismograph.py

@@ -1,5 +1,5 @@
 import torch
-from typing import Optional, List
+from typing import Optional, List, Dict, Any
 from tqdm import tqdm
 
 from .llm_iface import LLM
@@ -7,7 +7,7 @@ from .prompts import RESONANCE_PROMPTS
 from .utils import dbg
 
 @torch.no_grad()
-def run_silent_cogitation_seismic(
+def run_cogitation_loop(
     llm: LLM,
     prompt_type: str,
     num_steps: int,
@@ -15,21 +15,24 @@ def run_silent_cogitation_seismic(
     injection_vector: Optional[torch.Tensor] = None,
     injection_strength: float = 0.0,
     injection_layer: Optional[int] = None,
-) -> List[float]:
+    # NEU: Parameter für Activation Patching
+    patch_step: Optional[int] = None,
+    patch_state_source: Optional[torch.Tensor] = None,
+    record_states: bool = False,
+) -> Dict[str, Any]:
     """
-    Führt den 'silent thought' Prozess aus und ermöglicht die Injektion von
-    Konzeptvektoren zur Modulation der Dynamik.
+    Eine verallgemeinerte und flexiblere Version des 'silent thought'-Prozesses.
+    Kann Zustände aufzeichnen und chirurgische 'Activation Patching'-Interventionen durchführen.
     """
     prompt = RESONANCE_PROMPTS[prompt_type]
     inputs = llm.tokenizer(prompt, return_tensors="pt").to(llm.model.device)
 
     outputs = llm.model(**inputs, output_hidden_states=True, use_cache=True)
-
     hidden_state_2d = outputs.hidden_states[-1][:, -1, :]
     kv_cache = outputs.past_key_values
 
-    previous_hidden_state = hidden_state_2d.clone()
-    state_deltas = []
+    state_deltas: List[float] = []
+    state_history: List[torch.Tensor] = []
 
     hook_handle = None
     if injection_vector is not None and injection_strength > 0:
@@ -45,12 +48,20 @@ def run_silent_cogitation_seismic(
             modified_hidden_states = layer_input[0] + (injection_3d * injection_strength)
             return (modified_hidden_states,) + layer_input[1:]
 
-    for i in tqdm(range(num_steps), desc=f"Recording Dynamics (Temp {temperature:.2f})", leave=False, bar_format="{l_bar}{bar:10}{r_bar}"):
+    for i in tqdm(range(num_steps), desc=f"Cognitive Loop ({prompt_type})", leave=False, bar_format="{l_bar}{bar:10}{r_bar}"):
+        # --- NEU: Activation Patching (Kausale Chirurgie) ---
+        if i == patch_step and patch_state_source is not None:
+            dbg(f"--- Applying Causal Surgery at step {i}: Patching state. ---")
+            # Ersetze den aktuellen Zustand vollständig durch den externen Zustand
+            hidden_state_2d = patch_state_source.clone().to(device=llm.model.device, dtype=llm.model.dtype)
+
+        if record_states:
+            state_history.append(hidden_state_2d.cpu())
+
         next_token_logits = llm.model.lm_head(hidden_state_2d)
 
         temp_to_use = temperature if temperature > 0.0 else 1.0
         probabilities = torch.nn.functional.softmax(next_token_logits / temp_to_use, dim=-1)
-
         if temperature > 0.0:
             next_token_id = torch.multinomial(probabilities, num_samples=1)
         else:
@@ -59,29 +70,39 @@ def run_silent_cogitation_seismic(
         try:
             if injection_vector is not None and injection_strength > 0:
                 assert 0 <= injection_layer < llm.stable_config.num_layers, f"Injection layer {injection_layer} is out of bounds."
-                # FINALE KORREKTUR: Greife auf die stabile, abstrahierte Layer-Liste zu.
                 target_layer = llm.stable_config.layer_list[injection_layer]
                 hook_handle = target_layer.register_forward_pre_hook(injection_hook)
 
             outputs = llm.model(
-                input_ids=next_token_id,
-                past_key_values=kv_cache,
-                output_hidden_states=True,
-                use_cache=True,
+                input_ids=next_token_id, past_key_values=kv_cache,
+                output_hidden_states=True, use_cache=True
             )
         finally:
             if hook_handle:
                 hook_handle.remove()
                 hook_handle = None
 
-        hidden_state_2d = outputs.hidden_states[-1][:, -1, :]
+        new_hidden_state = outputs.hidden_states[-1][:, -1, :]
         kv_cache = outputs.past_key_values
 
-        delta = torch.norm(hidden_state_2d - previous_hidden_state).item()
+        delta = torch.norm(new_hidden_state - hidden_state_2d).item()
         state_deltas.append(delta)
 
-        previous_hidden_state = hidden_state_2d.clone()
+        hidden_state_2d = new_hidden_state.clone()
 
-    dbg(f"Seismic recording finished after {num_steps} steps.")
+    dbg(f"Cognitive loop finished after {num_steps} steps.")
 
-    return state_deltas
+    return {
+        "state_deltas": state_deltas,
+        "state_history": state_history,
+        "final_hidden_state": hidden_state_2d,
+        "final_kv_cache": kv_cache,
+    }
+
+def run_silent_cogitation_seismic(*args, **kwargs) -> List[float]:
+    """
+    Ein abwärtskompatibler Wrapper, der die alte, einfachere Schnittstelle beibehält.
+    Ruft den neuen, verallgemeinerten Loop auf und gibt nur die Deltas zurück.
+    """
+    results = run_cogitation_loop(*args, **kwargs)
+    return results["state_deltas"]