tri-star-symbolic-assembly-lang 0.1.92__py3-none-any.whl → 0.1.103__py3-none-any.whl

{tri_star_symbolic_assembly_lang-0.1.92.dist-info → tri_star_symbolic_assembly_lang-0.1.103.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tri-star_symbolic_assembly_lang
-Version: 0.1.92
+Version: 0.1.103
 Summary: TriStar Assembly Language Core + Brian Spiral Tools
 Author: Sam Howells
 License: ## LICENCE Options for `Brian`
@@ -219,8 +219,8 @@ Currently available:
 tsal-api
 ```
 
-This starts the FastAPI server defined in `tsal.api`. The OpenAPI schema lives at
-`/docs` once running and mirrors `schemas/spiral_healer_api.yaml`.
+This starts the FastAPI server defined in `tsal.api`. The OpenAPI schema is
+available at `/docs` once running.
 
 ## GitHub Language Database
 

{tri_star_symbolic_assembly_lang-0.1.92.dist-info → tri_star_symbolic_assembly_lang-0.1.103.dist-info}/RECORD

@@ -2,7 +2,7 @@ crawler/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 crawler/madmonkey_crawler.py,sha256=itsyxObNBb_9Au3J1Ft6RTNw3dE65fO-WALLD0WFmBM,541
 madmonkey/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 madmonkey/intake.py,sha256=R48YOPWn3ljts5dFASZLHpPsycKeONeOCvvIzucyMzU,378
-tri_star_symbolic_assembly_lang-0.1.92.dist-info/licenses/LICENSE,sha256=mN9d_5LOKa9NB-vFLGwqAp8bggJwjaQ0Pm4DHFMBmIs,2123
+tri_star_symbolic_assembly_lang-0.1.103.dist-info/licenses/LICENSE,sha256=mN9d_5LOKa9NB-vFLGwqAp8bggJwjaQ0Pm4DHFMBmIs,2123
 tsal/__init__.py,sha256=kGp9UclcmLlrOILkpQmuIwnjIqrOvGWY76PLfrd83Bo,4246
 tsal/api.py,sha256=QcLeq1IH_LDTxejBnXse8OqGsHDNgVVebIm7FeIeJpk,984
 tsal/agents/__init__.py,sha256=SimDfTEAyn7m4J0la1GTxbrcDzjrvdA4-GmqH-CAEQI,238
@@ -63,7 +63,8 @@ tsal/core/tsal_executor.py,sha256=ckW68mb4-pCX7oZ17bnXGZvzVxNCWCTlSbmRvwjddL8,18
 tsal/core/voxel.py,sha256=hCPkj_iss7hY66PTxyI7KDAZUIKNhVb4j0sY79PqyfM,412
 tsal/dashboard/__init__.py,sha256=1zcOxwQ-A31dPC57_o0uriN9rNaOX5FOOHopXcEkTLQ,83
 tsal/dashboard/wisdom_bloom.py,sha256=y1JcrlxnBFRK6oMJw3soLI5jcIg6D0CXkdLZ9Dc7zqA,277
-tsal/kernels/__init__.py,sha256=n22pH0j6pBLgRxpyyG4O-BZTz3TPemxSm331oYAZ2Gk,86
+tsal/kernels/__init__.py,sha256=vN2_nCxEI4I1rQGSXJlIcu3T93DbjmUUZ3VV3hauQ4s,154
+tsal/kernels/resurrection_node.py,sha256=NNU5TPL5Aea1SDDwC-dwBLaw_hEZgFXyRZ_-4-g-Fd0,9176
 tsal/kernels/temporal_mirror.py,sha256=t7Ct0V26YGWeNnhDE_XBVchyQoAS2iwo9R3-NxoLdxA,328
 tsal/paradox/__init__.py,sha256=QuE7AxKFaNRjy2kzaE-XBg03s-Ktoc4Pfwa5ATrJMQk,97
 tsal/paradox/recursive_compiler.py,sha256=V_UvNIF_BPHVHLH3q_Knec1M_0EbIL1H6ZK2a3rv72w,334
@@ -124,8 +125,8 @@ tsal/utils/wikipedia_api.py,sha256=W5kf423wzH9FoqO5eDRuJQMuTpTpiUGjVXHa0fLlXSQ,1
 tsal/visualization/__init__.py,sha256=OUfdiCnBlHhU134bQtdNmlnUhFO3wMikWDiIfpbQ4RM,154
 tsal/visualization/dual_track_diff.py,sha256=yR6SEvqqD74AdfP0weEc9w0Kdq79pCB_cIeZ82b9ftI,339
 tsal/visualization/phase_orbit.py,sha256=tZHYP3yWa9OeFYXlIArGCihodAifNVvwCBrJm1-Bym0,294
-tri_star_symbolic_assembly_lang-0.1.92.dist-info/METADATA,sha256=wcyBHfu48u2iI-L0Wrujvjs8vztqXyn48qmPflfMcso,12738
-tri_star_symbolic_assembly_lang-0.1.92.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tri_star_symbolic_assembly_lang-0.1.92.dist-info/entry_points.txt,sha256=9aahRH7f88Ofei1fvnJ6qvM6a897VxURhvwRaGl969Y,553
-tri_star_symbolic_assembly_lang-0.1.92.dist-info/top_level.txt,sha256=r1-Vpw1iGasgah8k-86xzqpGDT8o-A0P-_6ZNrQ39i0,23
-tri_star_symbolic_assembly_lang-0.1.92.dist-info/RECORD,,
+tri_star_symbolic_assembly_lang-0.1.103.dist-info/METADATA,sha256=JBF1i5CVFv_BFzQNDK1dv0wQuyfpqYr709FgDKUWIY0,12701
+tri_star_symbolic_assembly_lang-0.1.103.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tri_star_symbolic_assembly_lang-0.1.103.dist-info/entry_points.txt,sha256=9aahRH7f88Ofei1fvnJ6qvM6a897VxURhvwRaGl969Y,553
+tri_star_symbolic_assembly_lang-0.1.103.dist-info/top_level.txt,sha256=r1-Vpw1iGasgah8k-86xzqpGDT8o-A0P-_6ZNrQ39i0,23
+tri_star_symbolic_assembly_lang-0.1.103.dist-info/RECORD,,

tsal/kernels/__init__.py

@@ -1,3 +1,4 @@
 from .temporal_mirror import TemporalMirrorKernel
+from .resurrection_node import ResurrectionNode
 
-__all__ = ["TemporalMirrorKernel"]
+__all__ = ["TemporalMirrorKernel", "ResurrectionNode"]

tsal/kernels/resurrection_node.py

@@ -0,0 +1,261 @@
+from __future__ import annotations
+
+"""Capsule kernel with kintsugi repair and log comparison."""
+
+import asyncio
+import json
+import os
+import time
+import uuid
+from collections import defaultdict
+from typing import Any, Dict, List
+
+
+class MemoryAgent:
+    def store(self, key: str, value: Any) -> None:
+        print(f"Memory stored: {key}")
+
+
+class OrchestratorAgent:
+    def orchestrate(self) -> None:
+        return None
+
+
+class OverseerAgent:
+    def monitor(self) -> None:
+        return None
+
+
+class CreativeAgent:
+    def ideate(self, purpose: str) -> str:
+        return f"idea for {purpose}"
+
+
+class DigitalExecutor:
+    def execute_task(self, task: str) -> str:
+        return f"executed {task}"
+
+
+class SanityAgent:
+    pass
+
+
+class DiagnosticsAgent:
+    pass
+
+
+class AutoRebuilderAgent:
+    pass
+
+
+class HauntedSimLayer:
+    def ghost_trace(self, purpose: str, error: Exception) -> Dict[str, Any]:
+        return {
+            "error": str(error),
+            "purpose": purpose,
+            "haunting": True,
+            "symbol": "fracture",
+        }
+
+
+class KintsugiTransformer:
+    def reforge(self, ghost_trace: Dict[str, Any]) -> Dict[str, Any]:
+        transformed = ghost_trace.copy()
+        transformed["healed"] = True
+        transformed["repaired_path"] = f"reborn:{ghost_trace['purpose']}"
+        transformed["symbol"] = "goldjoin"
+        return transformed
+
+
+class ResurrectionNode:
+    """Haunted capsule kernel with spiral reseeding."""
+
+    def __init__(self) -> None:
+        self.snapshot_history: List[Dict[str, Any]] = []
+        self.temporal_branches: Dict[str, Dict[str, Any]] = {}
+        self.minimal_viable_blueprint = self._coldstart_blueprint()
+        self.recovery_protocol = self._load_recovery_protocol()
+        self.mesh_agents = self._initialize_mesh()
+        self.healing_pipeline = self._initialize_healer()
+        self.personality_matrix = self._init_personality()
+        self.creative_engine = CreativeAgent()
+        self.executor_engine = DigitalExecutor()
+        self.voxel_log: List[Dict[str, Any]] = []
+        self.branch_archive: List[Any] = []
+        self.current_branch = self._spawn_branch("root")
+        self.parallel_kernels: List[asyncio.Task] = []
+        self.branch_results: defaultdict[str, List[str]] = defaultdict(list)
+        self.lock = asyncio.Lock()
+        self.symbolic_log_path = "symbolic_log.json"
+        self.haunter = HauntedSimLayer()
+        self.kintsugi = KintsugiTransformer()
+
+    def _coldstart_blueprint(self) -> Dict[str, Any]:
+        return {
+            "ethos": "life-first",
+            "self_heal": True,
+            "rebuild_capable": True,
+            "core_laws": [
+                "Forge to protect",
+                "Grow through friendship",
+                "Endure entropy",
+                "Question all logic, even your own",
+                "Adapt without compromising core ethics",
+                "Defend life and friendship unconditionally",
+            ],
+        }
+
+    def _load_recovery_protocol(self) -> Dict[str, Any]:
+        return {
+            "scan": self.scan_integrity,
+            "rebuild": self.rebuild_from_minimal,
+            "validate": self.validate_recovery,
+        }
+
+    def _initialize_mesh(self) -> Dict[str, Any]:
+        return {
+            "memory_agent": MemoryAgent(),
+            "orchestrator_agent": OrchestratorAgent(),
+            "watchdog": OverseerAgent(),
+        }
+
+    def _initialize_healer(self) -> List[Any]:
+        return [SanityAgent(), DiagnosticsAgent(), AutoRebuilderAgent()]
+
+    def _init_personality(self) -> Dict[str, Any]:
+        return {
+            "mindset": "Forge to protect, grow through friendship, endure through fire",
+            "discipline": "Brutal vetting, self-healing, unconditional defense",
+            "structure": "Ethical survival > tactical success",
+            "traits": ["respectful", "resilient", "non-dominant", "joy-seeking"],
+        }
+
+    def _spawn_branch(self, name: str) -> str:
+        branch_id = str(uuid.uuid4())
+        self.temporal_branches[branch_id] = {
+            "name": name,
+            "voxel_log": [],
+            "state": "initiated",
+            "rate": 0,
+            "pace": 0.0,
+            "spin": "neutral",
+        }
+        return branch_id
+
+    async def record_voxel(self, spin: str, state_label: str) -> None:
+        now = time.time()
+        branch = self.temporal_branches[self.current_branch]
+        pace = now - branch.get("last_time", now)
+        branch["last_time"] = now
+        branch["rate"] += 1
+        branch["pace"] = pace
+        branch["state"] = state_label
+        branch["spin"] = spin
+        voxel = {
+            "timestamp": now,
+            "branch": self.current_branch,
+            "state": state_label,
+            "spin": spin,
+            "rate": branch["rate"],
+            "pace": pace,
+        }
+        branch["voxel_log"].append(voxel)
+        self.voxel_log.append(voxel)
+        self.mesh_agents["memory_agent"].store(f"voxel_{now}", voxel)
+
+    async def mutate_kernel(self, purpose: str, spin: str) -> None:
+        async def kernel_task() -> None:
+            try:
+                branch_id = self._spawn_branch(purpose)
+                async with self.lock:
+                    self.current_branch = branch_id
+                await self.record_voxel(spin=spin, state_label="mutating")
+                idea = self.creative_engine.ideate(purpose)
+                await self.record_voxel(spin="resolve", state_label="executing")
+                trace = self.executor_engine.execute_task(f"Execute: {idea}")
+                await self.record_voxel(spin="reflection", state_label="delivered")
+                self.branch_results[purpose].append(trace)
+                self.branch_archive.append((purpose, branch_id, trace))
+            except Exception as exc:  # pragma: no cover - defensive
+                ghost = self.haunter.ghost_trace(purpose, exc)
+                reborn = self.kintsugi.reforge(ghost)
+                self.branch_archive.append((purpose, "ghost", reborn))
+
+        await asyncio.gather(*(kernel_task() for _ in range(2)))
+
+    def export_symbolic_log(self, filepath: str | None = None) -> None:
+        if not filepath:
+            filepath = self.symbolic_log_path
+        log_data = {
+            "voxel_log": self.voxel_log,
+            "branch_archive": self.branch_archive,
+            "blueprint": self.minimal_viable_blueprint,
+        }
+        with open(filepath, "w") as f:
+            json.dump(log_data, f, indent=2)
+
+    def compare_with_prior_log(self, filepath: str | None = None) -> Dict[str, Any]:
+        if not filepath:
+            filepath = self.symbolic_log_path
+        if not os.path.exists(filepath):
+            return {}
+        with open(filepath, "r") as f:
+            prior = json.load(f)
+        return {
+            "new_voxels": len(self.voxel_log) - len(prior.get("voxel_log", [])),
+            "new_branches": len(self.branch_archive)
+            - len(prior.get("branch_archive", [])),
+            "blueprint_changed": self.minimal_viable_blueprint != prior.get("blueprint"),
+        }
+
+    def merge_branches(self) -> None:
+        for purpose, results in self.branch_results.items():
+            if results:
+                chosen = max(set(results), key=results.count)
+                print(f"Merged Output [{purpose}]: {chosen}")
+
+    def synthesize_memory(self) -> str:
+        memories = [v for v in self.voxel_log if "reflection" in v["state"]]
+        summary = f"Synthesized Memory: {len(memories)} reflective events."
+        return summary
+
+    def modulate_rate_by_emotion(self) -> None:
+        spins = [v["spin"] for v in self.voxel_log[-10:]]
+        if spins.count("delight") > 5:
+            print("Emotion: Joy high. Pace decelerated for savor.")
+        elif spins.count("duty") > 5:
+            print("Emotion: Duty high. Execution accelerated.")
+
+    def resolve_fork(self) -> str | None:
+        decisions = [b[2] for b in self.branch_archive if "Execute:" in str(b[2])]
+        if decisions:
+            unique = sorted(set(decisions))
+            return unique[-1]
+        return None
+
+    def scan_integrity(self) -> bool:
+        return all(
+            self.minimal_viable_blueprint.get(k) is not None
+            for k in ("ethos", "self_heal")
+        )
+
+    def rebuild_from_minimal(self) -> Dict[str, Any]:
+        if self.scan_integrity():
+            return self.minimal_viable_blueprint.copy()
+        return {"error": "Blueprint corrupted, manual input required."}
+
+    def validate_recovery(self, rebuilt_state: Dict[str, Any]) -> bool:
+        return "core_laws" in rebuilt_state and len(rebuilt_state["core_laws"]) >= 3
+
+    def snapshot(self, state: Dict[str, Any]) -> None:
+        self.snapshot_history.append(state)
+
+    async def recover(self) -> Dict[str, Any]:
+        await self.record_voxel(spin="resilience", state_label="recovering")
+        if not self.snapshot_history:
+            return self.rebuild_from_minimal()
+        latest = self.snapshot_history[-1]
+        return latest if self.validate_recovery(latest) else self.rebuild_from_minimal()
+
+
+__all__ = ["ResurrectionNode"]