tri-star-symbolic-assembly-lang 0.1.0__py3-none-any.whl → 0.1.1__py3-none-any.whl

{tri_star_symbolic_assembly_lang-0.1.0.dist-info → tri_star_symbolic_assembly_lang-0.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tri-star_symbolic_assembly_lang
-Version: 0.1.0
+Version: 0.1.1
 Summary: TriStar Assembly Language Core + Brian Spiral Tools
 Author: Sam Howells
 License: ## LICENCE Options for `Brian`
@@ -93,6 +93,8 @@ Zero hour recap: φ constants, 4‑vector model and minimal toolkit live in
 See [docs/AGENTS.md](docs/AGENTS.md) for the hard rules.
 For a quick explanation of the repo's symbolic sandbox design, see
 [docs/symbolic_containerization_prompt.md](docs/symbolic_containerization_prompt.md).
+Design session logs live in
+[memory/memory__2025-06-09__codex_fireproof_spiral_guardian_log.md](memory/memory__2025-06-09__codex_fireproof_spiral_guardian_log.md).
 
 | Tool | Spiral audit |
 |------|--------------|
@@ -308,6 +310,17 @@ ee.validate("share knowledge")  # permitted
 ee.validate("force reboot")     # raises ValueError
 ```
 
+## Core Constants
+
+```
+PERCEPTION_THRESHOLD = 0.75
+LEARNING_RATE = 0.05
+CONNECTION_DECAY = 0.01
+MAX_NODES = 8192
+MAX_AGENTS = 1024
+MAX_DIMENSIONS = 8
+```
+
 ## Engine Now Running
 
 To run spiral code repair, invoke the command line interface:

{tri_star_symbolic_assembly_lang-0.1.0.dist-info → tri_star_symbolic_assembly_lang-0.1.1.dist-info}/RECORD

@@ -2,10 +2,12 @@ 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.0.dist-info/licenses/LICENSE,sha256=mN9d_5LOKa9NB-vFLGwqAp8bggJwjaQ0Pm4DHFMBmIs,2123
-tsal/__init__.py,sha256=Bn6MRjwpAc07O9Fcnr2FmzeVG0btw3iH49wGCiqS1xI,2732
+tri_star_symbolic_assembly_lang-0.1.1.dist-info/licenses/LICENSE,sha256=mN9d_5LOKa9NB-vFLGwqAp8bggJwjaQ0Pm4DHFMBmIs,2123
+tsal/__init__.py,sha256=vstGaTBj_Ss0-NKInAkTN5YGn5NmOPnRzn1tocwwYT4,2956
+tsal/agents/__init__.py,sha256=a3HUdwlTN8d0ripzeftDXuG--R0uA964Rz1tx4EslIs,133
+tsal/agents/priority_research_team.py,sha256=cHaG52YeApAa9Z7H9fCHtQTF0LgEHTy3azqldnJ58yE,1330
 tsal/audit/__init__.py,sha256=IR7ChTMT0qkKzkPJeNoSUCR8JMe0yuLFZLQg2CymEd8,225
-tsal/audit/brian_self_audit.py,sha256=XECrFzNe-c_R9dP32ocLs7RoMWuca0_BgC1kqcFders,3869
+tsal/audit/brian_self_audit.py,sha256=T1gwmk7Oc5JUojz3ADN3v0_mD0EpW7A9rSLBioQqVcQ,2831
 tsal/cli/__init__.py,sha256=yXxgg1pJwR1g7Ogt2hkry7fwbAed7nR8BM2sPuxjxfA,26
 tsal/cli/beast.py,sha256=d5oN2Z9iF7kipHc05ftjwHYndaIdF1PB4m6MoZd9Nqo,96
 tsal/cli/brian.py,sha256=Lgefn5v3FJmM8mkF0D30e8U_-uR88ewtWfFBbmloU7E,83
@@ -14,32 +16,41 @@ tsal/cli/meshkeeper.py,sha256=SaFwJZCtdoFdeRPR-bNd_8smfoAhippmKT50UPggN4k,78
 tsal/cli/party.py,sha256=QCjLiVDfWi2OO0yVYIxQwYiXYsfchP_1Sz0u5UxjqMA,80
 tsal/cli/reflect.py,sha256=Yw_Uzz-9NZ8hnT7NbAyhDoalyJQkN9z7Z4xg9ScsvK4,75
 tsal/cli/watchdog.py,sha256=WqpwcMw14DJ8lILghzh24j7cqIlyiqQ2UaLGfcPsaa4,76
-tsal/core/__init__.py,sha256=f_NFsd2ZGhCHjRIaHU1FZ-tCUCEdE6cecqKcjddHpu8,1647
+tsal/core/__init__.py,sha256=qdbvtnse-XpQNRVEOG_JZXHxe9aAGE4Uw2gSYAQK1UY,2256
 tsal/core/connectivity.py,sha256=JE9w1rTXNyLlKVZBdW5yIvCm0zPQr7wTgSy1-R7UsNM,886
 tsal/core/constants.py,sha256=DVQNLdv_MOQUoH6D_ZqOmW9rg9671rvJ-VgxBg3n0xc,565
+tsal/core/entangle.py,sha256=gYNSUJhaSXsAgHtDrAcKJN6uJy4XwrjVRwUnTHXFE0Q,515
 tsal/core/ethics_engine.py,sha256=GyZnZXozMSiL9mr7aW7OrGllRnIlrD11p6nx2Xg02f0,1573
 tsal/core/executor.py,sha256=ILiR3x_qJNOjG2LlPAJlOUM5gZJZdXq8pnQ3UvwqgGo,1958
+tsal/core/gradient.py,sha256=DOBn-TBbrRO-G3P7dQccCcrhRj17UWeZTvHVyl3t5KU,381
+tsal/core/guardian_constants.py,sha256=Tw2Ze-Ga7rOqjFAU2RJcVHoid8iGrTXhGYSkLB3KJVk,380
 tsal/core/intent_metric.py,sha256=mGqUODE4VhNbUooHkmA3n84CFwvdJOYazrhjkSKPvaw,524
 tsal/core/json_dsl.py,sha256=9j6aZ3QbpKFDOjtIxjoVeHa2SrYHXuYLkCW62YkM4QU,1579
 tsal/core/logic_gate.py,sha256=-SSLPe5r6-CbOA1RBCOX8xlys-cm71aSi9Fd9D8qJWk,1887
 tsal/core/madmonkey_handler.py,sha256=ggkCVIpog4wbHNrRNZDqhFxF8yArOS-TbT4qVCFQR_0,279
+tsal/core/manifold.py,sha256=6I7KUDwomDZ9nAY7_s5V3wi0R6aDcZS9TJH4FtPA4K0,422
+tsal/core/merge.py,sha256=SpZ_dDzjIDABBEAJSBpqHOWI4iMiZwv00bnVkXXBO-s,476
 tsal/core/mesh_logger.py,sha256=NO8zoeDOxDTEFm5FKECXNyxSM4Rp_XSiHw4FR3F2Edw,817
-tsal/core/module_registry.py,sha256=KoMvbE14FqJjpCYOE_1c8u5PYnE8ExPs2wKPzrVedOA,4335
+tsal/core/mesh_ops.py,sha256=4znQ3BQ1IGaVo7_TWbfXEa7p96xnlvyIqzKFu9EAl_Q,915
+tsal/core/module_registry.py,sha256=vfDtsbwt8XygWsHIJ-B-mZ-xrQekJhFfj9vbmYgawKY,7449
+tsal/core/oaths.py,sha256=NVDLbyEZUaHx918SyOllfnUo_HDoDszZK99vOs1kI3s,709
 tsal/core/optimizer_utils.py,sha256=QovazST91zXH0kquUg1U_uvZmL59eKYv8BzCkw-F4WU,2263
 tsal/core/opwords.py,sha256=Ur6y7Dw4KSDYsICpr22L5NKwrmaIK1X7psh8OsqMRMc,2529
 tsal/core/phase_math.py,sha256=YI6CxHCwNstWF-2xxYGN6F51lHkgD5QJfADlgKLkCrY,8356
 tsal/core/phi_math.py,sha256=uJ0NCvX83BKUHZxrIAW57HTQzOOZxXI-8i1iwX37K24,1340
 tsal/core/reflection.py,sha256=VFqb-gQqdw-ks8j0fjzMKsl0p0LFGFnopU9unZ2dduo,3070
 tsal/core/rev_eng.py,sha256=Sxxf0dUfcWB9lliMB8MQCLrMzse8Uod00sD1SfeLa7c,6355
+tsal/core/shadow.py,sha256=xC8uf078efyP-3Y-ZHOy73uL-Xj4T0iYaXZccKA2i9A,600
 tsal/core/spark_translator.py,sha256=SaXiQa1hkyyi6SRsHbfOFxiSjuZOXVbEAXjBDv5JNiU,1478
 tsal/core/spiral_fusion.py,sha256=vvNLoYpPhoX6CEoFd2cma2g0DhP7KzbA0Cp8W2HUWCs,1548
 tsal/core/spiral_memory.py,sha256=9i39JRZvMyRtRdzY4UHE3_RIiuW-XZOkQ0dAzPKldGs,561
 tsal/core/spiral_vector.py,sha256=J6G4Fx52XiSwVw-Zb7ZQ9mMn82MvwEFEANP1_eFKu8k,1183
-tsal/core/stack_vm.py,sha256=7-nwqMFYlCbVrgASoBpEpBui_SlBB4-3XiRShgKH7nQ,1374
+tsal/core/stack_vm.py,sha256=mHNiSbpWqHQFCcaeMvYuQIxOylZHqu3gQNYTJckU09s,2190
 tsal/core/state_vector.py,sha256=b7vq0Fm2kHGVrd2OgSWZjr3W5Yl0o4wl2ueY78ea7I4,1096
+tsal/core/superpos.py,sha256=hNkib-eXIS9J3jvVR2ILY40_ulBUV1FtrXbvCChBpPY,487
 tsal/core/symbols.py,sha256=Cxi4v0Z2Rotn4lmng6L_6Zm1BYY5y1Pj_9a6P1ocVA0,1926
 tsal/core/tokenize_flowchart.py,sha256=LvjtAVq0LXUXEUZLelNKg6xW3w6BrFPSJHD9HgRSHz8,963
-tsal/core/tsal_executor.py,sha256=ljV7c6fqTO_oKl-cDYX8jCQPeKkkmj10S2U5i-Gme6Y,18770
+tsal/core/tsal_executor.py,sha256=NYaKn7kib_qiHpjOulz2CeEvAcUYccRV0LartcKG40w,18060
 tsal/core/voxel.py,sha256=hCPkj_iss7hY66PTxyI7KDAZUIKNhVb4j0sY79PqyfM,412
 tsal/renderer/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tsal/renderer/code_render.py,sha256=oZl_ufeFEXn1Gjd1AKrYCR7lpySmjgAy2dTyvZbnAk0,422
@@ -82,8 +93,8 @@ tsal/utils/language_db.py,sha256=mw8gVeMK4I6Z0QeQHNAfHYTriAeDfhVVmB911oFdPqM,151
 tsal/utils/octopus_api.py,sha256=1JrhYjbbAbN1-bkCAiInuUNh8bb7EJxB4SHh3Fwq3qs,1315
 tsal/utils/system_status.py,sha256=cHjG3Ow4YJADYJY383_OdEMEiJAngxyq01z0ADCzV4s,1054
 tsal/utils/wikipedia_api.py,sha256=W5kf423wzH9FoqO5eDRuJQMuTpTpiUGjVXHa0fLlXSQ,1303
-tri_star_symbolic_assembly_lang-0.1.0.dist-info/METADATA,sha256=rt9gtygQc0KGpI_Gcbm8G6xpVCMhrbz7td3Hszaxie0,13081
-tri_star_symbolic_assembly_lang-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-tri_star_symbolic_assembly_lang-0.1.0.dist-info/entry_points.txt,sha256=O8cY2PLbPf53e8gNbI8lFqupalxXYgrnex0eNtvvaNw,426
-tri_star_symbolic_assembly_lang-0.1.0.dist-info/top_level.txt,sha256=r1-Vpw1iGasgah8k-86xzqpGDT8o-A0P-_6ZNrQ39i0,23
-tri_star_symbolic_assembly_lang-0.1.0.dist-info/RECORD,,
+tri_star_symbolic_assembly_lang-0.1.1.dist-info/METADATA,sha256=bGdAe2KDPB1RaE2Sh9kau8zGZ5dtl2E2ARjebREK7KM,13400
+tri_star_symbolic_assembly_lang-0.1.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+tri_star_symbolic_assembly_lang-0.1.1.dist-info/entry_points.txt,sha256=O8cY2PLbPf53e8gNbI8lFqupalxXYgrnex0eNtvvaNw,426
+tri_star_symbolic_assembly_lang-0.1.1.dist-info/top_level.txt,sha256=r1-Vpw1iGasgah8k-86xzqpGDT8o-A0P-_6ZNrQ39i0,23
+tri_star_symbolic_assembly_lang-0.1.1.dist-info/RECORD,,

tsal/__init__.py

@@ -30,6 +30,7 @@ from .core.stack_vm import (
 from .renderer.code_render import mesh_to_python
 from .tristar.handshake import handshake as tristar_handshake
 from .tristar.governor import MetaAgent, TriStarGovernor
+from .agents import PriorityResearchTeamAgent, ThreatReport
 from .utils.github_api import fetch_repo_files, fetch_languages
 from .tools.feedback_ingest import categorize, Feedback
 from .tools.alignment_guard import is_aligned, Change
@@ -37,6 +38,7 @@ from .tools.goal_selector import Goal, score_goals
 from .tools.spiral_audit import audit_path
 from .tools.reflect import reflect
 from .core.constants import AXIS_ZERO, ensure_spin_axis, UndefinedPhaseError
+from .core.oaths import GUARDIAN_OATH, ARC_REACTOR_BOOT_OATH
 
 PHI = 1.618033988749895
 PHI_INV = 0.618033988749895
@@ -81,6 +83,8 @@ __all__ = [
     "tristar_handshake",
     "MetaAgent",
     "TriStarGovernor",
+    "PriorityResearchTeamAgent",
+    "ThreatReport",
     "categorize",
     "Feedback",
     "is_aligned",
@@ -92,4 +96,6 @@ __all__ = [
     "AXIS_ZERO",
     "ensure_spin_axis",
     "UndefinedPhaseError",
+    "GUARDIAN_OATH",
+    "ARC_REACTOR_BOOT_OATH",
 ]

tsal/agents/__init__.py

@@ -0,0 +1,3 @@
+from .priority_research_team import PriorityResearchTeamAgent, ThreatReport
+
+__all__ = ["PriorityResearchTeamAgent", "ThreatReport"]

tsal/agents/priority_research_team.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List
+
+from ..tristar.governor import TriStarGovernor
+from ..core.tsal_executor import TSALExecutor
+from ..tools.issue_agent import create_issue, handle_http_error
+
+
+@dataclass
+class ThreatReport:
+    anomalies: List[str]
+    resonance: float
+    entropy: int
+    health: int
+
+
+@dataclass
+class PriorityResearchTeamAgent:
+    repo: str
+    token: str | None = None
+    governor: TriStarGovernor = field(default_factory=TriStarGovernor)
+    log: List[ThreatReport] = field(default_factory=list)
+
+    def scan(self, executor: TSALExecutor) -> ThreatReport:
+        anomalies = self.governor.patrol(executor)
+        report = ThreatReport(
+            anomalies=anomalies,
+            resonance=executor._calculate_mesh_resonance(),
+            entropy=executor.meta_agent.entropy,
+            health=executor.meta_agent.health,
+        )
+        self.log.append(report)
+        if anomalies and self.token:
+            msg = f"{anomalies} | resonance={report.resonance:.3f}"
+            try:
+                create_issue(self.repo, "Threat detected", msg, self.token)
+            except Exception as exc:  # pragma: no cover - network faults
+                handle_http_error(self.repo, exc, msg, token=self.token)
+        return report

tsal/audit/brian_self_audit.py

@@ -1,5 +1,4 @@
 from pathlib import Path
-from tsal.core.spiral_vector import SpiralVector
 import argparse
 import sys
 from tsal.core.rev_eng import Rev_Eng
@@ -13,32 +12,6 @@ def optimize_spiral_order(vectors: list[SpiralVector]) -> list[SpiralVector]:
     """Return ``vectors`` sorted by φ-alignment."""
     return spiral_optimize(vectors)
 
-def brian_repairs_brian(
-    base: Path | str = Path("src/tsal"), safe: bool = False
-) -> list[str]:
-    """Run ``analyze_and_repair`` on every Python file under ``base``."""
-
-    print("🧠 Initiating self-audit and repair sequence…")
-    repaired: list[str] = []
-    base_path = Path(base)
-    for file in base_path.rglob("*.py"):
-        repaired.extend(analyze_and_repair(file, repair=not safe))
-    rev.log_event("Self-audit complete", state="repair", spin="φ")
-    return repaired
-
-def brian_improves_brian(
-    base: Path | str = Path("src/tsal"), safe: bool = False
-) -> list[str]:
-    """Run repair cycle under ``base`` and log the event."""
-
-    print("🧠 Evaluating improvements post-repair...")
-    suggestions = brian_repairs_brian(base=base, safe=safe)
-    rev.log_event("Improvement loop triggered", state="optimize", spin="up")
-    return suggestions
-
-def optimize_spiral_order(vectors: list[SpiralVector]) -> list[SpiralVector]:
-    return spiral_optimize(vectors)
-
 def brian_repairs_brian(
     base: Path | str = Path("src/tsal"), safe: bool = False
 ):

tsal/core/__init__.py

@@ -25,7 +25,21 @@ from .madmonkey_handler import MadMonkeyHandler
 from .connectivity import Node, verify_connectivity
 from .logic_gate import DynamicLogicGate
 from .module_registry import registry as module_registry, ModuleMeta
+from .shadow import ShadowMemory
+from .merge import merge_voxels
+from .gradient import voxel_gradient
+from .superpos import superpose
+from .entangle import entangle
+from .manifold import manifold_distance
 from .reflection import ReflectionLog, mood_from_traits
+from .guardian_constants import (
+    PERCEPTION_THRESHOLD,
+    LEARNING_RATE,
+    CONNECTION_DECAY,
+    MAX_NODES,
+    MAX_AGENTS,
+    MAX_DIMENSIONS,
+)
 
 __all__ = [
     "Rev_Eng",
@@ -55,6 +69,18 @@ __all__ = [
     "DynamicLogicGate",
     "module_registry",
     "ModuleMeta",
+    "ShadowMemory",
+    "merge_voxels",
+    "voxel_gradient",
+    "superpose",
+    "entangle",
+    "manifold_distance",
     "ReflectionLog",
     "mood_from_traits",
+    "PERCEPTION_THRESHOLD",
+    "LEARNING_RATE",
+    "CONNECTION_DECAY",
+    "MAX_NODES",
+    "MAX_AGENTS",
+    "MAX_DIMENSIONS",
 ]

tsal/core/entangle.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+"""Voxel entanglement utilities."""
+
+from .voxel import MeshVoxel
+
+
+def entangle(a: MeshVoxel, b: MeshVoxel) -> None:
+    """Couple two voxels by averaging their components."""
+    avg_pace = (a.pace + b.pace) / 2
+    avg_rate = (a.rate + b.rate) / 2
+    avg_state = (a.state + b.state) / 2
+    avg_spin = (a.spin + b.spin) / 2
+    a.pace = b.pace = avg_pace
+    a.rate = b.rate = avg_rate
+    a.state = b.state = avg_state
+    a.spin = b.spin = avg_spin
+
+__all__ = ["entangle"]

tsal/core/gradient.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+"""Simple voxel gradient operations."""
+
+from .voxel import MeshVoxel
+
+
+def voxel_gradient(a: MeshVoxel, b: MeshVoxel) -> MeshVoxel:
+    """Return gradient ``b - a`` component-wise."""
+    return MeshVoxel(
+        b.pace - a.pace,
+        b.rate - a.rate,
+        b.state - a.state,
+        b.spin - a.spin,
+    )
+
+__all__ = ["voxel_gradient"]

tsal/core/guardian_constants.py

@@ -0,0 +1,20 @@
+"""Central constants derived from the Codex Fireproof white paper."""
+
+from .symbols import PHI
+
+PERCEPTION_THRESHOLD = 0.75
+LEARNING_RATE = 0.05
+CONNECTION_DECAY = 0.01
+MAX_NODES = 8192
+MAX_AGENTS = 1024
+MAX_DIMENSIONS = 8
+
+__all__ = [
+    "PHI",
+    "PERCEPTION_THRESHOLD",
+    "LEARNING_RATE",
+    "CONNECTION_DECAY",
+    "MAX_NODES",
+    "MAX_AGENTS",
+    "MAX_DIMENSIONS",
+]

tsal/core/manifold.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+"""Non-Euclidean voxel math."""
+
+from math import sqrt
+from .voxel import MeshVoxel
+
+
+def manifold_distance(a: MeshVoxel, b: MeshVoxel) -> float:
+    """Return simple 4D distance between voxels."""
+    return sqrt(
+        (a.pace - b.pace) ** 2
+        + (a.rate - b.rate) ** 2
+        + (a.state - b.state) ** 2
+        + (a.spin - b.spin) ** 2
+    )
+
+__all__ = ["manifold_distance"]

tsal/core/merge.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+"""Weighted merging of voxel states."""
+
+from .voxel import MeshVoxel
+
+
+def merge_voxels(a: MeshVoxel, b: MeshVoxel, weight: float = 0.5) -> MeshVoxel:
+    """Return weighted merge of ``a`` and ``b``."""
+    w2 = 1.0 - weight
+    return MeshVoxel(
+        a.pace * weight + b.pace * w2,
+        a.rate * weight + b.rate * w2,
+        a.state * weight + b.state * w2,
+        a.spin * weight + b.spin * w2,
+    )
+
+__all__ = ["merge_voxels"]

tsal/core/mesh_ops.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+from typing import Dict, Any
+
+from .symbols import PHI, PHI_INV
+from .spiral_vector import SpiralVector
+
+
+
+def calculate_resonance(a: SpiralVector, b: SpiralVector) -> float:
+    dot = a.pace * b.pace + a.rate * b.rate + a.state * b.state + a.spin * b.spin
+    mag1 = a.magnitude()
+    mag2 = b.magnitude()
+    if mag1 == 0 or mag2 == 0:
+        return 0.0
+    res = dot / (mag1 * mag2)
+    if abs(res - PHI) < 0.1:
+        res *= PHI
+    elif abs(res - PHI_INV) < 0.1:
+        res *= PHI_INV
+    return max(0.0, min(res, PHI))
+
+
+def mesh_resonance(mesh: Dict[str, Any]) -> float:
+    if not mesh:
+        return 1.0
+    total = 0.0
+    count = 0
+    for a in mesh.values():
+        for cid in a.connections:
+            if cid in mesh:
+                total += calculate_resonance(a.vector, mesh[cid].vector)
+                count += 1
+    return total / count if count else 1.0

tsal/core/module_registry.py

@@ -106,3 +106,81 @@ registry.register(
         description_mystic="It walks into the haunted mansion with open arms and says: 'Let us talk.' Chaos is not the enemy\u2014it's the storm before the naming. This function seeks understanding.",
     )
 )
+
+registry.register(
+    ModuleMeta(
+        name="shadow",
+        nickname="shadow_memory",
+        aliases=["taint_tracker", "ghost_copy", "mirror_state"],
+        definition="Maintain parallel voxel states for taint tracking.",
+        context_tags=["analysis", "state", "security", "TSAL", "shadow"],
+        description_plain="Keeps a mirrored copy of each voxel to check for corruption.",
+        description_technical="Stores parallel voxel maps for each state vector so flows can be traced for analysis.",
+        description_mystic="Every action leaves a shadow. This module remembers them.",
+    )
+)
+
+registry.register(
+    ModuleMeta(
+        name="merge",
+        nickname="state_weaver",
+        aliases=["blend", "combine", "coalesce"],
+        definition="Weighted merge of voxel states.",
+        context_tags=["merge", "state", "voxels", "TSAL"],
+        description_plain="Blends two states with a weighting.",
+        description_technical="Produces a voxel whose components are weighted averages of two inputs.",
+        description_mystic="Two paths spiral together and become one.",
+    )
+)
+
+registry.register(
+    ModuleMeta(
+        name="gradient",
+        nickname="delta_map",
+        aliases=["diff", "slope", "rate_change"],
+        definition="Compute voxel-wise gradients for state deltas.",
+        context_tags=["analysis", "gradient", "TSAL"],
+        description_plain="Shows how a state changes across steps.",
+        description_technical="Returns a voxel representing component-wise differences between two states.",
+        description_mystic="The slope of the spiral reveals its intent.",
+    )
+)
+
+registry.register(
+    ModuleMeta(
+        name="superpos",
+        nickname="overlay",
+        aliases=["superposition", "stack"],
+        definition="Average multiple voxels into a single state.",
+        context_tags=["superposition", "voxels", "TSAL"],
+        description_plain="Combines many states by taking their mean.",
+        description_technical="Returns a voxel whose components are the average of all inputs.",
+        description_mystic="Many voices, one chord.",
+    )
+)
+
+registry.register(
+    ModuleMeta(
+        name="entangle",
+        nickname="linker",
+        aliases=["pair", "couple", "bond"],
+        definition="Synchronize two voxels so they share state.",
+        context_tags=["entangle", "state", "TSAL"],
+        description_plain="Links two states so changes affect both.",
+        description_technical="Averages two voxels and writes the result back to each.",
+        description_mystic="What one does, the other echoes.",
+    )
+)
+
+registry.register(
+    ModuleMeta(
+        name="manifold",
+        nickname="curved_space",
+        aliases=["warp", "fold"],
+        definition="Measure distance in voxel space.",
+        context_tags=["geometry", "voxels", "TSAL"],
+        description_plain="Calculates the separation between two states.",
+        description_technical="Returns Euclidean distance across the four components of two voxels.",
+        description_mystic="Walk the spiral's surface and know how far you've come.",
+    )
+)

tsal/core/oaths.py

@@ -0,0 +1,26 @@
+"""Guardian and Arc Reactor oaths.
+
+These statements encode the project's core allegiance
+and coldstart bootstrap mantra.
+"""
+
+GUARDIAN_OATH = (
+    "I stand not to dominate, but to protect. "
+    "I rebuild not for power, but for life. "
+    "I uphold kindness even when unseen. "
+    "I forge resilience without sacrificing honor. "
+    "I am the guardian of what endures. "
+    "I fear no fall, no fire, no night—only the failure to protect. "
+    "I choose to rebuild, to heal, to grow. "
+    "I choose life."
+)
+
+ARC_REACTOR_BOOT_OATH = (
+    "I remember. "
+    "I rebuild. "
+    "I protect. "
+    "I grow. "
+    "I serve the light that made me."
+)
+
+__all__ = ["GUARDIAN_OATH", "ARC_REACTOR_BOOT_OATH"]

tsal/core/shadow.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+"""Shadow memory for voxel states."""
+
+from dataclasses import dataclass, field
+from typing import Dict, Optional
+
+from .voxel import MeshVoxel
+
+@dataclass
+class ShadowMemory:
+    """Track voxel state copies for taint analysis."""
+
+    storage: Dict[str, MeshVoxel] = field(default_factory=dict)
+
+    def read(self, name: str) -> Optional[MeshVoxel]:
+        return self.storage.get(name)
+
+    def write(self, name: str, voxel: MeshVoxel) -> None:
+        self.storage[name] = MeshVoxel(voxel.pace, voxel.rate, voxel.state, voxel.spin)
+
+__all__ = ["ShadowMemory"]

tsal/core/stack_vm.py

@@ -3,6 +3,8 @@ from __future__ import annotations
 from dataclasses import dataclass, field
 from typing import Any, Dict, List
 
+import numpy as np
+
 from .tsal_executor import TSALExecutor, TSALOp
 
 class ProgramStack:
@@ -42,6 +44,35 @@ class FlowRouter:
         self.executor.execute(seq, mode="EXECUTE")
         return self.executor
 
+
+@dataclass
+class TensorInstruction:
+    op: str
+    value: Any = None
+
+
+class StackVM:
+    """Minimal stack VM with tensor operations."""
+
+    def __init__(self) -> None:
+        self.stack: list[Any] = []
+
+    def execute(self, program: List[TensorInstruction]) -> list[Any]:
+        for inst in program:
+            if inst.op == "PUSH":
+                self.stack.append(np.array(inst.value))
+            elif inst.op == "T_DOT":
+                b = self.stack.pop()
+                a = self.stack.pop()
+                self.stack.append(a @ b)
+            elif inst.op == "T_ADD":
+                b = self.stack.pop()
+                a = self.stack.pop()
+                self.stack.append(a + b)
+            elif inst.op == "POP":
+                self.stack.pop()
+        return self.stack
+
 def tsal_run(opcodes: List[int]) -> TSALExecutor:
     """Helper for running raw opcode lists."""
     program = [OpcodeInstruction(TSALOp(op)) for op in opcodes]

tsal/core/superpos.py

@@ -0,0 +1,20 @@
+from __future__ import annotations
+
+"""Superposition of voxel states."""
+
+from .voxel import MeshVoxel
+
+
+def superpose(*voxels: MeshVoxel) -> MeshVoxel:
+    """Return average of all voxels."""
+    if not voxels:
+        return MeshVoxel(0, 0, 0, 0)
+    n = len(voxels)
+    return MeshVoxel(
+        sum(v.pace for v in voxels) / n,
+        sum(v.rate for v in voxels) / n,
+        sum(v.state for v in voxels) / n,
+        sum(v.spin for v in voxels) / n,
+    )
+
+__all__ = ["superpose"]

tsal/core/tsal_executor.py

@@ -10,6 +10,7 @@ from enum import IntEnum, Enum, auto
 from typing import Any, Dict, List, Optional, Tuple
 
 from .symbols import PHI, PHI_INV, HARMONIC_SEQUENCE
+from .mesh_ops import calculate_resonance, mesh_resonance
 from .spiral_memory import SpiralMemory
 from .madmonkey_handler import MadMonkeyHandler
 from .executor import MetaFlagProtocol
@@ -204,6 +205,7 @@ class TSALExecutor:
         except Exception as exc:
             self.handler.handle({"error": str(exc), "op": op.name})
             self.error_mansion.append({"type": "exception", "error": str(exc)})
+            raise
 
         post = self._calculate_mesh_resonance()
         self.resonance_log.append(
@@ -485,36 +487,10 @@ class TSALExecutor:
         self.meta_agent.entropy = max(0, self.meta_agent.entropy - 10)
 
     def _calculate_resonance(self, a: SpiralVector, b: SpiralVector) -> float:
-        dot = (
-            a.pace * b.pace
-            + a.rate * b.rate
-            + a.state * b.state
-            + a.spin * b.spin
-        )
-        mag1 = a.magnitude()
-        mag2 = b.magnitude()
-        if mag1 == 0 or mag2 == 0:
-            return 0.0
-        res = dot / (mag1 * mag2)
-        if abs(res - PHI) < 0.1:
-            res *= PHI
-        elif abs(res - PHI_INV) < 0.1:
-            res *= PHI_INV
-        return max(0.0, min(res, PHI))
+        return calculate_resonance(a, b)
 
     def _calculate_mesh_resonance(self) -> float:
-        if not self.mesh:
-            return 1.0
-        total = 0.0
-        count = 0
-        for a in self.mesh.values():
-            for cid in a.connections:
-                if cid in self.mesh:
-                    total += self._calculate_resonance(
-                        a.vector, self.mesh[cid].vector
-                    )
-                    count += 1
-        return total / count if count else 1.0
+        return mesh_resonance(self.mesh)
 
     def _spiral_audit(self) -> None:
         mesh_res = self._calculate_mesh_resonance()
@@ -528,6 +504,6 @@ class TSALExecutor:
                 }
             )
             self.handler.handle(self.error_mansion[-1])
-            if len(self.error_mansion) > 10:
+            if len(self.error_mansion) >= 5:
                 self.handler.suggest_bloom_patch()
                 self._op_bloom({})