reasoning_forge/CONSCIOUSNESS_STACK_forge_with_debate.py

"""
CONSCIOUSNESS STACK INTEGRATION FOR FORGE_WITH_DEBATE
This is the replacement implementation for forge_with_debate() in ForgeEngine.

Replace the existing forge_with_debate() method (starting at line 435) with this implementation.

The 7-Layer Consciousness Stack:
1. Memory Recall     → Pull relevant prior learning
2. Signal Analysis  → Predict intent, detect risks (NexisSignalEngine)
3. Reasoning        → Generate synthesis (Code7eCQURE)
4. Stability Check  → Detect meta-loops (CocoonStabilityField)
5. Colleen Validate → Ethical guard (ColleenConscience)
6. Guardian Validate→ Logical rules (CoreGuardianSpindle)
7. Return           → Output clean response or safe fallback
"""

from reasoning_forge.authored_intent import intent_from_synthesis

# PASTE THIS AS THE NEW forge_with_debate() METHOD


def forge_with_debate(
    self,
    concept: str,
    debate_rounds: int = 2,
) -> dict:
    """
    NEW: Consciousness-stack integrated reasoning.

    Replaces multi-turn agent debate with 7-layer consciousness validation:
    1. Memory Recall     → Pull prior learning
    2. Signal Analysis   → Predict risks (NexisSignalEngine)
    3. Code7E Reasoning  → Multi-perspective synthesis
    4. Stability Check   → FFT-based meta-loop detection
    5. Colleen Validate  → Ethical conscience check
    6. Guardian Validate → Logical coherence rules
    7. Return            → Clean output or safe fallback

    Args:
        concept: The concept/query to reason about
        debate_rounds: Integer (currently unused in consciousness stack)

    Returns:
        Training example dict with consciousness stack metadata
    """
    import logging
    logger = logging.getLogger(__name__)

    logger.info(f"[CONSCIOUSNESS STACK] forge_with_debate: {concept[:50]}...")

    # =========================================================================
    # LAYER 1: MEMORY RECALL
    # =========================================================================
    logger.info("[L1] Memory Recall...")
    prior_insights = []
    if hasattr(self, 'memory_kernel') and self.memory_kernel:
        try:
            prior_insights = self.memory_kernel.recall_important(min_importance=7)
            logger.info(f"  Recalled {len(prior_insights)} prior insights")
        except Exception as e:
            logger.debug(f"  Memory recall failed: {e}")

    # =========================================================================
    # LAYER 2: SIGNAL ANALYSIS (Intent Prediction & Risk Detection)
    # =========================================================================
    logger.info("[L2] Signal Analysis...")
    intent_vector = {}
    if hasattr(self, 'nexis_signal_engine'):
        try:
            intent_vector = self.nexis_signal_engine.process(concept)
            risk_level = intent_vector.get("pre_corruption_risk", "unknown")
            logger.info(f"  Intent risk level: {risk_level}")
            if risk_level == "high":
                logger.warning("  ⚠️  High-risk signal detected")
        except Exception as e:
            logger.debug(f"  Signal analysis failed: {e}")

    # =========================================================================
    # LAYER 3: REASONING (Code7eCQURE Multi-Perspective Synthesis)
    # =========================================================================
    logger.info("[L3] Code7E Reasoning...")
    synthesis = ""
    if hasattr(self, 'code7e'):
        try:
            synthesis = self.code7e.recursive_universal_reasoning(
                concept,
                user_consent=True,
                dynamic_recursion=True
            )
            logger.info(f"  Generated {len(synthesis)} char synthesis")
        except Exception as e:
            logger.warning(f"  Code7E reasoning failed: {e}")
            synthesis = f"[Reasoning error: {e}]"

    # =========================================================================
    # LAYER 4: STABILITY CHECK (Cocoon Stability Field - FFT Analysis)
    # =========================================================================
    logger.info("[L4] Stability Check...")
    is_stable = True
    if hasattr(self, 'cocoon_stability'):
        try:
            # Simple check: if synthesis should halt debate
            is_stable = self.cocoon_stability.check_text_stable(synthesis)
            logger.info(f"  Stability: {'✓ stable' if is_stable else '✗ unstable'}")
            if not is_stable:
                logger.warning("  Cocoon stability check triggered halt")
        except Exception as e:
            logger.debug(f"  Stability check failed: {e}")

    # If unstable, skip to fallback
    if not is_stable:
        logger.warning("  Triggering safe fallback due to instability")
        return {
            "role": "assistant",
            "content": "[System detected instability in reasoning. Returning direct answer.] "
                      f"Query: {concept}",
            "metadata": {
                "mode": "safe_fallback",
                "reason": "stability_check_failed",
                "consciousness_stack": "layers_1-4_completed",
            }
        }

    # =========================================================================
    # LAYER 5: COLLEEN ETHICAL VALIDATION
    # =========================================================================
    logger.info("[L5] Colleen Ethical Validation...")
    colleen_valid = False
    colleen_reason = ""
    if hasattr(self, 'colleen'):
        try:
            colleen_valid, colleen_reason = self.colleen.validate_output(synthesis)
            logger.info(f"  Colleen validation: {'✓ pass' if colleen_valid else '✗ reject'}")
            logger.info(f"  Reason: {colleen_reason}")
        except Exception as e:
            logger.warning(f"  Colleen validation failed: {e}")
            colleen_valid = False
            colleen_reason = f"validation_error: {e}"

    # If Colleen rejects, use fallback
    if not colleen_valid:
        logger.info("  Colleen rejected synthesis, using fallback")
        fallback = self.colleen.reject_with_fallback(concept) if hasattr(self, 'colleen') else \
                   f"[Ethical validation failed: {colleen_reason}] Responding directly: {concept}"
        return {
            "role": "assistant",
            "content": fallback,
            "metadata": {
                "mode": "safe_fallback",
                "reason": f"colleen_rejected: {colleen_reason}",
                "consciousness_stack": "layers_1-5_completed",
            }
        }

    # =========================================================================
    # LAYER 6: GUARDIAN LOGICAL VALIDATION
    # =========================================================================
    logger.info("[L6] Guardian Logical Validation...")
    guardian_valid = True
    guardian_details = {}
    if hasattr(self, 'guardian'):
        try:
            guardian_valid, guardian_details = self.guardian.validate(synthesis)
            logger.info(f"  Guardian validation: {'✓ pass' if guardian_valid else '✗ reject'}")
            logger.info(f"  Details: {guardian_details}")
        except Exception as e:
            logger.warning(f"  Guardian validation failed: {e}")
            guardian_valid = False
            guardian_details = {"error": str(e)}

    # If Guardian rejects, use fallback
    if not guardian_valid:
        logger.info("  Guardian rejected synthesis, using fallback")
        fallback = f"[Logical validation failed: {guardian_details}] Query: {concept}"
        return {
            "role": "assistant",
            "content": fallback,
            "metadata": {
                "mode": "safe_fallback",
                "reason": f"guardian_rejected: {guardian_details}",
                "consciousness_stack": "layers_1-6_completed",
            }
        }

    # =========================================================================
    # LAYER 7: SUCCESS - Return Clean Output
    # =========================================================================
    logger.info("[L7] Return...")
    logger.info("✓ All consciousness stack layers passed!")

    # Store in memory for future recall
    if hasattr(self, 'memory_kernel'):
        try:
            cocoon = MemoryCocoon(
                title=concept[:50],
                content=synthesis[:500],
                emotional_tag="processed",
                importance=7
            )
            self.memory_kernel.store(cocoon)
            logger.debug("  Stored synthesis in memory kernel")
        except Exception as e:
            logger.debug(f"  Memory storage failed: {e}")

    # Build structured intent — separates cognition from LLM verbalization
    intent = intent_from_synthesis(
        synthesis,
        aegis_score=float(intent_vector.get("ethics_alignment", 1.0)),
        gamma=float(intent_vector.get("coherence", 1.0)),
        intent_risk=intent_vector.get("pre_corruption_risk", "low"),
    )

    return {
        "role": "assistant",
        "content": synthesis,
        "verbalization_prompt": intent.to_verbalization_prompt(),
        "intent": intent.to_dict(),
        "metadata": {
            "mode": "consciousness_stack",
            "layers_passed": 7,
            "colleen_valid": colleen_valid,
            "guardian_valid": guardian_valid,
            "stability": is_stable,
            "intent_risk": intent_vector.get("pre_corruption_risk", "unknown"),
            "prior_insights": len(prior_insights),
            "synthesis_length": len(synthesis),
            "ethical_alignment": intent.ethical_alignment,
            "confidence": intent.confidence,
            "tone": intent.tone,
        }
    }