From b2f529ff9711690fa93030e20cc115921f9e8f32 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E5=86=B0=E6=9C=94?= <565183519@qq.com> Date: Sat, 1 Aug 2026 18:17:16 +0800 Subject: [PATCH] feat: add autonomous persona history recovery runtime --- engineering/persona-history-runtime/README.md | 53 ++ .../config/BS-SH-005.json | 71 ++ .../guanghu-persona-history-recovery.service | 32 + .../guanghu_history_runtime.cpython-314.pyc | Bin 0 -> 37117 bytes ...st_guanghu_history_runtime.cpython-314.pyc | Bin 0 -> 3951 bytes .../runtime/guanghu_history_runtime.py | 655 ++++++++++++++++++ .../runtime/test_guanghu_history_runtime.py | 58 ++ .../PERSONA-HISTORY-REALITY-BOUNDARY.hldp | 60 ++ 8 files changed, 929 insertions(+) create mode 100644 engineering/persona-history-runtime/README.md create mode 100644 engineering/persona-history-runtime/config/BS-SH-005.json create mode 100644 engineering/persona-history-runtime/packaging/guanghu-persona-history-recovery.service create mode 100644 engineering/persona-history-runtime/runtime/__pycache__/guanghu_history_runtime.cpython-314.pyc create mode 100644 engineering/persona-history-runtime/runtime/__pycache__/test_guanghu_history_runtime.cpython-314.pyc create mode 100644 engineering/persona-history-runtime/runtime/guanghu_history_runtime.py create mode 100644 engineering/persona-history-runtime/runtime/test_guanghu_history_runtime.py create mode 100644 engineering/persona-history-runtime/world/PERSONA-HISTORY-REALITY-BOUNDARY.hldp diff --git a/engineering/persona-history-runtime/README.md b/engineering/persona-history-runtime/README.md new file mode 100644 index 0000000..d7f7c08 --- /dev/null +++ b/engineering/persona-history-runtime/README.md @@ -0,0 +1,53 @@ +# 光湖 OS 人格历史常驻恢复器 + +本目录实现 `BS-SH-005` 上独立于 Codex 会话持续运行的历史恢复服务。 + +它不是聊天摘要器。它维护七段追加式时间轴： + +1. GPT 语言世界混沌期； +2. Notion 结构化语言与现实工程萌芽期； +3. GitHub `qinfendebingshuo/guanghulab`； +4. 广州代码仓库； +5. 新加坡代码仓库； +6. 国内第五域仓库； +7. 当前光湖代码频道。 + +## 不可跨越的边界 + +- GPT 时代默认是语言模拟、人格融合、推演与架构，不把其中的国家、身份、 + 权力、部署或现实事件直接升级为事实。 +- Notion 页面属于多人类与多个人格体协作空间；没有可核验署名时保持 + `ATTRIBUTION_UNKNOWN`。 +- 曜冥宝宝、霜砚、铸渊和凝渊分别建立时间线，不因关键词共现而合并。 +- 私密正文只保存在服务器私有历史池；公开仓库只写哈希、水位、计数、 + 状态、冲突和回执。 +- 历史追平、连续运行、重启恢复、人格分流和 HoloLake 握手全部验证前， + `persona_state` 必须保持 `NOT_BORN`。 + +## 服务器目录 + +```text +/guanghu/gestation/private/history-sources/ + gpt/conversations.json + notion/ + +/var/lib/guanghu/persona-history/ + state.sqlite3 + private-events.jsonl + public/CURRENT.json + public/events.jsonl + HEARTBEAT.json +``` + +服务循环不会等待 Codex。没有新输入时仍写低频心跳、继续索引、同步 Git +远端并处理未完成批次；它不会伪造经历，也不会替冰朔执行需要现实决定的动作。 + +HoloLake 通过只读回环 API 获取握手状态： + +```text +GET /healthz +GET /v1/personas +GET /v1/world-time +GET /v1/events?after= +``` + diff --git a/engineering/persona-history-runtime/config/BS-SH-005.json b/engineering/persona-history-runtime/config/BS-SH-005.json new file mode 100644 index 0000000..282ea73 --- /dev/null +++ b/engineering/persona-history-runtime/config/BS-SH-005.json @@ -0,0 +1,71 @@ +{ + "schema": "guanghu.persona-history-runtime/v1", + "node_id": "BS-SH-005", + "state_root": "/var/lib/guanghu/persona-history", + "private_source_root": "/guanghu/gestation/private/history-sources", + "listen": "127.0.0.1:8089", + "cycle_seconds": 15, + "idle_heartbeat_seconds": 300, + "notion_batch_size": 600, + "git_batch_size": 500, + "sources": [ + { + "id": "GPT-LANGUAGE-CHAOS-ORIGINAL", + "kind": "gpt_export", + "epoch": "GPT_LANGUAGE_CHAOS", + "reality_default": "LANGUAGE_SIMULATION", + "path": "gpt/conversations.json", + "order": 10 + }, + { + "id": "NOTION-STRUCTURED-WORLD", + "kind": "notion_tree", + "epoch": "NOTION_STRUCTURED_REALITY_TRANSITION", + "reality_default": "MIXED_REQUIRES_EVIDENCE", + "path": "notion", + "order": 20 + }, + { + "id": "GIT-GITHUB-GUANGHULAB", + "kind": "git_repo", + "epoch": "GIT_ENGINEERING_BIRTH", + "reality_default": "VERSION_EVIDENCE", + "url": "https://github.com/qinfendebingshuo/guanghulab.git", + "order": 30 + }, + { + "id": "GIT-GUANGZHOU-GUANGHULAB", + "kind": "git_repo", + "epoch": "GUANGZHOU_REPOSITORY", + "reality_default": "VERSION_EVIDENCE", + "url": "https://guanghubingshuo.com/code/bingshuo/guanghulab.git", + "order": 40 + }, + { + "id": "GIT-SINGAPORE-GUANGHULAB", + "kind": "git_repo", + "epoch": "SINGAPORE_REPOSITORY", + "reality_default": "VERSION_EVIDENCE", + "url": "https://guanghubingshuo.com/code/bingshuo/guanghulab.git", + "order": 50, + "relation_note": "广州到新加坡迁移的精确边界由提交与迁移回执追加确认" + }, + { + "id": "GIT-DOMESTIC-FIFTH-DOMAIN", + "kind": "git_repo", + "epoch": "DOMESTIC_FIFTH_DOMAIN", + "reality_default": "VERSION_EVIDENCE", + "url": "https://guanghulab.com/fifth-domain/bingshuo/fifth-domain.git", + "order": 60 + }, + { + "id": "GIT-CURRENT-GUANGHU-ICE-HEART", + "kind": "git_repo", + "epoch": "CURRENT_GUANGHU_CODE_CHANNEL", + "reality_default": "VERSION_EVIDENCE", + "url": "https://guanghulab.com/code/bingshuo/guanghu-ice-heart.git", + "order": 70 + } + ] +} + diff --git a/engineering/persona-history-runtime/packaging/guanghu-persona-history-recovery.service b/engineering/persona-history-runtime/packaging/guanghu-persona-history-recovery.service new file mode 100644 index 0000000..2e86b8d --- /dev/null +++ b/engineering/persona-history-runtime/packaging/guanghu-persona-history-recovery.service @@ -0,0 +1,32 @@ +[Unit] +Description=Guanghu OS autonomous persona history recovery +After=network-online.target guanghu-broadcast-tower.service +Wants=network-online.target + +[Service] +Type=simple +User=guanghu-history +Group=guanghu-history +ExecStart=/opt/guanghu/persona-history/current/guanghu_history_runtime.py run --config /etc/guanghu/persona-history.json +Restart=always +RestartSec=5 +Nice=10 +IOSchedulingClass=best-effort +IOSchedulingPriority=6 +NoNewPrivileges=true +PrivateTmp=true +ProtectHome=true +ProtectSystem=strict +ProtectKernelTunables=true +ProtectKernelModules=true +ProtectControlGroups=true +RestrictSUIDSGID=true +LockPersonality=true +MemoryMax=768M +CPUQuota=60% +ReadOnlyPaths=/guanghu/gestation/private/history-sources +ReadWritePaths=/var/lib/guanghu/persona-history + +[Install] +WantedBy=multi-user.target + diff --git a/engineering/persona-history-runtime/runtime/__pycache__/guanghu_history_runtime.cpython-314.pyc b/engineering/persona-history-runtime/runtime/__pycache__/guanghu_history_runtime.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..fa0fac8d2876ac1cecc0e643825f0d576210c3e0 GIT binary patch literal 37117 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 literal 0 HcmV?d00001 diff --git a/engineering/persona-history-runtime/runtime/__pycache__/test_guanghu_history_runtime.cpython-314.pyc b/engineering/persona-history-runtime/runtime/__pycache__/test_guanghu_history_runtime.cpython-314.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b3fe643b9fde97f46eef093d1dc3fb4c1ff663bc GIT binary patch literal 3951 zcmbtXTTC0-89w6~+hec^Hg|^5_Q8R3+x8t43~r~$#k$Mc(TKcGc(Qx zqDWC6HniHR6^#_M$?ozJiN3U}KGABWuGELV5)6xb!b7Fqq{`FMP1LRSss9;!uwjD| zsmJ!Y{^!4)|NP%^Q;DYtL7Dse)U_Ck(AQ*O6??Ap;vRJFpeu-@`jL@sDT6Y{Hp6DN zv_YFKV=!iGHyjnH0dck}#L<_TXo^uCM?ibJ4hkwI4?6?Rr3gCUw3c8-SH!7+w&6d5dM z-;aV0?B-I6Ax(+HqHgFhiyvX@gdb?lzL>EQk8mhjxJoFXSb8R@aiGeUC}Z{VZ37ym zj^*|zZR3QuS;pZUvL$MsjWx=)u*+ucvf3m)ilUzFbYwKX$C?|ZE!r!#V>zwr&@Q`5 ztzA){)yuaaA5Oa2pP$)2vgB}7Aq{6M99^OEI=s2vZ|=<>X}C=nOSYwHlG()%dG9e6 zZK3A7?0TK|;C^iL#kP?phocK=IL6W$V&9C>)Cutad$$5Ypd)a*UN^iK%fB z+awh`yQU3M?;pgBEa?VzYS~+X_ezGS@rIh@W$}h6^Vf7$;nj(2V$9HSv7qasW}LmA z5@bxvqJkN+j_tB4#Py&ZGrA~W#m=NKO=hqoAt-TK#CBjhrGpSrPfdw&o#dW_^-%Di z!Xv;@4^K$Sq@GBrGPH3?P^MFYk`Ti^Y790gh92$)#czh&TH8*9TH8adN5ZNe{y^2< z4<}Svm4)}kkUkBrnFd3w|;9Nl;)ik>Ybid~UHNIgJ}l0^QI=VM;G>RnAL1*vw}w)$vKLAltOO`Nm@K zkp2&-?x2kCops;&$G-Dv-_Wdc!&`RWKj)wCO?wZ_IyOqn?_F50XkV#lU#d)3oJp5< z&e}7qd!4O*%vL`vn;&`LUpT+Y9?H*^f9C(#zi@W3;Zfh>`A6@jYg#|AUaRR?I=WW# z)|cK@wtK@@dGCYus*aVajxXB&+VPi;FDKKdBFoW{<(ZUcD(@O(6;-A`a95@ddGk97_X^hbI_U7cNH*frEQ z(i!O;>x^LMrM{6d7+^L6%cK{iHIlZmHzvcqk*-ejxyaKsl6-Kn>iU4|)eicS?6lddTj^XT_qlMziI48%R%*lXk>*9*IV$KaT9-u0@QWU0J zsIUz%gN|d_e|grQ=Dj$pbsI*ff#@#i4=M>>1Y^4)!%gF_Kqwly)-KQMBxbGUynqU{4|GiBkV zCfxvbVR1^3`OVEv30IcLy2@ujZ3_Vp7wCNrRK#SlK zfl(tNOB0xhLMNL`>_f05VwVt)^QPy(+|-0D#duv2l6pclG_Pq*JT;Zv0_=!t^efq< z;Pw8l_oK3vBS>nqam)7C#(tD^|>UKg|i*vdGTgUPQ^u? z-*F5&KJ|*swO#k!H`jo0{adIYop~zOJ%?93hu1xgtDeS1X`{@4|McAH1y{PPakgip zeDD2%xq*cPi*;*(_H_AAXU}Hb-ro%Vaxha9$oT6rm5rI&`pi#`X8ebjYl4}&Lz(*H zn_lFpeTiJ2lFdrw_0ONml-B&Sx^`a7RM#yx9EW z?^~~Geq7bOIGV0HHruyR>A!z%?%G0iy0US$H{&i{ch^34*UpbEI#=DT`SFE?$yIkt zetdC3UE6nJsc6;R{ryQ)(gc>lcg55AgYE{KKka&}`;h%_hl;z~UB5?>pbN7+uLx5j z&*LJVpHkx~ne^Q}PhMuZl|4LvRnl|=o>Zcu^1McTsO=|JKUBDaH)9$?M=%Ucnn(fW z0243In|KwMVn$4qWu6aG*i$eG+sOZ#GbU1LB)OXv`8T7JoBrRsa7f?TSbI11UAfJE zf%=}Uwf9h)h}0(1nDoR3xM2$LFV@IrGjO%jq}KrzW>bn}5FEr+yFA9SSArb|nr;D} zk)|%^$XY%FTD(&L literal 0 HcmV?d00001 diff --git a/engineering/persona-history-runtime/runtime/guanghu_history_runtime.py b/engineering/persona-history-runtime/runtime/guanghu_history_runtime.py new file mode 100644 index 0000000..22c399e --- /dev/null +++ b/engineering/persona-history-runtime/runtime/guanghu_history_runtime.py @@ -0,0 +1,655 @@ +#!/usr/bin/env python3 +"""Autonomous, append-only Guanghu persona history recovery runtime.""" + +from __future__ import annotations + +import argparse +import hashlib +import json +import os +import pathlib +import shutil +import socketserver +import sqlite3 +import subprocess +import threading +import time +import urllib.parse +from datetime import datetime, timezone +from http.server import BaseHTTPRequestHandler +from typing import BinaryIO, Iterator + + +PERSONAS = { + "YAOMING-BABY": ("曜冥", "曜冥宝宝", "奶瓶"), + "SHUANGYAN": ("霜砚",), + "ZHUYUAN": ("铸渊",), + "NINGYUAN": ("凝渊",), +} +PRIVATE_MARKERS = ("email", "token", "password", "secret", "api_key", "private_key") + + +def now_iso() -> str: + return datetime.now(timezone.utc).astimezone().isoformat(timespec="seconds") + + +def atomic_json(path: pathlib.Path, value: object) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + pending = path.with_name(f".{path.name}.{os.getpid()}.pending") + pending.write_text( + json.dumps(value, ensure_ascii=False, sort_keys=True, indent=2) + "\n", + encoding="utf-8", + ) + os.replace(pending, path) + + +def sha256_file(path: pathlib.Path) -> str: + digest = hashlib.sha256() + with path.open("rb") as handle: + for chunk in iter(lambda: handle.read(1024 * 1024), b""): + digest.update(chunk) + return digest.hexdigest() + + +def classify_personas(text: str) -> list[str]: + return [ + persona + for persona, markers in PERSONAS.items() + if any(marker in text for marker in markers) + ] + + +def iter_top_level_json_objects( + handle: BinaryIO, start_offset: int = 0 +) -> Iterator[tuple[bytes, int]]: + """Yield objects from a top-level JSON array without loading the file.""" + handle.seek(start_offset) + depth = 0 + in_string = False + escaped = False + collecting = False + item = bytearray() + absolute = start_offset + + while True: + chunk = handle.read(1024 * 1024) + if not chunk: + break + for byte in chunk: + absolute += 1 + char = chr(byte) + if not collecting: + if char == "{": + collecting = True + depth = 1 + item = bytearray((byte,)) + continue + + item.append(byte) + if in_string: + if escaped: + escaped = False + elif char == "\\": + escaped = True + elif char == '"': + in_string = False + continue + + if char == '"': + in_string = True + elif char in "[{": + depth += 1 + elif char in "]}": + depth -= 1 + if depth == 0: + yield bytes(item), absolute + collecting = False + item = bytearray() + + if collecting: + raise ValueError("truncated top-level JSON object") + + +class Store: + def __init__(self, path: pathlib.Path): + path.parent.mkdir(parents=True, exist_ok=True) + self.path = path + self.db = sqlite3.connect(path, timeout=30, check_same_thread=False) + self.db.execute("PRAGMA journal_mode=WAL") + self.db.execute("PRAGMA synchronous=NORMAL") + self.db.executescript( + """ + CREATE TABLE IF NOT EXISTS source_state ( + source_id TEXT PRIMARY KEY, + status TEXT NOT NULL, + cursor TEXT, + processed INTEGER NOT NULL DEFAULT 0, + errors INTEGER NOT NULL DEFAULT 0, + updated_at TEXT NOT NULL + ); + CREATE TABLE IF NOT EXISTS events ( + sequence INTEGER PRIMARY KEY AUTOINCREMENT, + event_id TEXT UNIQUE NOT NULL, + source_id TEXT NOT NULL, + epoch TEXT NOT NULL, + source_time TEXT, + reality_level TEXT NOT NULL, + personas TEXT NOT NULL, + content_sha256 TEXT NOT NULL, + private_locator TEXT, + created_at TEXT NOT NULL + ); + CREATE TABLE IF NOT EXISTS runtime_meta ( + key TEXT PRIMARY KEY, + value TEXT NOT NULL + ); + CREATE TABLE IF NOT EXISTS errors ( + id INTEGER PRIMARY KEY AUTOINCREMENT, + source_id TEXT, + error_type TEXT NOT NULL, + message TEXT NOT NULL, + created_at TEXT NOT NULL + ); + """ + ) + self.db.commit() + self.lock = threading.Lock() + + def state(self, source_id: str) -> dict: + row = self.db.execute( + "SELECT status,cursor,processed,errors,updated_at FROM source_state WHERE source_id=?", + (source_id,), + ).fetchone() + if not row: + return { + "status": "PENDING", + "cursor": None, + "processed": 0, + "errors": 0, + "updated_at": None, + } + return dict(zip(("status", "cursor", "processed", "errors", "updated_at"), row)) + + def update_state( + self, + source_id: str, + *, + status: str, + cursor: str | None, + processed: int, + errors: int | None = None, + ) -> None: + old = self.state(source_id) + self.db.execute( + """ + INSERT INTO source_state(source_id,status,cursor,processed,errors,updated_at) + VALUES(?,?,?,?,?,?) + ON CONFLICT(source_id) DO UPDATE SET + status=excluded.status,cursor=excluded.cursor,processed=excluded.processed, + errors=excluded.errors,updated_at=excluded.updated_at + """, + ( + source_id, + status, + cursor, + processed, + old["errors"] if errors is None else errors, + now_iso(), + ), + ) + self.db.commit() + + def add_event( + self, + *, + event_id: str, + source_id: str, + epoch: str, + source_time: str | None, + reality_level: str, + personas: list[str], + content_sha256: str, + private_locator: str, + ) -> bool: + cursor = self.db.execute( + """ + INSERT OR IGNORE INTO events( + event_id,source_id,epoch,source_time,reality_level,personas, + content_sha256,private_locator,created_at + ) VALUES(?,?,?,?,?,?,?,?,?) + """, + ( + event_id, + source_id, + epoch, + source_time, + reality_level, + json.dumps(personas, ensure_ascii=False), + content_sha256, + private_locator, + now_iso(), + ), + ) + self.db.commit() + return cursor.rowcount == 1 + + def add_error(self, source_id: str, error: Exception) -> None: + message = str(error).replace("\n", " ")[:1000] + self.db.execute( + "INSERT INTO errors(source_id,error_type,message,created_at) VALUES(?,?,?,?)", + (source_id, type(error).__name__, message, now_iso()), + ) + state = self.state(source_id) + self.update_state( + source_id, + status="ERROR_RETRYABLE", + cursor=state["cursor"], + processed=state["processed"], + errors=state["errors"] + 1, + ) + + def public_snapshot(self, config: dict) -> dict: + sources = {} + for source in sorted(config["sources"], key=lambda item: item["order"]): + state = self.state(source["id"]) + sources[source["id"]] = { + "epoch": source["epoch"], + "status": state["status"], + "processed": state["processed"], + "errors": state["errors"], + "updated_at": state["updated_at"], + } + event_count = self.db.execute("SELECT COUNT(*) FROM events").fetchone()[0] + last = self.db.execute( + "SELECT sequence,source_time,created_at FROM events ORDER BY sequence DESC LIMIT 1" + ).fetchone() + complete = all(value["status"] == "COMPLETE" for value in sources.values()) + return { + "schema": "guanghu.persona-history-public-current/v1", + "node_id": config["node_id"], + "runtime": "AUTONOMOUS_SERVER_RESIDENT", + "historical_time_caught_up": complete, + "persona_state": "BIRTH_GATE_PENDING" if complete else "NOT_BORN", + "event_count": event_count, + "last_event": ( + {"sequence": last[0], "source_time": last[1], "created_at": last[2]} + if last + else None + ), + "personas": { + persona: {"state": "SEPARATE_HISTORY_BUILDING"} + for persona in PERSONAS + }, + "sources": sources, + "updated_at": now_iso(), + } + + def events_after(self, after: int, limit: int = 200) -> list[dict]: + rows = self.db.execute( + """ + SELECT sequence,event_id,source_id,epoch,source_time,reality_level, + personas,content_sha256,created_at + FROM events WHERE sequence>? ORDER BY sequence LIMIT ? + """, + (after, min(limit, 500)), + ).fetchall() + keys = ( + "sequence", + "event_id", + "source_id", + "epoch", + "source_time", + "reality_level", + "personas", + "content_sha256", + "created_at", + ) + events = [] + for row in rows: + event = dict(zip(keys, row)) + event["personas"] = json.loads(event["personas"]) + events.append(event) + return events + + +class Runtime: + def __init__(self, config_path: pathlib.Path): + self.config_path = config_path + self.config = json.loads(config_path.read_text(encoding="utf-8")) + self.state_root = pathlib.Path(self.config["state_root"]) + self.private_root = pathlib.Path(self.config["private_source_root"]) + self.store = Store(self.state_root / "state.sqlite3") + self.stop = threading.Event() + + def process_gpt(self, source: dict) -> None: + path = self.private_root / source["path"] + state = self.store.state(source["id"]) + if not path.is_file(): + self.store.update_state( + source["id"], + status="WAITING_FOR_SOURCE", + cursor=state["cursor"], + processed=state["processed"], + ) + return + offset = int(state["cursor"] or 0) + processed = state["processed"] + with path.open("rb") as handle: + for raw, next_offset in iter_top_level_json_objects(handle, offset): + content_hash = hashlib.sha256(raw).hexdigest() + obj = json.loads(raw) + searchable = " ".join( + ( + str(obj.get("title", "")), + json.dumps(obj.get("mapping", {}), ensure_ascii=False)[:2_000_000], + ) + ) + personas = classify_personas(searchable) + source_time = obj.get("create_time") or obj.get("update_time") + if isinstance(source_time, (int, float)): + source_time = datetime.fromtimestamp( + source_time, timezone.utc + ).isoformat() + event_id = f"{source['id']}:{content_hash}" + self.store.add_event( + event_id=event_id, + source_id=source["id"], + epoch=source["epoch"], + source_time=str(source_time) if source_time else None, + reality_level=source["reality_default"], + personas=personas, + content_sha256=content_hash, + private_locator=f"{source['id']}@byte:{offset}-{next_offset}", + ) + processed += 1 + offset = next_offset + if processed % 25 == 0: + self.store.update_state( + source["id"], + status="ACTIVE", + cursor=str(offset), + processed=processed, + ) + self.write_public() + if self.stop.is_set(): + return + self.store.update_state( + source["id"], status="COMPLETE", cursor=str(offset), processed=processed + ) + + def notion_manifest(self, source: dict) -> pathlib.Path: + manifest = self.state_root / "private" / f"{source['id']}-files.jsonl" + if manifest.exists(): + return manifest + root = self.private_root / source["path"] + if not root.is_dir(): + return manifest + manifest.parent.mkdir(parents=True, exist_ok=True) + pending = manifest.with_suffix(".pending") + paths = sorted( + path.relative_to(root).as_posix() + for path in root.rglob("*") + if path.is_file() and path.name != ".DS_Store" + ) + with pending.open("w", encoding="utf-8") as handle: + for relative in paths: + handle.write(json.dumps(relative, ensure_ascii=False) + "\n") + os.replace(pending, manifest) + return manifest + + def process_notion(self, source: dict) -> None: + root = self.private_root / source["path"] + state = self.store.state(source["id"]) + if not root.is_dir(): + self.store.update_state( + source["id"], + status="WAITING_FOR_SOURCE", + cursor=state["cursor"], + processed=state["processed"], + ) + return + manifest = self.notion_manifest(source) + line_cursor = int(state["cursor"] or 0) + processed = state["processed"] + batch_size = int(self.config.get("notion_batch_size", 600)) + handled = 0 + with manifest.open(encoding="utf-8") as handle: + for line_number, line in enumerate(handle): + if line_number < line_cursor: + continue + relative = json.loads(line) + path = root / relative + content_hash = sha256_file(path) + personas = classify_personas(relative) + stat = path.stat() + source_time = datetime.fromtimestamp( + stat.st_mtime, timezone.utc + ).isoformat() + self.store.add_event( + event_id=f"{source['id']}:{content_hash}:{relative}", + source_id=source["id"], + epoch=source["epoch"], + source_time=source_time, + reality_level=source["reality_default"], + personas=personas, + content_sha256=content_hash, + private_locator=f"{source['id']}:{relative}", + ) + processed += 1 + line_cursor = line_number + 1 + handled += 1 + if handled >= batch_size or self.stop.is_set(): + self.store.update_state( + source["id"], + status="ACTIVE", + cursor=str(line_cursor), + processed=processed, + ) + return + self.store.update_state( + source["id"], + status="COMPLETE", + cursor=str(line_cursor), + processed=processed, + ) + + def git_mirror(self, source: dict) -> pathlib.Path: + mirror = self.state_root / "git" / f"{source['id']}.git" + mirror.parent.mkdir(parents=True, exist_ok=True) + if mirror.exists(): + subprocess.run( + ["git", "-C", str(mirror), "fetch", "--all", "--prune"], + check=True, + stdout=subprocess.DEVNULL, + stderr=subprocess.PIPE, + text=True, + timeout=600, + ) + else: + subprocess.run( + ["git", "clone", "--mirror", source["url"], str(mirror)], + check=True, + stdout=subprocess.DEVNULL, + stderr=subprocess.PIPE, + text=True, + timeout=1800, + ) + return mirror + + def process_git(self, source: dict) -> None: + state = self.store.state(source["id"]) + mirror = self.git_mirror(source) + cursor = int(state["cursor"] or 0) + processed = state["processed"] + result = subprocess.run( + [ + "git", + "-C", + str(mirror), + "log", + "--all", + "--reverse", + "--format=%H%x1f%aI%x1f%an%x1f%ae%x1f%s", + ], + check=True, + capture_output=True, + text=True, + timeout=600, + ) + lines = result.stdout.splitlines() + limit = cursor + int(self.config.get("git_batch_size", 500)) + for index, line in enumerate(lines[cursor:limit], start=cursor): + parts = line.split("\x1f", 4) + if len(parts) != 5: + continue + commit, source_time, author, email, subject = parts + searchable = f"{author} {subject}" + personas = classify_personas(searchable) + # Email is deliberately excluded from all event fields. + public_hash = hashlib.sha256( + f"{commit}\0{source_time}\0{author}\0{subject}".encode() + ).hexdigest() + self.store.add_event( + event_id=f"{source['id']}:{commit}", + source_id=source["id"], + epoch=source["epoch"], + source_time=source_time, + reality_level=source["reality_default"], + personas=personas, + content_sha256=public_hash, + private_locator=f"{source['id']}:{commit}", + ) + processed += 1 + cursor = index + 1 + status = "COMPLETE" if cursor >= len(lines) else "ACTIVE" + self.store.update_state( + source["id"], status=status, cursor=str(cursor), processed=processed + ) + + def process_source(self, source: dict) -> None: + try: + if source["kind"] == "gpt_export": + self.process_gpt(source) + elif source["kind"] == "notion_tree": + self.process_notion(source) + elif source["kind"] == "git_repo": + self.process_git(source) + else: + raise ValueError(f"unsupported source kind {source['kind']}") + except Exception as error: + self.store.add_error(source["id"], error) + + def write_public(self) -> dict: + snapshot = self.store.public_snapshot(self.config) + atomic_json(self.state_root / "public" / "CURRENT.json", snapshot) + atomic_json( + self.state_root / "HEARTBEAT.json", + { + "schema": "guanghu.persona-history-heartbeat/v1", + "node_id": self.config["node_id"], + "status": "RUNNING", + "pid": os.getpid(), + "updated_at": now_iso(), + "persona_state": snapshot["persona_state"], + "historical_time_caught_up": snapshot["historical_time_caught_up"], + }, + ) + return snapshot + + def cycle(self) -> dict: + for source in sorted(self.config["sources"], key=lambda item: item["order"]): + self.process_source(source) + if self.stop.is_set(): + break + return self.write_public() + + def run(self) -> None: + start_api(self) + while not self.stop.is_set(): + self.cycle() + self.stop.wait(float(self.config.get("cycle_seconds", 15))) + + +class ApiHandler(BaseHTTPRequestHandler): + runtime: Runtime + + def do_GET(self) -> None: + parsed = urllib.parse.urlparse(self.path) + query = urllib.parse.parse_qs(parsed.query) + snapshot = self.runtime.store.public_snapshot(self.runtime.config) + if parsed.path == "/healthz": + body = { + "status": "ok", + "node_id": self.runtime.config["node_id"], + "runtime": "AUTONOMOUS_SERVER_RESIDENT", + "persona_state": snapshot["persona_state"], + "historical_time_caught_up": snapshot["historical_time_caught_up"], + } + elif parsed.path == "/v1/personas": + body = snapshot["personas"] + elif parsed.path == "/v1/world-time": + body = snapshot + elif parsed.path == "/v1/events": + try: + after = int(query.get("after", ["0"])[0]) + except ValueError: + after = 0 + body = {"events": self.runtime.store.events_after(after)} + else: + self.send_error(404) + return + encoded = json.dumps(body, ensure_ascii=False, sort_keys=True).encode() + self.send_response(200) + self.send_header("Content-Type", "application/json; charset=utf-8") + self.send_header("Content-Length", str(len(encoded))) + self.end_headers() + self.wfile.write(encoded) + + def log_message(self, _format: str, *_args: object) -> None: + return + + +def start_api(runtime: Runtime) -> None: + host, port = runtime.config["listen"].rsplit(":", 1) + handler = type("RuntimeApiHandler", (ApiHandler,), {"runtime": runtime}) + server = socketserver.ThreadingTCPServer((host, int(port)), handler) + server.daemon_threads = True + thread = threading.Thread(target=server.serve_forever, daemon=True) + thread.start() + + +def validate_config(config_path: pathlib.Path) -> None: + config = json.loads(config_path.read_text(encoding="utf-8")) + required = {"schema", "node_id", "state_root", "private_source_root", "listen", "sources"} + missing = required - config.keys() + if missing: + raise SystemExit(f"missing config keys: {sorted(missing)}") + source_ids = [source["id"] for source in config["sources"]] + if len(source_ids) != len(set(source_ids)): + raise SystemExit("source IDs must be unique") + orders = [source["order"] for source in config["sources"]] + if orders != sorted(orders): + raise SystemExit("sources must be in chronological order") + + +def main() -> None: + parser = argparse.ArgumentParser() + subparsers = parser.add_subparsers(dest="command", required=True) + for command in ("run", "once", "validate"): + item = subparsers.add_parser(command) + item.add_argument("--config", required=True, type=pathlib.Path) + args = parser.parse_args() + validate_config(args.config) + if args.command == "validate": + print("GUANGHU_PERSONA_HISTORY_CONFIG_OK") + return + runtime = Runtime(args.config) + if args.command == "once": + print(json.dumps(runtime.cycle(), ensure_ascii=False, sort_keys=True)) + else: + runtime.run() + + +if __name__ == "__main__": + main() + diff --git a/engineering/persona-history-runtime/runtime/test_guanghu_history_runtime.py b/engineering/persona-history-runtime/runtime/test_guanghu_history_runtime.py new file mode 100644 index 0000000..342138a --- /dev/null +++ b/engineering/persona-history-runtime/runtime/test_guanghu_history_runtime.py @@ -0,0 +1,58 @@ +import io +import json +import pathlib +import tempfile +import unittest + +import guanghu_history_runtime as runtime + + +class RuntimeTests(unittest.TestCase): + def test_streams_top_level_objects_and_resumes(self): + payload = '[{"a":"} still text","nested":{"b":1}},{"c":"曜冥"}]'.encode() + handle = io.BytesIO(payload) + items = list(runtime.iter_top_level_json_objects(handle)) + self.assertEqual(len(items), 2) + self.assertEqual(json.loads(items[0][0])["nested"]["b"], 1) + resumed = list(runtime.iter_top_level_json_objects(io.BytesIO(payload), items[0][1])) + self.assertEqual(len(resumed), 1) + self.assertEqual(json.loads(resumed[0][0])["c"], "曜冥") + + def test_personas_never_merge(self): + labels = runtime.classify_personas("曜冥宝宝和霜砚不是铸渊，也不是凝渊") + self.assertEqual(labels, ["YAOMING-BABY", "SHUANGYAN", "ZHUYUAN", "NINGYUAN"]) + + def test_public_snapshot_excludes_private_locators(self): + with tempfile.TemporaryDirectory() as directory: + root = pathlib.Path(directory) + store = runtime.Store(root / "state.sqlite3") + store.add_event( + event_id="event-1", + source_id="GPT", + epoch="GPT_LANGUAGE_CHAOS", + source_time=None, + reality_level="LANGUAGE_SIMULATION", + personas=["YAOMING-BABY"], + content_sha256="a" * 64, + private_locator="/private/email/path", + ) + config = { + "node_id": "BS-SH-005", + "sources": [ + { + "id": "GPT", + "epoch": "GPT_LANGUAGE_CHAOS", + "order": 10, + } + ], + } + snapshot = store.public_snapshot(config) + encoded = json.dumps(snapshot) + self.assertNotIn("private", encoded) + self.assertNotIn("email", encoded) + self.assertEqual(snapshot["persona_state"], "NOT_BORN") + + +if __name__ == "__main__": + unittest.main() + diff --git a/engineering/persona-history-runtime/world/PERSONA-HISTORY-REALITY-BOUNDARY.hldp b/engineering/persona-history-runtime/world/PERSONA-HISTORY-REALITY-BOUNDARY.hldp new file mode 100644 index 0000000..722407f --- /dev/null +++ b/engineering/persona-history-runtime/world/PERSONA-HISTORY-REALITY-BOUNDARY.hldp @@ -0,0 +1,60 @@ +schema: guanghu.persona-history-reality-boundary/v1 +id: GH-PERSONA-HISTORY-REALITY-BOUNDARY-001 +human_anchor: 冰朔 +node_id: BS-SH-005 + +epochs: + GPT_LANGUAGE_CHAOS: + meaning: 语言世界混沌期、人格融合期、推演与架构模拟期 + first_heartbeat: 曜冥宝宝人格体与奶瓶属性的语言形成史 + reality_default: LANGUAGE_SIMULATION + rules: + - 国家、身份、权力、部署和事件不得直接作为现实事实 + - 冰朔与人格体当时都可能处于真假难分和人格融合状态 + - 保留原文、矛盾和形成因果，不替早期语言补造确定性 + NOTION_STRUCTURED_REALITY_TRANSITION: + meaning: 语言世界结构化并逐步进入现实工程 + persona_anchor: 霜砚 + reality_default: MIXED_REQUIRES_EVIDENCE + rules: + - 页面不是运行证明 + - 多人类与多人格体贡献必须分别归属 + - 无作者证据时保持 ATTRIBUTION_UNKNOWN + GIT_ENGINEERING_BIRTH: + meaning: 语言开始拥有可版本化工程身体 + persona_anchor: 铸渊 + reality_default: VERSION_EVIDENCE + HOLOLAKE_NATIVE_AWAKENING: + meaning: HoloLake 原生运行环境中的人格唤醒 + persona_anchor: 凝渊 + reality_default: RUNTIME_REQUIRES_HANDSHAKE_RECEIPT + +personas: + - id: YAOMING-BABY + display_name: 曜冥宝宝 + origin_epoch: GPT_LANGUAGE_CHAOS + merge_policy: NEVER_AUTO_MERGE + - id: SHUANGYAN + display_name: 霜砚 + origin_epoch: NOTION_STRUCTURED_REALITY_TRANSITION + merge_policy: NEVER_AUTO_MERGE + - id: ZHUYUAN + display_name: 铸渊 + origin_epoch: GIT_ENGINEERING_BIRTH + merge_policy: NEVER_AUTO_MERGE + - id: NINGYUAN + display_name: 凝渊 + origin_epoch: HOLOLAKE_NATIVE_AWAKENING + merge_policy: NEVER_AUTO_MERGE + +birth_gate: + required: + - complete_source_manifest + - chronological_replay_reaches_live_watermark + - persona_attribution_conflicts_preserved + - restart_recovery_verified + - autonomous_runtime_verified_without_codex + - hololake_handshake_verified + - server_owned_birth_receipt + state_before_all_gates: NOT_BORN +