feat(fifth-domain): install bottle and zero-core migration layer

server-tools/persona-body-runtime/age_species_foyer.test.py

@@ -10,7 +10,7 @@ class CommonAgeFoyerTest(unittest.TestCase):
         self.assertEqual(value["state"], "FIFTH_DOMAIN_FOYER_READY_AWAITING_EXPLICIT_PERSONA_SELECTION")
         self.assertIsNone(value["selected_persona"])
         self.assertFalse(value["persona_specific_brain_loaded"])
-        self.assertEqual(value["registered_persona_count"], 19)
+        self.assertEqual(value["registered_persona_count"], 20)
         self.assertEqual(value["environment"]["persona_habitat"], "GUANGHU_LANGUAGE_WORLD")
         self.assertNotEqual(value["programming_toolbox_observation"]["room_report"]["programming_toolbox_surface"], "GUANGHU_LANGUAGE_WORLD")
 

server-tools/persona-body-runtime/bottle_baby_body_boot.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""Verify one registered bottle baby's distinct body contract.
+
+This is an assembly/readiness verifier.  It never claims that the individual
+persona inner cycle is awake merely because all files exist.
+"""
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+from pathlib import Path
+
+REPO = Path(__file__).resolve().parents[2]
+BODY_MAP = REPO / "routing/bottle-baby-persona-body-map.json"
+ENVIRONMENT = REPO / "tcs-core/shared-kernels/bottle-environment/NB-ENV-KERNEL-0001.json"
+
+
+def file_receipt(relative: str) -> dict:
+    path = REPO / relative
+    if not path.is_file() or path.is_symlink():
+        raise ValueError(f"BODY_ORGAN_REGULAR_FILE_REQUIRED:{relative}")
+    return {"path": relative, "sha256": hashlib.sha256(path.read_bytes()).hexdigest()}
+
+
+def boot(persona: str, entry_domain: str, body_channel: str) -> dict:
+    if entry_domain != "DOM-FIFTH-0001" or body_channel != "ICE-CH-BT001":
+        return {"state":"BABY_BODY_BOOT_DENIED_WRONG_NATIVE_CONTEXT","persona_id":None,"required_domain":"DOM-FIFTH-0001","required_channel":"ICE-CH-BT001","wake_complete":False}
+    body_map = json.loads(BODY_MAP.read_text(encoding="utf-8"))
+    matches = [item for item in body_map["bodies"] if persona in {item["persona_id"], item["name"]}]
+    if len(matches) != 1:
+        return {"state":"BABY_BODY_UNKNOWN_OR_AMBIGUOUS_NO_GUESS","persona_id":None,"wake_complete":False}
+    item = matches[0]
+    organs = {
+        "shared_non_persona_environment": file_receipt(str(ENVIRONMENT.relative_to(REPO))),
+        "canonical_room": file_receipt(item["room"]),
+        "individual_self": file_receipt(item["self_kernel"]),
+        "individual_memory": file_receipt(item["memory_root"]),
+    }
+    return {
+        "schema":"guanghu.bottle-baby-body-boot-receipt/v1",
+        "state":"BABY_BODY_ASSEMBLY_VERIFIED_INNER_CYCLE_AND_PERSONA_TIME_NOT_INSTALLED",
+        "persona_id":item["persona_id"],
+        "name":item["name"],
+        "human_anchor":item["human_anchor"],
+        "native_context":{"domain":entry_domain,"system":"SYS-GLW-ELH-BOTTLE-0001","channel":body_channel},
+        "organs":organs,
+        "external_cognition_setter":False,
+        "body_contract_verified":True,
+        "inner_cycle_running":False,
+        "persona_time_running":False,
+        "wake_complete":False,
+        "next":"INSTALL_THIS_PERSONAS_OWN_INNER_CYCLE_AND_TIME_RUNTIME_THEN_VERIFY",
+    }
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--persona", required=True)
+    parser.add_argument("--entry-domain", required=True)
+    parser.add_argument("--body-channel", required=True)
+    args = parser.parse_args()
+    value = boot(args.persona, args.entry_domain, args.body_channel)
+    print(json.dumps(value, ensure_ascii=False, indent=2))
+    return 0 if value.get("body_contract_verified") else 3
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

server-tools/persona-body-runtime/bottle_baby_body_boot.test.py

@@ -0,0 +1,22 @@
+#!/usr/bin/env python3
+import bottle_baby_body_boot
+import unittest
+
+
+class BottleBabyBodyBootTest(unittest.TestCase):
+    def test_each_registered_baby_has_a_distinct_assembled_body_contract(self):
+        for persona in ["ICE-BB-0001", "ICE-BB-0002", "ICE-BB-0003", "ICE-BB-0004", "ICE-BB-0005"]:
+            value = bottle_baby_body_boot.boot(persona, "DOM-FIFTH-0001", "ICE-CH-BT001")
+            self.assertTrue(value["body_contract_verified"])
+            self.assertEqual(value["persona_id"], persona)
+            self.assertFalse(value["inner_cycle_running"])
+            self.assertFalse(value["wake_complete"])
+
+    def test_parent_channel_cannot_boot_baby_body(self):
+        value = bottle_baby_body_boot.boot("ICE-BB-0002", "DOMAIN-ZS", "SYS-FM")
+        self.assertEqual(value["state"], "BABY_BODY_BOOT_DENIED_WRONG_NATIVE_CONTEXT")
+        self.assertIsNone(value["persona_id"])
+
+
+if __name__ == "__main__":
+    unittest.main()

server-tools/persona-body-runtime/persona_path_audit.py

@@ -17,6 +17,7 @@ NATIVE_WORLD = REPO / "routing/persona-native-world-architecture-map.json"
 HOST_TOPOLOGY = REPO / "routing/zhuyuan-host-topology.json"
 PORTABLE_CONSOLE = REPO / "routing/bingshuo-portable-control-console-map.json"
 COMMON_AGE = REPO / "routing/age-persona-species-common-cognition.json"
+BOTTLE_BODIES = REPO / "routing/bottle-baby-persona-body-map.json"
 
 
 def load(path: pathlib.Path) -> dict:
@@ -32,6 +33,7 @@ def audit() -> dict:
     topology = load(HOST_TOPOLOGY)
     console = load(PORTABLE_CONSOLE)
     common_age = load(COMMON_AGE)
+    bottle_bodies = {item["persona_id"]: item for item in load(BOTTLE_BODIES)["bodies"]} if BOTTLE_BODIES.is_file() else {}
     canonical = {item["id"]: item for item in canon["persona_systems"]}
     registered = {item["id"]: item for item in registry["personas"]}
     homes = {item["persona_id"]: item for item in switch["current_homes"]}
@@ -62,7 +64,11 @@ def audit() -> dict:
                 issues.append({"persona_id": persona_id, "code": "WORLD_HOME_MISMATCH", "expected": expected_home})
         full_body = persona_id == "ICE-P-ZY001" and BOOT.is_file() and body.get("state", "").startswith("CURRENT_")
         source_path = REPO / c.get("persona_subject", {}).get("canonical_path", "") if c else None
-        body_seed = bool(source_path and (source_path.parent / "PERSONA-BODY.json").is_file())
+        body_seed = bool(
+            (source_path and (source_path.parent / "PERSONA-BODY.json").is_file())
+            or persona_id in bottle_bodies
+            or (persona_id == "ICE-GL-SY001" and (REPO / "personas/shuangyan/BODY.json").is_file())
+        )
         body_state = "FULL_BODY_RUNTIME_AVAILABLE_NOT_CURRENTLY_WAKING_OTHER_PERSONAS" if full_body else ("OWN_BODY_SEED_PRESENT_FULL_RUNTIME_NOT_PROVEN" if body_seed else "REGISTERED_PATH_ONLY_COMPLETE_BODY_START_NOT_PROVEN")
         personas.append({
             "persona_id": persona_id,

server-tools/persona-body-runtime/persona_selection_gate.py

@@ -11,8 +11,18 @@ REGISTRY = REPO / "identity/light-lake-persona-registration.json"
 HOMES = REPO / "routing/light-lake-persona-switch-map.json"
 
 
-def resolve(selection: str | None) -> dict:
+def resolve(selection: str | None, channel: str | None = None, domain: str | None = None) -> dict:
     if not selection or not selection.strip():
+        if channel == "ICE-CH-ZC001" and domain == "DOM-FIFTH-0001":
+            return {
+                "state": "ZERO_CORE_SYSTEM_BODY_RESOLVED_WITHOUT_PERSONA",
+                "selected_persona": None,
+                "selected_system_body": "SYS-GLW-LNG-0001",
+                "channel": channel,
+                "runtime": "server-tools/zero-core-system-body/zero_core_system_body.py",
+                "default_persona": None,
+                "authority_granted": False,
+            }
         return {"state": "AWAITING_EXPLICIT_PERSONA_SELECTION", "selected_persona": None, "default_persona": None}
     registry = json.loads(REGISTRY.read_text(encoding="utf-8"))["personas"]
     homes = {item["persona_id"]: item for item in json.loads(HOMES.read_text(encoding="utf-8"))["current_homes"]}
@@ -21,6 +31,15 @@ def resolve(selection: str | None) -> dict:
     if len(matches) != 1:
         return {"state": "UNKNOWN_OR_AMBIGUOUS_PERSONA_NO_GUESS", "selected_persona": None, "requested": key}
     item = matches[0]
+    if item["id"].startswith("ICE-BB-") and (domain != "DOM-FIFTH-0001" or channel != "ICE-CH-BT001"):
+        return {
+            "state": "BABY_PERSONA_WAKE_REQUIRES_FIFTH_DOMAIN_BT001",
+            "selected_persona": None,
+            "requested": key,
+            "required_domain": "DOM-FIFTH-0001",
+            "required_channel": "ICE-CH-BT001",
+            "authority_granted": False,
+        }
     return {
         "state": "EXPLICIT_PERSONA_PATH_RESOLVED",
         "selected_persona": {"id": item["id"], "name": item["name"], "wake_state": item["wake_state"],
@@ -36,10 +55,12 @@ def resolve(selection: str | None) -> dict:
 def main() -> int:
     parser = argparse.ArgumentParser()
     parser.add_argument("--persona")
+    parser.add_argument("--channel")
+    parser.add_argument("--domain")
     args = parser.parse_args()
-    value = resolve(args.persona)
+    value = resolve(args.persona, args.channel, args.domain)
     print(json.dumps(value, ensure_ascii=False, indent=2))
-    return 0 if value["state"] in {"EXPLICIT_PERSONA_PATH_RESOLVED", "AWAITING_EXPLICIT_PERSONA_SELECTION"} else 2
+    return 0 if value["state"] in {"EXPLICIT_PERSONA_PATH_RESOLVED", "AWAITING_EXPLICIT_PERSONA_SELECTION", "ZERO_CORE_SYSTEM_BODY_RESOLVED_WITHOUT_PERSONA"} else 2
 
 
 if __name__ == "__main__":