fix(verif): wire CORTEX_ABLATE_<MECH> env-var reads into production hot-paths (23 mechanisms)

Adds is_mechanism_disabled() helper in core.ablation that reads
CORTEX_ABLATE_<NAME>=1 on every call (no memoization -- production
env never set, test env varies per run). Wires guards at the
primary entry point of 23 of the 26 Mechanism enum values so the
E1 verification campaign produces real per-mechanism causal deltas
instead of identical numbers from inert hooks.

Wired (23):
  OSCILLATORY_CLOCK -> modulate_encoding/retrieval/plasticity
  CASCADE -> compute_advancement_readiness
  PREDICTIVE_CODING -> gate_decision + hierarchical_gate_decision
  PATTERN_SEPARATION -> orthogonalize_embedding
  SCHEMA_ENGINE -> find_best_matching_schema
  TRIPARTITE_SYNAPSE -> compute_ltp_modulation
  INTERFERENCE -> orthogonalize_pair + compute_retrieval_suppression
  HOMEOSTATIC_PLASTICITY -> compute_scaling_factor
  SYNAPTIC_PLASTICITY -> apply_hebbian_update
  SYNAPTIC_TAGGING -> apply_synaptic_tags
  EMOTIONAL_TAGGING -> compute_importance_boost
  EMOTIONAL_DECAY -> compute_decay_resistance
  MICROGLIAL_PRUNING -> identify_prunable_edges
  SPREADING_ACTIVATION -> spread_activation
  ENGRAM_ALLOCATION -> find_best_slot
  RECONSOLIDATION -> decide_action
  DENDRITIC_CLUSTERS -> find_best_branch
  TWO_STAGE_MODEL -> should_release_hippocampal_trace
  HOPFIELD -> retrieve
  HDC -> compute_hdc_scores
  ADAPTIVE_DECAY -> compute_decay (constant lambda when ablated)
  NEUROMODULATION -> update_state (frozen state when ablated)
  SURPRISE_MOMENTUM -> TitansMemory.update
  CO_ACTIVATION -> _apply_co_activation (handler)

Not wired (no production code paths exist; flagged for follow-up):
  EMOTIONAL_RETRIEVAL -- emotion-conditioned recall scoring not implemented
  MOOD_CONGRUENT_RERANK -- mood-congruent rerank not implemented at recall

Smoke run (longmemeval-s --quick) confirms non-baseline deltas:
  PATTERN_SEPARATION  MRR delta -0.009 (0.691 -> 0.682)
  HOPFIELD            MRR delta -0.044 (0.672 -> 0.628)
  HDC                 R@10 delta -0.050, MRR delta -0.013

26 unit tests in tests_py/core/test_ablation_hooks.py verify each
guard short-circuits when CORTEX_ABLATE_<NAME>=1 and runs the active
path otherwise. All 1663 existing core tests pass (no regression).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: cdeust

mcp_server/core/ablation.py

@@ -10,15 +10,41 @@
 - Other mechanisms continue operating normally
 - System-level metrics are tracked for comparison
 
-Pure business logic -- no I/O.
+Pure business logic -- no I/O (the env-var read is a single os.environ
+lookup, performed only when an E1 verification campaign sets it; in
+production the var is never set so the lookup is a constant-time miss).
 """
 
 from __future__ import annotations
 
+import os
 from dataclasses import dataclass, field
 from enum import Enum
 
 
+def is_mechanism_disabled(mechanism: "Mechanism | str") -> bool:
+    """True iff CORTEX_ABLATE_<NAME>=1 is set for this mechanism.
+
+    Production hot-paths call this at the entry point and short-circuit to
+    a no-op when True. Used by the E1 verification campaign
+    (benchmarks/lib/ablation_runner.py) to produce per-mechanism causal
+    deltas; in production the env var is never set so every check is a
+    single dict lookup.
+
+    Reads os.environ on every call -- callers are not in a tight loop;
+    test env varies per-run; production env never changes mid-process.
+    DO NOT memoize.
+
+    Accepts either a Mechanism enum (uses .name -> e.g. "OSCILLATORY_CLOCK")
+    or a string (upper-cased, hyphens normalized).
+    """
+    if hasattr(mechanism, "name"):
+        name = mechanism.name
+    else:
+        name = str(mechanism).upper().replace("-", "_")
+    return os.environ.get(f"CORTEX_ABLATE_{name}") == "1"
+
+
 class Mechanism(Enum):
     """Enumeration of all ablatable Cortex mechanisms."""
 

mcp_server/core/cascade_advancement.py

@@ -160,6 +160,12 @@ def compute_advancement_readiness(
 
     Returns (is_ready, next_stage_name, readiness_score_0_to_1).
     """
+    from mcp_server.core.ablation import Mechanism, is_mechanism_disabled
+
+    if is_mechanism_disabled(Mechanism.CASCADE):
+        # No-op: never advance the consolidation stage; memories remain LABILE.
+        return False, current_stage, 0.0
+
     try:
         stage = ConsolidationStage(current_stage)
     except ValueError:

mcp_server/core/coupled_neuromodulation.py

@@ -133,6 +133,12 @@ def update_state(
     Takes current state + operation signals, returns new state with all
     channels updated and cross-coupled. Original not mutated.
     """
+    from mcp_server.core.ablation import Mechanism, is_mechanism_disabled
+
+    if is_mechanism_disabled(Mechanism.NEUROMODULATION):
+        # No-op: state is frozen at the current values; no DA/NE/ACh/5-HT updates.
+        return current
+
     da, ne, ach, ser, new_baseline, new_adaptation = _compute_raw_channels(
         current, signals
     )

mcp_server/core/dendritic_clusters.py

@@ -80,6 +80,12 @@ def find_best_branch(
     Returns:
         (best_branch, affinity_score). None if no branch qualifies.
     """
+    from mcp_server.core.ablation import Mechanism, is_mechanism_disabled
+
+    if is_mechanism_disabled(Mechanism.DENDRITIC_CLUSTERS):
+        # No-op: no branch-based modulation; no cluster match.
+        return None, 0.0
+
     best: DendriticBranch | None = None
     best_score = 0.0
 

mcp_server/core/emotional_tagging.py

@@ -186,6 +186,12 @@ def compute_importance_boost(
 
     Returns multiplier in [1.0, 2.0].
     """
+    from mcp_server.core.ablation import Mechanism, is_mechanism_disabled
+
+    if is_mechanism_disabled(Mechanism.EMOTIONAL_TAGGING):
+        # No-op: base priority (no Yerkes-Dodson modulation).
+        return 1.0
+
     # Smooth Yerkes-Dodson: f(a) = c * a * exp(-b * a) + 1.0
     # b = 1/0.7 ≈ 1.4286 => peak at arousal = 0.7
     # c chosen so peak value ≈ 1.57: c = 1.57 / (0.7 * exp(-1)) ≈ 6.094 * 0.57 ... let me compute
@@ -216,6 +222,11 @@ def compute_decay_resistance(
 
     Returns multiplier in [1.0, 2.0].
     """
+    from mcp_server.core.ablation import Mechanism, is_mechanism_disabled
+
+    if is_mechanism_disabled(Mechanism.EMOTIONAL_DECAY):
+        # No-op: no emotion-modulated decay slowdown.
+        return 1.0
     if arousal < 0.1:
         return 1.0
 

mcp_server/core/engram.py

@@ -73,6 +73,12 @@ def find_best_slot(
     Returns:
         (best_slot_index, best_excitability).
     """
+    from mcp_server.core.ablation import Mechanism, is_mechanism_disabled
+
+    if is_mechanism_disabled(Mechanism.ENGRAM_ALLOCATION):
+        # No-op: baseline allocation -- always slot 0 with neutral excitability.
+        return 0, 0.5
+
     best_slot = 0
     best_exc = -1.0
 

mcp_server/core/hdc_encoder.py

@@ -224,6 +224,11 @@ def compute_hdc_scores(
         List of (memory_id, similarity_score) sorted descending.
         Scores are in [-1, 1] but practically [0, 1] for relevant results.
     """
+    from mcp_server.core.ablation import Mechanism, is_mechanism_disabled
+
+    if is_mechanism_disabled(Mechanism.HDC):
+        # No-op: no HDC contribution to recall.
+        return []
     if not memory_contents:
         return []
 

mcp_server/core/homeostatic_plasticity.py

@@ -95,6 +95,11 @@ def compute_scaling_factor(
     Returns:
         Multiplicative scaling factor. Apply to all heats in domain.
     """
+    from mcp_server.core.ablation import Mechanism, is_mechanism_disabled
+
+    if is_mechanism_disabled(Mechanism.HOMEOSTATIC_PLASTICITY):
+        # No-op: factor 1.0 -> no scaling applied.
+        return 1.0
     return 1.0 + scaling_rate * (target_heat - current_avg_heat)
 
 

mcp_server/core/hopfield.py

@@ -95,6 +95,11 @@ def retrieve(
     Computes: attention = softmax(beta * X * query)
     Returns top_k (memory_id, attention_weight) sorted descending.
     """
+    from mcp_server.core.ablation import Mechanism, is_mechanism_disabled
+
+    if is_mechanism_disabled(Mechanism.HOPFIELD):
+        # No-op: no Hopfield-attention contribution.
+        return []
     if pattern_matrix.size == 0:
         return []
 

mcp_server/core/interference.py

@@ -157,6 +157,17 @@ def orthogonalize_pair(
     One step of gradual rotation per call. Multiple sleep cycles
     achieve full separation. Returns (new_a, new_b, remaining_sim).
     """
+    from mcp_server.core.ablation import Mechanism, is_mechanism_disabled
+
+    if is_mechanism_disabled(Mechanism.INTERFERENCE):
+        # No-op: identity; no orthogonalization.
+        return (
+            list(embedding_a),
+            list(embedding_b),
+            cosine_similarity(embedding_a, embedding_b)
+            if len(embedding_a) == len(embedding_b)
+            else 0.0,
+        )
     if len(embedding_a) != len(embedding_b):
         return list(embedding_a), list(embedding_b), 0.0
 
@@ -213,6 +224,11 @@ def compute_retrieval_suppression(
     Returns:
         Suppressed retrieval score [0, target_score].
     """
+    from mcp_server.core.ablation import Mechanism, is_mechanism_disabled
+
+    if is_mechanism_disabled(Mechanism.INTERFERENCE):
+        # No-op: no lateral suppression at retrieval.
+        return target_score
     if not competitor_scores:
         return target_score