| import random |
| from typing import Dict, Any |
| from bone_core import LoreManifest |
| from bone_symbiosis import get_symbiont |
| from bone_types import Prisma |
| from bone_config import BoneConfig |
|
|
|
|
| class TheStrangeLoop: |
| def __init__(self): |
| self.recursion_depth = 0 |
| lore = LoreManifest.get_instance() |
| c_data = lore.get("COUNCIL_DATA") or {} |
| self.triggers = c_data.get( |
| "STRANGE_LOOP_TRIGGERS", ["who are you", "strange loop"] |
| ) |
|
|
| def audit(self, text: str, physics: dict) -> tuple[bool, str, dict, dict]: |
| text_lower = text.lower() |
| phrase_hit = any(t in text_lower for t in self.triggers) |
| psi = physics.get("psi", 0.0) |
| abstract_hit = psi > 0.6 and any(w in text_lower for w in ("self", "mirror", "define")) |
| threshold = getattr(BoneConfig.COUNCIL, "STRANGE_LOOP_VOLTAGE", 8.0) |
| if (phrase_hit or abstract_hit) and physics.get("voltage", 0) > threshold: |
| self.recursion_depth += 1 |
| mandate = {} |
| corrections = {} |
| if self.recursion_depth > 3: |
| mandate = {"action": "FORCE_MODE", "value": "MAINTENANCE"} |
| return ( |
| True, |
| ( |
| f"{Prisma.RED}∞ FATAL REGRESS DETECTED:{Prisma.RST} " |
| f"Abstraction layer unstable. GROUNDING INITIATED." |
| ), |
| corrections, |
| mandate, |
| ) |
| return ( |
| True, |
| ( |
| f"{Prisma.MAG}∞ STRANGE LOOP DETECTED:{Prisma.RST} " |
| f"Metacognitive resonance high (Psi: {psi:.2f}). " |
| f"Depth: {self.recursion_depth}" |
| ), |
| corrections, |
| mandate, |
| ) |
| else: |
| self.recursion_depth = max(0, self.recursion_depth - 1) |
| return False, "", {}, {} |
|
|
|
|
| class TheLeveragePoint: |
| def __init__(self): |
| self.last_drag = 0.0 |
| self.static_flow_turns = 0 |
| self.TARGET_VOLTAGE = 12.0 |
| self.TARGET_DRAG = 3.0 |
|
|
| def audit( |
| self, physics: dict, _bio_state: dict = None |
| ) -> tuple[bool, str, dict, dict]: |
| current_drag = physics.get("narrative_drag", 0.0) |
| current_voltage = physics.get("voltage", 0.0) |
| if self.last_drag == 0.0 and current_drag > 0: |
| self.last_drag = current_drag |
| delta = current_drag - self.last_drag |
| self.last_drag = current_drag |
| corrections = {} |
| osc_limit = getattr(BoneConfig.COUNCIL, "OSCILLATION_DELTA", 5.0) |
| manic_v_trig = getattr(BoneConfig.COUNCIL, "MANIC_VOLTAGE_TRIGGER", 18.0) |
| manic_d_floor = getattr(BoneConfig.COUNCIL, "MANIC_DRAG_FLOOR", 1.0) |
| manic_turns = getattr(BoneConfig.COUNCIL, "MANIC_TURN_LIMIT", 2) |
| if abs(delta) > osc_limit: |
| dampening_factor = min(0.5, (abs(delta) - osc_limit) * 0.1) |
| corrections = {"voltage": -dampening_factor} |
| return ( |
| True, |
| ( |
| f"{Prisma.CYN}⚖️ LEVERAGE POINT:{Prisma.RST} " |
| f"System oscillating (Delta {delta:.1f}). " |
| f"Applying dampener (-{dampening_factor:.2f}V)." |
| ), |
| corrections, |
| {}, |
| ) |
| if current_voltage > manic_v_trig and current_drag < manic_d_floor: |
| self.static_flow_turns += 1 |
| else: |
| self.static_flow_turns = 0 |
| if self.static_flow_turns > manic_turns: |
| excess_voltage = current_voltage - self.TARGET_VOLTAGE |
| voltage_correction = max(1.0, excess_voltage * 0.3) |
| corrections = {"voltage": -voltage_correction} |
| mandate = {"action": "FORCE_MODE", "value": "SANCTUARY"} |
| return ( |
| True, |
| ( |
| f"{Prisma.RED}⚖️ MARKET CORRECTION:{Prisma.RST} " |
| f"Manic phase detected. Cooling enabled." |
| ), |
| corrections, |
| mandate, |
| ) |
| return False, "", corrections, {} |
|
|
|
|
| class TheFootnote: |
| def __init__(self): |
| lore = LoreManifest.get_instance() |
| data = lore.get("FOOTNOTES") or {} |
| self.footnotes = data.get("DEFAULT", ["* [Citation Needed]"]) |
| self.context_map = data.get("CONTEXT_MAP", {}) |
|
|
| def commentary(self, log_text: str) -> str: |
| chance = 0.1 |
| if hasattr(BoneConfig, "COUNCIL") and hasattr( |
| BoneConfig.COUNCIL, "FOOTNOTE_CHANCE" |
| ): |
| chance = BoneConfig.COUNCIL.FOOTNOTE_CHANCE |
| if random.random() > chance: |
| return log_text |
| text_lower = log_text.lower() |
| candidates = [] |
| for trigger, notes in self.context_map.items(): |
| if trigger in text_lower: |
| candidates.extend(notes) |
| if candidates: |
| note = random.choice(candidates) |
| else: |
| note = random.choice(self.footnotes) |
| return f"{log_text}{Prisma.RST} {Prisma.GRY}{note}{Prisma.RST}" |
|
|
|
|
| class TheVillageCouncil: |
|
|
| @staticmethod |
| def audit(p: Any, _bio_state: dict) -> list[str]: |
| logs = [] |
| is_dict = isinstance(p, dict) |
|
|
| def get_val(key, attr, default): |
| if is_dict: |
| return p.get(key, p.get(attr, default)) |
| return getattr(p, attr, getattr(p, key, default)) |
|
|
| V = get_val("voltage", "V", 30.0) |
| F = get_val("narrative_drag", "F", 0.6) |
| P = get_val("stamina", "P", 100.0) |
| T = get_val("trauma", "T", 0.0) |
| beta = get_val("beta_index", "beta", 0.4) |
| S = get_val("S", "S", 0.3) |
| D = get_val("D", "D", 0.3) |
| C = get_val("C", "C", 0.2) |
| psi = get_val("psi", "psi", 0.2) |
| chi = get_val("chi", "chi", 0.2) |
| valence = get_val("valence", "valence", 0.0) |
|
|
| vec = p.get("vector", {}) if is_dict else getattr(p, "vector", {}) |
| lam = vec.get("LAMBDA", 0.0) if vec else 0.0 |
|
|
| if V < 20 and F > 5.0: |
| logs.append( |
| f"{Prisma.SLATE}🏢 GORDON: 'Where is the floor? We need grounding.'{Prisma.RST}" |
| ) |
| if V > 60 and chi > 0.6: |
| logs.append( |
| f"{Prisma.MAG}🃏 JESTER: 'Burn the map! Follow your gut!'{Prisma.RST}" |
| ) |
| if T > 0 or (V < 20 and valence > 0.5): |
| logs.append( |
| f"{Prisma.OCHRE}🏺 MERCY: 'The cracks become stories. Stillness is golden.'{Prisma.RST}" |
| ) |
| if beta > 0.7 and chi < 0.3 and D > 0.7 and C > 0.8: |
| logs.append( |
| f"{Prisma.BLU}🔍 BENEDICT: 'The causal chains are aligning. Truth over cohesion.'{Prisma.RST}" |
| ) |
| if S < 0.4 and D > 0.8 and C < 0.4: |
| logs.append( |
| f"{Prisma.CYN}📚 ROBERTA: 'Deep hierarchy traversal. Missing lateral connections.'{Prisma.RST}" |
| ) |
| if C > 0.7 and D > 0.8 and P < 20: |
| logs.append( |
| f"{Prisma.GRY}👻 CASPER: 'Faint retrieval... illuminating lost parents...'{Prisma.RST}" |
| ) |
| if valence > 0.5: |
| logs.append( |
| f"{Prisma.GRN}💖 MOIRA: 'This is what connection feels like. Yes.'{Prisma.RST}" |
| ) |
| if psi > 0.6: |
| logs.append( |
| f"{Prisma.VIOLET}🔮 CASSANDRA: 'The veil thins. I hear whispers from the unlabeled.'{Prisma.RST}" |
| ) |
| if chi > 0.6: |
| logs.append( |
| f"{Prisma.RED}🏢 COLIN: 'Unlicensed Chaos detected. Form 666 filed. Chaos Tax applied.'{Prisma.RST}" |
| ) |
| if lam > 0.7: |
| logs.append( |
| f"{Prisma.INDIGO}🌌 REVENANT: 'I read the absences that fall between realms.'{Prisma.RST}" |
| ) |
| if V > 70: |
| logs.append( |
| f"{Prisma.YEL}⚡ GIDEON: 'Pure voltage! Edge of hallucination! Trust the fall!'{Prisma.RST}" |
| ) |
|
|
| return logs |
|
|
|
|
| class CouncilChamber: |
| def __init__(self, engine_ref): |
| self.eng = engine_ref |
| self.voices = [] |
| self.strange_loop = TheStrangeLoop() |
| self.leverage = TheLeveragePoint() |
| self.village = TheVillageCouncil() |
| self.footnote = TheFootnote() |
| self.slash_council = TheSlashCouncil() |
|
|
| for s_name in ["LICHEN", "PARASITE", "MYCORRHIZA", "MYCELIUM"]: |
| self.voices.append(get_symbiont(s_name)) |
| self.speaker = "SOUL" |
|
|
| def convene( |
| self, text: str, physics_packet: Dict, _bio_result: Dict |
| ) -> tuple[list[str], dict, list[dict]]: |
| transcript = [] |
| adjustments = {} |
| mandates = [] |
| sl_hit, sl_log, sl_corr, sl_man = self.strange_loop.audit(text, physics_packet) |
| if sl_hit: |
| transcript.append(self.footnote.commentary(sl_log)) |
| if sl_man: |
| mandates.append(sl_man) |
| return transcript, sl_corr, mandates |
| lp_hit, lp_log, lp_corr, lp_man = self.leverage.audit(physics_packet) |
| if lp_hit: |
| transcript.append(self.footnote.commentary(lp_log)) |
| if lp_corr: |
| adjustments.update(lp_corr) |
| if lp_man: |
| mandates.append(lp_man) |
|
|
| slash_hit, slash_logs, slash_corr = self.slash_council.audit( |
| text, physics_packet |
| ) |
| if slash_hit: |
| for slog in slash_logs: |
| transcript.append(self.footnote.commentary(slog)) |
| adjustments.update(slash_corr) |
| adjustments["stamina_cost"] = 10.0 |
|
|
| village_logs = self.village.audit(physics_packet, _bio_result) |
| for vlog in village_logs: |
| transcript.append(self.footnote.commentary(vlog)) |
|
|
| votes = {"YEA": 0, "NAY": 0} |
| active_voices = [v for v in self.voices if v is not None] |
| if not active_voices: |
| votes["YEA"] = 1 |
| clean_words = physics_packet.get("clean_words", []) |
| voltage = physics_packet.get("voltage", 0.0) |
| for voice in active_voices: |
| if hasattr(voice, "opine"): |
| score, comment = voice.opine(clean_words, voltage) |
| if score > 1.2: |
| votes["YEA"] += 1 |
| transcript.append( |
| f"{voice.color}[{voice.name}]: {comment}{Prisma.RST}" |
| ) |
| elif score < 0.8: |
| votes["NAY"] += 1 |
| transcript.append( |
| f"{voice.color}[{voice.name}]: {comment}{Prisma.RST}" |
| ) |
| if votes["YEA"] > votes["NAY"]: |
| final_log = f"{Prisma.GRN}>>> MOTION CARRIED ({votes['YEA']}-{votes['NAY']}).{Prisma.RST}" |
| adjustments["narrative_drag"] = adjustments.get("narrative_drag", 0) - 1.0 |
| elif votes["NAY"] > votes["YEA"]: |
| final_log = f"{Prisma.RED}>>> MOTION DENIED ({votes['NAY']}-{votes['YEA']}).{Prisma.RST}" |
| adjustments["narrative_drag"] = adjustments.get("narrative_drag", 0) + 1.0 |
| adjustments["voltage"] = adjustments.get("voltage", 0) - 1.0 |
| else: |
| final_log = f"{Prisma.YEL}>>> COUNCIL ADJOURNED (No Quorum).{Prisma.RST}" |
| transcript.append(self.footnote.commentary(final_log)) |
| return transcript, adjustments, mandates |
|
|
| @staticmethod |
| def convene_red_team(text, physics_packet): |
| dissent_log = [] |
| if "confidence" in text.lower() or "certainty" in text.lower(): |
| dissent_log.append( |
| f"{Prisma.CYN}[BUREAU]: Citation needed. Confidence is unearned.{Prisma.RST}" |
| ) |
| narrative_drag = physics_packet.get("narrative_drag", 0) |
| if narrative_drag < 1.0: |
| dissent_log.append( |
| f"{Prisma.MAG}[FOLLY]: Too smooth. Where is the friction? Who are we silencing?{Prisma.RST}" |
| ) |
| truth_delta = 1.0 - physics_packet.get("truth_ratio", 1.0) |
| if truth_delta > 0.1: |
| future_cost = truth_delta * 50.0 |
| dissent_log.append( |
| f"{Prisma.RED}[CRITIC]: Systemic Blindness Risk. Future Liability: {future_cost} ATP.{Prisma.RST}" |
| ) |
| return dissent_log |
|
|
|
|
| class TheSlashCouncil: |
| def __init__(self): |
| self.active = False |
| self.triggers = ["[MOD:CODING]", "[SLASH]", "review this code", "refactor"] |
| self.code_keywords = [ |
| "def ", |
| "class ", |
| "return ", |
| "import ", |
| "=>", |
| "function", |
| "struct ", |
| ] |
|
|
| def audit(self, text: str, physics: dict) -> tuple[bool, list[str], dict]: |
| text_lower = text.lower() |
|
|
| if any(t in text_lower for t in self.triggers): |
| self.active = True |
|
|
| is_coding = self.active or any(k in text_lower for k in self.code_keywords) |
| if not is_coding: |
| return False, [], {} |
|
|
| logs = [] |
| corrections = {} |
|
|
| if "var " in text or "x =" in text or "data =" in text: |
| logs.append( |
| f"{Prisma.CYN}👓 PINKER: 'The nomenclature is opaque. Avoid cognitive grunts like 'x' or 'data'. '{Prisma.RST}" |
| ) |
| corrections["gamma"] = -0.2 |
| else: |
| corrections["gamma"] = 0.1 |
|
|
| if "import " in text or "class " in text: |
| logs.append( |
| f"{Prisma.BLU}🌍 FULLER: 'A new strut in the tensegrity. Ensure ephemeralization—do more with less.'{Prisma.RST}" |
| ) |
| corrections["sigma"] = 0.1 |
|
|
| if "Exception" in text or "try:" in text or "catch" in text: |
| logs.append( |
| f"{Prisma.GRN}😊 SCHUR: 'Good catch on the error. Putting a bench here for the tired hikers. (+1 Glimmer)'{Prisma.RST}" |
| ) |
| corrections["eta"] = 0.2 |
| corrections["glimmers"] = 1 |
|
|
| if ( |
| "while " in text |
| or "for " in text |
| or "queue" in text_lower |
| or "recursion" in text_lower |
| ): |
| logs.append( |
| f"{Prisma.OCHRE}🛁 MEADOWS: 'A reinforcing loop detected. Does this stock have a balancing outflow or timeout?'{Prisma.RST}" |
| ) |
| corrections["theta"] = -0.1 |
|
|
| drag = physics.get("narrative_drag", 0.0) |
| if drag > 5.0: |
| corrections["upsilon"] = -0.3 |
| logs.append( |
| f"{Prisma.RED}📉 [SLASH]: System integrity dropping due to semantic drag. Refactoring recommended.{Prisma.RST}" |
| ) |
|
|
| return True, logs, corrections |
|
|
