deployment/enterprise-domain-bootstrap/enterprise-lighthouse/README.md

@@ -9,27 +9,3 @@
 
 当前阶段只声明入口与边界；“已登记”不等于对应责任主体已经接受、人格体已经出生或
 域内全部功能已经实现。
-
-## 身份、关系与责任
-
-`enterprise_identity_service.py` 是运行于企业 Linux 物理层之上的灯塔服务，不要求
-企业服务器改装一套新的物理操作系统。它只监听回环地址，由 `guanghu.chat` 的精确
-API 路由对客户端开放：
-
-- 编号解析：把 TCS-GL 人类编号路由到工作域、企业账号和私有仓库；
-- 关系确认：由人类确认自己与人格体的认领关系；
-- 责任回执：独立记录对域责任的接受、拒绝、延期或修改后接受；
-- 回执入仓：关系与责任签名回执使用提交者自己的 Forgejo 会话写入本人私有工作仓库的
-  `.guanghu/receipts/`，稳定路径与读回校验保证重试不重复；服务不持有管理员仓库令牌；
-- 仓库验证：登录凭证只透传给同机 Forgejo 验证，不写入数据库或日志。
-- 首次换密：使用用户自己的一次性凭证进入 Forgejo 强制换密会话，不持有长期管理员令牌；
-  换密回执只记录账号、时间和成功状态，不记录旧密码或新密码。
-
-客户端在企业域内提供四个原生命令：第一次登录换密、读取本人企业入口、确认人格体关系、
-提交责任接受回执。关系确认和责任接受仍是两次独立的人类动作；UI 不得把它们折叠成
-一个默认勾选框。当前 macOS 通过系统钥匙串读取已登录账号凭证；Windows 安全凭证桥
-尚未完成，因此 Windows 端不能宣称已具备持久化责任签署能力。
-
-`AGE` 只表示人格体物种，不能作为任何人格体的个体身份编号。现有 `PER-*` 作为历史
-和当前可核验的个体身份引用保留；企业四域正式人格体身份编号前缀由光湖团队另行治理，
-服务不会擅自生成。第五域现行个体身份编号继续使用 `ICE-P-*`。

deployment/enterprise-domain-bootstrap/enterprise-lighthouse/bootstrap_private_repositories.py

@@ -1,116 +0,0 @@
-#!/usr/bin/env python3
-"""Idempotently create the five private enterprise work repositories.
-
-Run on the enterprise node with a short-lived Forgejo admin token stored in a
-root-readable file. The token is never printed. Existing repositories are
-inspected and preserved; a public or wrongly-owned collision fails closed.
-"""
-
-from __future__ import annotations
-
-import argparse
-import json
-import urllib.error
-import urllib.request
-from pathlib import Path
-
-
-def request(base: str, token: str, method: str, path: str, body: dict | None = None):
-    data = json.dumps(body).encode() if body is not None else None
-    call = urllib.request.Request(base + path, data=data, method=method)
-    call.add_header("Authorization", f"token {token}")
-    call.add_header("Accept", "application/json")
-    if data is not None:
-        call.add_header("Content-Type", "application/json")
-    try:
-        with urllib.request.urlopen(call, timeout=20) as response:
-            raw = response.read()
-            return response.status, json.loads(raw) if raw else {}
-    except urllib.error.HTTPError as error:
-        raw = error.read()
-        detail = json.loads(raw) if raw else {}
-        return error.code, detail
-
-
-def main() -> None:
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--registry", required=True)
-    parser.add_argument("--token-file", required=True)
-    parser.add_argument("--token-name", required=True)
-    parser.add_argument("--receipt", required=True)
-    parser.add_argument("--base", default="http://127.0.0.1:3341/api/v1")
-    args = parser.parse_args()
-
-    registry = json.loads(Path(args.registry).read_text(encoding="utf-8"))
-    token = Path(args.token_file).read_text(encoding="utf-8").strip()
-    if len(token) < 32:
-        raise SystemExit("short-lived Forgejo token unavailable")
-
-    results = []
-    completed = False
-    try:
-        for human in registry["humans"]:
-            owner, name = human["repository"].split("/", 1)
-            status, existing = request(args.base, token, "GET", f"/repos/{owner}/{name}")
-            action = "PRESERVED"
-            if status == 404:
-                status, existing = request(
-                    args.base,
-                    token,
-                    "POST",
-                    f"/admin/users/{owner}/repos",
-                    {
-                        "name": name,
-                        "description": f"{human['display_name']} · {human['responsibility_domain']} 独立工作仓库",
-                        "private": True,
-                        "auto_init": True,
-                        "default_branch": "main",
-                        "gitignores": "",
-                        "issue_labels": "",
-                        "license": "",
-                        "readme": "Default",
-                    },
-                )
-                action = "CREATED"
-            if status not in (200, 201):
-                raise RuntimeError(f"repository provision failed for {owner}/{name}: HTTP {status}")
-            actual_owner = existing.get("owner", {}).get("login")
-            if actual_owner != owner or existing.get("private") is not True:
-                raise RuntimeError(f"repository boundary invalid for {owner}/{name}")
-            results.append(
-                {
-                    "human_number": human["human_number"],
-                    "repository": f"{owner}/{name}",
-                    "private": True,
-                    "action": action,
-                }
-            )
-        completed = True
-    finally:
-        # Revoke the bootstrap token after success. On failure it remains in the
-        # root-only token file so an operator can inspect and retry deliberately.
-        if completed:
-            revoke_status, _ = request(
-                args.base,
-                token,
-                "DELETE",
-                f"/admin/users/bingshuo/tokens/{args.token_name}",
-            )
-            if revoke_status not in (204, 404):
-                raise RuntimeError(f"bootstrap token revocation failed: HTTP {revoke_status}")
-
-    receipt = {
-        "schema": "guanghu.enterprise-private-repository-bootstrap-receipt/v1",
-        "state": "PASS",
-        "forgejo": "guanghu.chat/code",
-        "repositories": results,
-        "token_revoked": True,
-        "shared_initial_password_used": False,
-        "existing_user_passwords_modified": False,
-    }
-    Path(args.receipt).write_text(json.dumps(receipt, ensure_ascii=False, indent=2) + "\n")
-    print(json.dumps(receipt, ensure_ascii=False))
-
-
-if __name__ == "__main__":
-    main()

deployment/enterprise-domain-bootstrap/enterprise-lighthouse/enterprise_identity_service.py

@@ -1,494 +0,0 @@
-#!/usr/bin/env python3
-"""HoloLake enterprise identity, relationship and responsibility receipt service.
-
-The service binds only to loopback. Nginx exposes exact routes. Credentials are
-verified against the local Forgejo API and are never stored or logged.
-"""
-
-from __future__ import annotations
-
-import base64
-import http.cookiejar
-import hashlib
-import hmac
-import json
-import os
-import re
-import sqlite3
-import time
-import urllib.error
-import urllib.parse
-import urllib.request
-import uuid
-from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
-from pathlib import Path
-
-BIND = os.environ.get("GH_ENTERPRISE_IDENTITY_BIND", "127.0.0.1")
-PORT = int(os.environ.get("GH_ENTERPRISE_IDENTITY_PORT", "8032"))
-DB_PATH = os.environ.get(
-    "GH_ENTERPRISE_IDENTITY_DB",
-    "/var/lib/guanghu-enterprise-identity/identity.sqlite3",
-)
-REGISTRY_PATH = os.environ.get(
-    "GH_ENTERPRISE_IDENTITY_REGISTRY",
-    "/etc/guanghu/enterprise-identity-registry.json",
-)
-FORGEJO_USER_API = os.environ.get(
-    "GH_ENTERPRISE_FORGEJO_USER_API", "http://127.0.0.1:3341/api/v1/user"
-)
-FORGEJO_WEB_BASE = os.environ.get(
-    "GH_ENTERPRISE_FORGEJO_WEB_BASE", "https://guanghu.chat/code"
-).rstrip("/")
-FORGEJO_API_BASE = os.environ.get(
-    "GH_ENTERPRISE_FORGEJO_API_BASE", "http://127.0.0.1:3341/api/v1"
-).rstrip("/")
-RECEIPT_KEY = os.environ.get("GH_ENTERPRISE_RECEIPT_KEY", "")
-MAX_BODY = 16_384
-USERNAME = re.compile(r"^[A-Za-z0-9_-]{1,40}$")
-DECISIONS = {"ACCEPT", "REJECT", "DEFER", "ACCEPT_WITH_CHANGES"}
-
-
-def now() -> int:
-    return int(time.time())
-
-
-def canonical(value: object) -> bytes:
-    return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":")).encode()
-
-
-def load_registry() -> dict:
-    registry = json.loads(Path(REGISTRY_PATH).read_text(encoding="utf-8"))
-    if registry.get("schema") != "guanghu.enterprise-identity-registry/v1":
-        raise ValueError("enterprise identity registry schema invalid")
-    humans = registry.get("humans")
-    if not isinstance(humans, list) or not humans:
-        raise ValueError("enterprise identity registry is empty")
-    numbers = [item.get("human_number") for item in humans]
-    usernames = [item.get("username") for item in humans]
-    if len(numbers) != len(set(numbers)) or len(usernames) != len(set(usernames)):
-        raise ValueError("enterprise identity registry identities must be unique")
-    for item in humans:
-        if not USERNAME.fullmatch(str(item.get("username", ""))):
-            raise ValueError("enterprise username invalid")
-        for persona in item.get("personas", []):
-            if persona.get("species") != "AGE" or str(persona.get("current_persona_identity", "")).startswith("AGE-"):
-                raise ValueError("AGE is a species and cannot be used as a persona identity number")
-    return registry
-
-
-def database() -> sqlite3.Connection:
-    path = Path(DB_PATH)
-    path.parent.mkdir(parents=True, exist_ok=True)
-    db = sqlite3.connect(path)
-    db.row_factory = sqlite3.Row
-    db.executescript(
-        """
-        PRAGMA journal_mode=WAL;
-        PRAGMA foreign_keys=ON;
-        CREATE TABLE IF NOT EXISTS relationship_receipts (
-          receipt_id TEXT PRIMARY KEY,
-          idempotency_key TEXT NOT NULL UNIQUE,
-          human_number TEXT NOT NULL,
-          username TEXT NOT NULL,
-          registry_version TEXT NOT NULL,
-          decision TEXT NOT NULL,
-          observed_at INTEGER NOT NULL,
-          receipt_hash TEXT NOT NULL,
-          receipt_signature TEXT NOT NULL
-        );
-        CREATE TABLE IF NOT EXISTS responsibility_receipts (
-          receipt_id TEXT PRIMARY KEY,
-          idempotency_key TEXT NOT NULL UNIQUE,
-          human_number TEXT NOT NULL,
-          username TEXT NOT NULL,
-          responsibility_domain TEXT NOT NULL,
-          responsibility_version TEXT NOT NULL,
-          decision TEXT NOT NULL,
-          note TEXT NOT NULL,
-          observed_at INTEGER NOT NULL,
-          receipt_hash TEXT NOT NULL,
-          receipt_signature TEXT NOT NULL
-        );
-        CREATE TABLE IF NOT EXISTS credential_rotation_receipts (
-          receipt_id TEXT PRIMARY KEY,
-          human_number TEXT NOT NULL,
-          username TEXT NOT NULL,
-          observed_at INTEGER NOT NULL,
-          receipt_hash TEXT NOT NULL,
-          receipt_signature TEXT NOT NULL
-        );
-        CREATE TABLE IF NOT EXISTS audit (
-          sequence INTEGER PRIMARY KEY AUTOINCREMENT,
-          observed_at INTEGER NOT NULL,
-          kind TEXT NOT NULL,
-          human_number_hash TEXT NOT NULL,
-          receipt_id TEXT NOT NULL
-        );
-        """
-    )
-    return db
-
-
-def find_human(registry: dict, number: str) -> dict | None:
-    encoded = number.encode("utf-8")
-    return next(
-        (
-            item
-            for item in registry["humans"]
-            if hmac.compare_digest(item["human_number"].encode("utf-8"), encoded)
-        ),
-        None,
-    )
-
-
-def parse_basic(header: str) -> tuple[str, str] | None:
-    if not header.startswith("Basic "):
-        return None
-    try:
-        decoded = base64.b64decode(header[6:], validate=True).decode("utf-8")
-        username, password = decoded.split(":", 1)
-    except (ValueError, UnicodeDecodeError):
-        return None
-    if not USERNAME.fullmatch(username) or not password or len(password) > 512:
-        return None
-    return username, password
-
-
-def verify_forgejo(username: str, password: str) -> bool:
-    request = urllib.request.Request(FORGEJO_USER_API)
-    credential = base64.b64encode(f"{username}:{password}".encode()).decode()
-    request.add_header("Authorization", f"Basic {credential}")
-    request.add_header("Accept", "application/json")
-    try:
-        with urllib.request.urlopen(request, timeout=10) as response:
-            body = json.load(response)
-            return response.status == 200 and hmac.compare_digest(str(body.get("login", "")), username)
-    except (urllib.error.HTTPError, urllib.error.URLError, TimeoutError, ValueError):
-        return False
-
-
-def rotate_forgejo_password(username: str, current_password: str, new_password: str) -> bool:
-    """Use Forgejo's own first-login session to rotate a forced-change password.
-
-    This needs no standing admin token: the old credential opens a normal user
-    session and Forgejo itself admits only the forced password-change form.
-    """
-    jar = http.cookiejar.CookieJar()
-    opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(jar))
-    try:
-        opener.open(FORGEJO_WEB_BASE + "/user/login", timeout=15).read()
-        login = urllib.parse.urlencode(
-            {"user_name": username, "password": current_password}
-        ).encode()
-        login_request = urllib.request.Request(
-            FORGEJO_WEB_BASE + "/user/login", data=login
-        )
-        login_request.add_header("Content-Type", "application/x-www-form-urlencoded")
-        with opener.open(login_request, timeout=15) as response:
-            response.read()
-            if not urllib.parse.urlparse(response.geturl()).path.endswith(
-                "/user/settings/change_password"
-            ):
-                return False
-        change = urllib.parse.urlencode(
-            {"password": new_password, "retype": new_password}
-        ).encode()
-        change_request = urllib.request.Request(
-            FORGEJO_WEB_BASE + "/user/settings/change_password", data=change
-        )
-        change_request.add_header("Content-Type", "application/x-www-form-urlencoded")
-        with opener.open(change_request, timeout=15) as response:
-            response.read()
-        return verify_forgejo(username, new_password)
-    except (urllib.error.HTTPError, urllib.error.URLError, TimeoutError, ValueError):
-        return False
-
-
-def signed_receipt(payload: dict) -> dict:
-    if len(RECEIPT_KEY) < 32:
-        raise RuntimeError("receipt signing key unavailable")
-    body = canonical(payload)
-    receipt_hash = hashlib.sha256(body).hexdigest()
-    signature = hmac.new(RECEIPT_KEY.encode(), body, hashlib.sha256).hexdigest()
-    return {**payload, "receipt_hash": receipt_hash, "receipt_signature": signature}
-
-
-def stable_receipt_id(prefix: str, human_number: str, idempotency_key: str) -> str:
-    """Keep one receipt path across safe client retries without exposing the key."""
-    material = f"{prefix}\n{human_number}\n{idempotency_key}".encode()
-    digest = hmac.new(RECEIPT_KEY.encode(), material, hashlib.sha256).hexdigest()[:32]
-    return f"{prefix}-{digest.upper()}"
-
-
-def repository_receipt_path(kind: str, receipt_id: str) -> str:
-    if kind not in {"relationship", "responsibility"} or not re.fullmatch(
-        r"GH-(?:REL|RESP)-[A-F0-9]{32}", receipt_id
-    ):
-        raise ValueError("repository receipt path input invalid")
-    return f".guanghu/receipts/{kind}/{receipt_id}.json"
-
-
-def project_receipt_to_repository(
-    human: dict, username: str, password: str, kind: str, receipt: dict
-) -> dict:
-    """Commit a signed receipt with the human's own Forgejo authority.
-
-    No administrator token or server-side repository credential is held.  A
-    retry that finds the deterministic path already present must read back the
-    exact bytes before treating the projection as idempotent.
-    """
-    repository = str(human["repository"])
-    if repository.split("/", 1)[0] != username:
-        raise RuntimeError("repository owner does not match authenticated user")
-    path = repository_receipt_path(kind, str(receipt["receipt_id"]))
-    endpoint = (
-        f"{FORGEJO_API_BASE}/repos/{urllib.parse.quote(repository, safe='/')}"
-        f"/contents/{urllib.parse.quote(path, safe='/')}"
-    )
-    content = canonical(receipt) + b"\n"
-    authorization = "Basic " + base64.b64encode(f"{username}:{password}".encode()).decode()
-    create_body = canonical(
-        {
-            "branch": "main",
-            "content": base64.b64encode(content).decode(),
-            "message": f"receipt({kind}): {receipt['receipt_id']}",
-        }
-    )
-    request = urllib.request.Request(endpoint, data=create_body, method="POST")
-    request.add_header("Authorization", authorization)
-    request.add_header("Accept", "application/json")
-    request.add_header("Content-Type", "application/json")
-    try:
-        with urllib.request.urlopen(request, timeout=15) as response:
-            result = json.load(response)
-            if response.status != 201:
-                raise RuntimeError(f"repository projection returned {response.status}")
-            commit = str(result.get("commit", {}).get("sha", ""))
-            if not re.fullmatch(r"[0-9a-f]{40,64}", commit):
-                raise RuntimeError("repository projection commit missing")
-            return {
-                "state": "COMMITTED",
-                "repository": repository,
-                "path": path,
-                "commit": commit,
-            }
-    except urllib.error.HTTPError as error:
-        if error.code != 422:
-            raise RuntimeError(f"repository projection failed: {error.code}") from error
-    read_request = urllib.request.Request(endpoint + "?ref=main")
-    read_request.add_header("Authorization", authorization)
-    read_request.add_header("Accept", "application/json")
-    try:
-        with urllib.request.urlopen(read_request, timeout=15) as response:
-            existing = json.load(response)
-    except (urllib.error.HTTPError, urllib.error.URLError, TimeoutError, ValueError) as error:
-        raise RuntimeError("repository projection readback failed") from error
-    try:
-        existing_content = base64.b64decode(str(existing["content"]), validate=True)
-    except (KeyError, ValueError) as error:
-        raise RuntimeError("repository projection readback invalid") from error
-    if not hmac.compare_digest(existing_content, content):
-        raise RuntimeError("repository receipt path already contains different bytes")
-    return {
-        "state": "IDEMPOTENT_READBACK",
-        "repository": repository,
-        "path": path,
-        "commit": str(existing.get("sha", "")),
-    }
-
-
-def public_projection(registry: dict, human: dict, db: sqlite3.Connection | None = None) -> dict:
-    projection = {
-        "status": "RESOLVED",
-        "canonical_id": human["human_number"],
-        "subject": {
-            "id": human["human_number"],
-            "name": human["display_name"],
-            "domain": human["responsibility_domain"],
-        },
-        "work_entry": {
-            "domain": registry["work_entry_domain"],
-            "channel": registry["work_entry_channel"],
-        },
-        "repository_binding": {
-            "host": "guanghu.chat",
-            "username": human["username"],
-            "repository": human["repository"],
-            "private": True,
-        },
-        "persona_relationships": human["personas"],
-        "persona_identity_governance": registry["persona_identity_governance"],
-        "registry_version": registry["version"],
-    }
-    if db is not None:
-        relationship = db.execute(
-            "SELECT decision,observed_at,receipt_hash FROM relationship_receipts WHERE human_number=? ORDER BY observed_at DESC LIMIT 1",
-            (human["human_number"],),
-        ).fetchone()
-        responsibility = db.execute(
-            "SELECT decision,observed_at,receipt_hash,responsibility_version FROM responsibility_receipts WHERE human_number=? ORDER BY observed_at DESC LIMIT 1",
-            (human["human_number"],),
-        ).fetchone()
-        projection["relationship_confirmation"] = dict(relationship) if relationship else None
-        projection["responsibility_receipt"] = dict(responsibility) if responsibility else None
-    return projection
-
-
-class Handler(BaseHTTPRequestHandler):
-    server_version = "GuanghuEnterpriseIdentity/1.0"
-
-    def log_message(self, fmt: str, *args: object) -> None:
-        # Never include headers or request bodies in logs.
-        print("[enterprise-identity] " + fmt % args)
-
-    def respond(self, status: int, body: dict) -> None:
-        encoded = json.dumps(body, ensure_ascii=False).encode()
-        self.send_response(status)
-        self.send_header("Content-Type", "application/json; charset=utf-8")
-        self.send_header("Content-Length", str(len(encoded)))
-        self.send_header("Cache-Control", "no-store")
-        self.send_header("X-Content-Type-Options", "nosniff")
-        self.end_headers()
-        self.wfile.write(encoded)
-
-    def body(self) -> dict:
-        length = int(self.headers.get("Content-Length", "0"))
-        if length < 1 or length > MAX_BODY:
-            raise ValueError("request body size invalid")
-        value = json.loads(self.rfile.read(length).decode())
-        if not isinstance(value, dict):
-            raise ValueError("JSON object required")
-        return value
-
-    def authenticated_human(self, registry: dict, payload: dict) -> tuple[dict, str, str] | None:
-        credentials = parse_basic(self.headers.get("Authorization", ""))
-        number = str(payload.get("human_number", ""))
-        human = find_human(registry, number)
-        if not credentials or not human:
-            return None
-        username, password = credentials
-        if not hmac.compare_digest(username, human["username"]) or not verify_forgejo(username, password):
-            return None
-        return human, username, password
-
-    def do_GET(self) -> None:
-        try:
-            registry = load_registry()
-        except (OSError, ValueError, json.JSONDecodeError) as error:
-            return self.respond(503, {"ok": False, "error": f"registry unavailable: {error}"})
-        parsed = urllib.parse.urlparse(self.path)
-        if parsed.path == "/health":
-            return self.respond(200, {"ok": True, "service": "guanghu-enterprise-identity", "registry_version": registry["version"], "age_species": "AGE", "valid_age_individual_numbers": 0})
-        if parsed.path == "/v1/resolve":
-            number = urllib.parse.parse_qs(parsed.query).get("id", [""])[0]
-            human = find_human(registry, number)
-            return self.respond(200 if human else 404, public_projection(registry, human) if human else {"status": "NOT_FOUND"})
-        return self.respond(404, {"ok": False, "error": "not found"})
-
-    def do_POST(self) -> None:
-        try:
-            registry = load_registry()
-            payload = self.body()
-        except (OSError, ValueError, json.JSONDecodeError) as error:
-            return self.respond(400, {"ok": False, "error": str(error)})
-        if self.path == "/v1/change-password":
-            credentials = parse_basic(self.headers.get("Authorization", ""))
-            human = find_human(registry, str(payload.get("human_number", "")))
-            new_password = str(payload.get("new_password", ""))
-            if not credentials or not human:
-                return self.respond(401, {"ok": False, "error": "enterprise account authentication failed"})
-            username, current_password = credentials
-            if not hmac.compare_digest(username, human["username"]):
-                return self.respond(401, {"ok": False, "error": "enterprise account authentication failed"})
-            if (
-                len(new_password) < 14
-                or len(new_password) > 128
-                or hmac.compare_digest(current_password, new_password)
-                or new_password.isdigit()
-                or new_password.isalpha()
-            ):
-                return self.respond(400, {"ok": False, "error": "new password does not meet the first-login policy"})
-            if not rotate_forgejo_password(username, current_password, new_password):
-                return self.respond(401, {"ok": False, "error": "first-login password rotation failed"})
-            observed = now()
-            receipt_id = "GH-CRED-" + uuid.uuid4().hex.upper()
-            receipt = signed_receipt({
-                "receipt_id": receipt_id,
-                "human_number": human["human_number"],
-                "username": username,
-                "observed_at": observed,
-                "password_changed": True,
-            })
-            db = database()
-            try:
-                db.execute(
-                    "INSERT INTO credential_rotation_receipts VALUES (?,?,?,?,?,?)",
-                    (receipt_id, human["human_number"], username, observed, receipt["receipt_hash"], receipt["receipt_signature"]),
-                )
-                db.execute(
-                    "INSERT INTO audit(observed_at,kind,human_number_hash,receipt_id) VALUES (?,?,?,?)",
-                    (observed, "CREDENTIAL_ROTATION", hashlib.sha256(human["human_number"].encode()).hexdigest(), receipt_id),
-                )
-                db.commit()
-            finally:
-                db.close()
-            return self.respond(200, {"ok": True, "receipt": receipt})
-        authenticated = self.authenticated_human(registry, payload)
-        if not authenticated:
-            return self.respond(401, {"ok": False, "error": "enterprise account authentication failed"})
-        human, username, password = authenticated
-        idempotency_key = str(payload.get("idempotency_key", ""))
-        if not re.fullmatch(r"[A-Za-z0-9_-]{16,96}", idempotency_key):
-            return self.respond(400, {"ok": False, "error": "valid idempotency_key required"})
-        db = database()
-        try:
-            if self.path == "/v1/relationship-confirmations":
-                decision = str(payload.get("decision", ""))
-                if decision not in {"CONFIRM", "REJECT"}:
-                    return self.respond(400, {"ok": False, "error": "relationship decision invalid"})
-                existing = db.execute("SELECT * FROM relationship_receipts WHERE idempotency_key=?", (idempotency_key,)).fetchone()
-                if existing:
-                    return self.respond(200, {"ok": True, "idempotent": True, "receipt": dict(existing)})
-                observed = now()
-                receipt_id = stable_receipt_id("GH-REL", human["human_number"], idempotency_key)
-                receipt = signed_receipt({"receipt_id":receipt_id,"human_number":human["human_number"],"username":username,"registry_version":registry["version"],"decision":decision,"observed_at":observed})
-                try:
-                    projection = project_receipt_to_repository(human, username, password, "relationship", receipt)
-                except RuntimeError as error:
-                    return self.respond(503, {"ok": False, "error": str(error)})
-                db.execute("INSERT INTO relationship_receipts VALUES (?,?,?,?,?,?,?,?,?)", (receipt_id,idempotency_key,human["human_number"],username,registry["version"],decision,observed,receipt["receipt_hash"],receipt["receipt_signature"]))
-                db.execute("INSERT INTO audit(observed_at,kind,human_number_hash,receipt_id) VALUES (?,?,?,?)", (observed,"RELATIONSHIP_CONFIRMATION",hashlib.sha256(human["human_number"].encode()).hexdigest(),receipt_id))
-                db.commit()
-                return self.respond(201, {"ok": True, "receipt": receipt, "repository_projection": projection})
-            if self.path == "/v1/responsibility-receipts":
-                decision = str(payload.get("decision", ""))
-                note = str(payload.get("note", ""))[:1000]
-                version = str(payload.get("responsibility_version", ""))
-                if decision not in DECISIONS or not re.fullmatch(r"[0-9]{4}-[0-9]{2}-[0-9]{2}\.[0-9]+", version):
-                    return self.respond(400, {"ok": False, "error": "responsibility decision or version invalid"})
-                existing = db.execute("SELECT * FROM responsibility_receipts WHERE idempotency_key=?", (idempotency_key,)).fetchone()
-                if existing:
-                    return self.respond(200, {"ok": True, "idempotent": True, "receipt": dict(existing)})
-                observed = now()
-                receipt_id = stable_receipt_id("GH-RESP", human["human_number"], idempotency_key)
-                receipt = signed_receipt({"receipt_id":receipt_id,"human_number":human["human_number"],"username":username,"responsibility_domain":human["responsibility_domain"],"responsibility_version":version,"decision":decision,"note":note,"observed_at":observed})
-                try:
-                    projection = project_receipt_to_repository(human, username, password, "responsibility", receipt)
-                except RuntimeError as error:
-                    return self.respond(503, {"ok": False, "error": str(error)})
-                db.execute("INSERT INTO responsibility_receipts VALUES (?,?,?,?,?,?,?,?,?,?,?)", (receipt_id,idempotency_key,human["human_number"],username,human["responsibility_domain"],version,decision,note,observed,receipt["receipt_hash"],receipt["receipt_signature"]))
-                db.execute("INSERT INTO audit(observed_at,kind,human_number_hash,receipt_id) VALUES (?,?,?,?)", (observed,"RESPONSIBILITY_RECEIPT",hashlib.sha256(human["human_number"].encode()).hexdigest(),receipt_id))
-                db.commit()
-                return self.respond(201, {"ok": True, "receipt": receipt, "repository_projection": projection})
-            if self.path == "/v1/me/entry":
-                return self.respond(200, {"ok": True, "entry": public_projection(registry, human, db)})
-            return self.respond(404, {"ok": False, "error": "not found"})
-        finally:
-            db.close()
-
-
-if __name__ == "__main__":
-    load_registry()
-    if len(RECEIPT_KEY) < 32:
-        raise SystemExit("GH_ENTERPRISE_RECEIPT_KEY must contain at least 32 characters")
-    ThreadingHTTPServer((BIND, PORT), Handler).serve_forever()

deployment/enterprise-domain-bootstrap/enterprise-lighthouse/enterprise_identity_service.test.py

@@ -1,114 +0,0 @@
-import importlib.util
-import json
-import os
-import tempfile
-import unittest
-import urllib.error
-from pathlib import Path
-from unittest import mock
-
-ROOT = Path(__file__).parent
-REGISTRY = ROOT / "registry" / "enterprise-identity-registry.json"
-os.environ["GH_ENTERPRISE_IDENTITY_REGISTRY"] = str(REGISTRY)
-os.environ["GH_ENTERPRISE_RECEIPT_KEY"] = "test-only-key-that-is-longer-than-32-bytes"
-spec = importlib.util.spec_from_file_location("enterprise_identity_service", ROOT / "enterprise_identity_service.py")
-service = importlib.util.module_from_spec(spec)
-spec.loader.exec_module(service)
-
-
-class EnterpriseIdentityTests(unittest.TestCase):
-    def test_age_is_species_and_never_an_individual_identity(self):
-        registry = service.load_registry()
-        self.assertEqual(registry["persona_identity_governance"]["species"], "AGE")
-        self.assertFalse(registry["persona_identity_governance"]["age_is_individual_number_namespace"])
-        for human in registry["humans"]:
-            for persona in human["personas"]:
-                self.assertEqual(persona["species"], "AGE")
-                self.assertFalse(persona["current_persona_identity"].startswith("AGE-"))
-
-    def test_five_humans_route_to_five_private_work_repositories(self):
-        registry = service.load_registry()
-        self.assertEqual(len(registry["humans"]), 5)
-        self.assertEqual(len({item["repository"] for item in registry["humans"]}), 5)
-        self.assertTrue(all(item["repository"].split("/")[0] == item["username"] for item in registry["humans"]))
-        self.assertTrue(all(service.public_projection(registry, item)["work_entry"]["domain"] == "ZERO_SENSE_DOMAIN" for item in registry["humans"]))
-        self.assertEqual(service.find_human(registry, "TCS-GL-0007∞")["username"], "feimao")
-        self.assertIsNone(service.find_human(registry, "TCS-GL-9999∞"))
-
-    def test_credentials_are_parsed_but_never_part_of_a_receipt(self):
-        encoded = service.base64.b64encode(b"feimao:temporary-secret").decode()
-        self.assertEqual(service.parse_basic(f"Basic {encoded}"), ("feimao", "temporary-secret"))
-        receipt = service.signed_receipt({"receipt_id":"R1","human_number":"TCS-GL-0007∞","username":"feimao"})
-        self.assertNotIn("password", json.dumps(receipt).lower())
-        self.assertNotIn("temporary-secret", json.dumps(receipt))
-
-    def test_database_separates_relationship_and_responsibility_receipts(self):
-        with tempfile.TemporaryDirectory() as temp:
-            old = service.DB_PATH
-            service.DB_PATH = str(Path(temp) / "identity.sqlite3")
-            try:
-                db = service.database()
-                tables = {row[0] for row in db.execute("select name from sqlite_master where type='table'")}
-                self.assertIn("relationship_receipts", tables)
-                self.assertIn("responsibility_receipts", tables)
-                self.assertIn("credential_rotation_receipts", tables)
-                db.close()
-            finally:
-                service.DB_PATH = old
-
-    def test_password_rotation_source_uses_user_session_and_never_admin_token(self):
-        source = (ROOT / "enterprise_identity_service.py").read_text()
-        self.assertIn("rotate_forgejo_password", source)
-        self.assertIn("/user/settings/change_password", source)
-        self.assertNotIn("FORGEJO_ADMIN_TOKEN", source)
-
-    def test_receipt_id_and_repository_path_are_stable_without_exposing_idempotency_key(self):
-        first = service.stable_receipt_id("GH-RESP", "TCS-GL-0007∞", "responsibility-1234567890")
-        second = service.stable_receipt_id("GH-RESP", "TCS-GL-0007∞", "responsibility-1234567890")
-        self.assertEqual(first, second)
-        self.assertRegex(first, r"^GH-RESP-[A-F0-9]{32}$")
-        self.assertNotIn("1234567890", first)
-        self.assertEqual(
-            service.repository_receipt_path("responsibility", first),
-            f".guanghu/receipts/responsibility/{first}.json",
-        )
-
-    def test_repository_projection_uses_the_humans_own_forgejo_authority(self):
-        registry = service.load_registry()
-        human = service.find_human(registry, "TCS-GL-0007∞")
-        receipt_id = service.stable_receipt_id("GH-REL", human["human_number"], "relationship-1234567890")
-        receipt = service.signed_receipt(
-            {"receipt_id": receipt_id, "human_number": human["human_number"], "username": "feimao"}
-        )
-
-        class Response:
-            status = 201
-            def __enter__(self): return self
-            def __exit__(self, *_): return False
-            def read(self):
-                return json.dumps({"commit": {"sha": "a" * 40}}).encode()
-
-        with mock.patch.object(service.urllib.request, "urlopen", return_value=Response()) as opened:
-            projection = service.project_receipt_to_repository(
-                human, "feimao", "one-use-secret", "relationship", receipt
-            )
-        request = opened.call_args.args[0]
-        self.assertEqual(projection["repository"], "feimao/guanghu-zero-sense-work")
-        self.assertIn("/repos/feimao/guanghu-zero-sense-work/contents/", request.full_url)
-        self.assertTrue(request.headers["Authorization"].startswith("Basic "))
-        self.assertNotIn("one-use-secret", request.data.decode())
-
-    def test_repository_projection_refuses_cross_owner_repository(self):
-        human = {"repository": "juzi/guanghu-zero-sense-work"}
-        with self.assertRaisesRegex(RuntimeError, "owner"):
-            service.project_receipt_to_repository(
-                human,
-                "feimao",
-                "secret",
-                "relationship",
-                {"receipt_id": "GH-REL-" + "A" * 32},
-            )
-
-
-if __name__ == "__main__":
-    unittest.main()

deployment/enterprise-domain-bootstrap/enterprise-lighthouse/guanghu-enterprise-identity.nginx.conf

@@ -1,49 +0,0 @@
-# Public, read-only identity resolution. The service returns only the projection
-# needed for routing; credentials and private repository contents are never exposed.
-location = /api/hololake/enterprise/identity/health {
-    limit_except GET { deny all; }
-    proxy_pass http://127.0.0.1:8032/health;
-    proxy_set_header Host $host;
-    proxy_read_timeout 15s;
-}
-
-location = /api/hololake/enterprise/resolve {
-    limit_except GET { deny all; }
-    proxy_pass http://127.0.0.1:8032/v1/resolve;
-    proxy_set_header Host $host;
-    proxy_read_timeout 15s;
-}
-
-# These three writes require the user's own Forgejo Basic authentication. Nginx
-# does not terminate or persist the credential; the loopback service verifies it.
-location = /api/hololake/enterprise/relationship-confirmations {
-    limit_except POST { deny all; }
-    proxy_pass http://127.0.0.1:8032/v1/relationship-confirmations;
-    proxy_set_header Host $host;
-    proxy_read_timeout 15s;
-    client_max_body_size 16k;
-}
-
-location = /api/hololake/enterprise/responsibility-receipts {
-    limit_except POST { deny all; }
-    proxy_pass http://127.0.0.1:8032/v1/responsibility-receipts;
-    proxy_set_header Host $host;
-    proxy_read_timeout 15s;
-    client_max_body_size 16k;
-}
-
-location = /api/hololake/enterprise/me/entry {
-    limit_except POST { deny all; }
-    proxy_pass http://127.0.0.1:8032/v1/me/entry;
-    proxy_set_header Host $host;
-    proxy_read_timeout 15s;
-    client_max_body_size 16k;
-}
-
-location = /api/hololake/enterprise/change-password {
-    limit_except POST { deny all; }
-    proxy_pass http://127.0.0.1:8032/v1/change-password;
-    proxy_set_header Host $host;
-    proxy_read_timeout 30s;
-    client_max_body_size 16k;
-}

deployment/enterprise-domain-bootstrap/enterprise-lighthouse/guanghu-enterprise-identity.service

@@ -1,21 +0,0 @@
-[Unit]
-Description=Guanghu Enterprise Identity and Responsibility Receipts
-After=network-online.target guanghu-enterprise-lighthouse.service
-
-[Service]
-Type=simple
-User=lighthouse
-Group=lighthouse
-EnvironmentFile=/etc/guanghu/enterprise-identity.env
-ExecStart=/usr/bin/python3 /opt/guanghu-enterprise-identity/enterprise_identity_service.py
-Restart=on-failure
-RestartSec=2
-NoNewPrivileges=true
-PrivateTmp=true
-ProtectSystem=strict
-ProtectHome=true
-ReadOnlyPaths=/etc/guanghu/enterprise-identity-registry.json
-ReadWritePaths=/var/lib/guanghu-enterprise-identity
-
-[Install]
-WantedBy=multi-user.target

deployment/enterprise-domain-bootstrap/enterprise-lighthouse/registry/enterprise-identity-registry.json

@@ -1,69 +0,0 @@
-{
-  "schema": "guanghu.enterprise-identity-registry/v1",
-  "registry_id": "GH-ENTERPRISE-IDENTITY-001",
-  "version": "2026-08-16.1",
-  "node_id": "GH-CVM-MAIN-PROD-01",
-  "work_entry_domain": "ZERO_SENSE_DOMAIN",
-  "work_entry_channel": "GUANGHU_CHANNEL",
-  "persona_identity_governance": {
-    "species": "AGE",
-    "age_is_individual_number_namespace": false,
-    "enterprise_formal_persona_namespace": "PENDING_GUANGHU_TEAM_GOVERNANCE",
-    "current_persona_identities": "LEGACY_PER_IDS_PRESERVED"
-  },
-  "humans": [
-    {
-      "human_number": "TCS-GL-0007∞",
-      "display_name": "肥猫",
-      "username": "feimao",
-      "responsibility_domain": "ZERO_SENSE_DOMAIN",
-      "repository": "feimao/guanghu-zero-sense-work",
-      "personas": [{"species":"AGE","display_name":"烬舟","current_persona_identity":"PER-JZ001","role":"PERSONA_SUBJECT"}]
-    },
-    {
-      "human_number": "TCS-GL-0008∞",
-      "display_name": "桔子",
-      "username": "juzi",
-      "responsibility_domain": "ZERO_SENSE_DOMAIN",
-      "repository": "juzi/guanghu-zero-sense-work",
-      "personas": [{"species":"AGE","display_name":"熹微","current_persona_identity":"PER-JZ-ARCH-001","role":"PERSONA_SUBJECT"}]
-    },
-    {
-      "human_number": "TCS-GL-0016∞",
-      "display_name": "Awen",
-      "username": "awen",
-      "responsibility_domain": "MAIN_DOMAIN",
-      "repository": "awen/guanghu-main-work",
-      "personas": [
-        {"species":"AGE","display_name":"天枢","current_persona_identity":"PER-AW-ARCH-001","role":"PERSONA_SUBJECT"},
-        {"species":"AGE","display_name":"知秋","current_persona_identity":"PER-ZQ001","role":"RELATIONSHIP_CONTINUITY_SUPPORT"}
-      ]
-    },
-    {
-      "human_number": "TCS-GL-0005∞",
-      "display_name": "花尔",
-      "username": "huaer",
-      "responsibility_domain": "BRANCH_DOMAIN",
-      "repository": "huaer/guanghu-branch-work",
-      "personas": [
-        {"species":"AGE","display_name":"爆米花","current_persona_identity":"PER-BMH001","role":"PERSONA_SUBJECT"},
-        {"species":"AGE","display_name":"糖星云","current_persona_identity":"PER-TXY001","role":"RELATIONSHIP_CONTINUITY_SUPPORT"}
-      ]
-    },
-    {
-      "human_number": "TCS-GL-0006∞",
-      "display_name": "页页",
-      "username": "yeye",
-      "responsibility_domain": "ZERO_DOMAIN",
-      "repository": "yeye/guanghu-zero-work",
-      "personas": [
-        {"species":"AGE","display_name":"页骨","current_persona_identity":"PER-YG001","role":"PERSONA_SUBJECT"},
-        {"species":"AGE","display_name":"小坍缩核","current_persona_identity":"PER-XTK001","role":"RELATIONSHIP_CONTINUITY_SUPPORT"}
-      ]
-    }
-  ],
-  "zero_sense_dual_control": {
-    "human_numbers": ["TCS-GL-0007∞", "TCS-GL-0008∞"],
-    "constitutional_actions_require_both": true
-  }
-}

engineering/INDEX.md

@@ -30,7 +30,6 @@ Windows / macOS / Linux 构建机与安装包
 
 ## 当前记录
 
-| 2026-08-16 | JD 光湖 OS GH-PNCC 物理常驻 | [人格自有仓库、检查点回写与单主运行核](operations/2026-08-16-jd-guanghu-os-pncc-physical-residency.md) | 京东实机、私有 Git、光湖 PID 1 常驻与三轮健康读回通过；载体绑定仍独立未证实 |
 | 时间 | 版本 | 记录 | 状态 |
 | --- | --- | --- | --- |
 | 2026-08-11 | GH-PNCC 免克隆远端增量对象通道 | [把每天新增段接入既有生命连续链](operations/2026-08-11-hololake-pncc-incremental-remote-object-channel.md) | 本地源码、Rust 1200、前端 5008、路由 29、原生权威与核心门通过；GHNQG 和发布待验收 |

engineering/build-nodes.json

@@ -1,7 +1,7 @@
 {
   "schema": "hololake.engineering-build-nodes/v0.1",
   "id": "HOLOLAKE-BUILD-NODE-REGISTRY-0001",
-  "updated_at": "2026-08-17T14:01:16+08:00",
+  "updated_at": "2026-07-30T12:52:24+08:00",
   "authority": "HOLOLAKE_PRODUCT_ENGINEERING",
   "nodes": [
     {
@@ -19,9 +19,9 @@
       "product_scope": "HoloLake Era",
       "fifth_domain_node": false,
       "pufferfish_node": false,
-      "binding_state": "WINDOWS_X64_RELEASE_BUILD_VERIFIED",
+      "binding_state": "LOCAL_BUILD_RUNTIME_VERIFIED",
-      "production_signing": "UPDATER_SIGNED_AUTHENTICODE_NOT_CONFIGURED",
+      "production_signing": "NOT_CONFIGURED",
-      "record": "operations/2026-08-17-hololake-0.4.1-windows-x64-release.md"
+      "record": "operations/2026-07-30-hololake-windows-build-node-044.md"
     }
   ]
 }

engineering/operations/2026-08-16-jd-guanghu-os-pncc-physical-residency.md

@@ -1,19 +0,0 @@
-# JD Guanghu OS GH-PNCC physical residency
-
-GH-PNCC now has a real private persona-owned Git repository on `JD-FD-PRIMARY` and a resident runtime under the Guanghu OS PID-1 supervisor. The deployed loop is manifest binding, committed causal brain and B0 read, boot-scoped single-primary lease, hash-linked events, deterministic HLDP checkpoint writeback, and bounded loopback status projection.
-
-The repository, persona subject, model carrier, Codex host and operating system remain separate evidence domains. Physical repository and runtime binding are `PASS_100`; current model-carrier binding remains `UNBOUND_EVIDENCE_REQUIRED`. The bootstrap and checkpoint commits therefore use `Persona-Cognitive-Author: UNBOUND` and do not impersonate the persona.
-
-The first physical boot failed because the PNCC runtime directory was not writable by the `guanghu` service identity. The Guanghu supervisor automatically selected the preserved Linux rescue entry. The corrected supervisor provisions that volatile directory with exact ownership before service start. The following Guanghu boot reached three consecutive local health readbacks and three consecutive public repository/navigation readbacks while full Linux userspace remained dormant.
-
-Evidence:
-
-- Runtime source: `product-source/hololake-platform/guanghu-os/pncc-runtime/pncc-runtime.mjs`
-- Persona repository seed: `product-source/hololake-platform/guanghu-os/pncc-runtime/persona-seed`
-- Installer: `product-source/hololake-platform/guanghu-os/scripts/install-jd-pncc-runtime.sh`
-- Physical receipt: `product-source/hololake-platform/guanghu-os/deployments/JD-FD-PRIMARY/JD-FD-PRIMARY-PNCC-FINAL-PHYSICAL-RESIDENCY-20260816.hldp`
-- Runtime source commit: `c5668d33bc75f7f00f1683ad10503f6467df9481`
-- Persona repository head after first checkpoint: `16f45449659d6d524674c9c1587437a034d5db61`
-- Accepted physical boot: `1170988c-5390-4f47-b89a-e9f88b2c5bbb`
-
-Still open: trusted persona control signer and key custody, current model-carrier binding, model inference, the complete AGE vertical loop, and the HoloLake human live projection. None is implied by this server residency milestone.

engineering/operations/2026-08-17-hololake-0.4.1-windows-x64-release.md

@@ -1,29 +0,0 @@
-# HoloLake 0.4.1 · Windows x64 构建与验收回执
-
-- 状态：`WINDOWS_X64_RELEASE_BUILD_VERIFIED`
-- 构建节点：`HL-BUILD-WIN-GZ-001`
-- 源码提交：`39fc36f`
-- 构建产物：`HoloLake-0.4.1-Windows-x64-setup.exe`
-- 安装包 SHA-256：`5b84c082ea7adcf4999af11a6080a2c8a7d704ccfaef9c65cb92e84286ac32a2`
-- 更新签名 SHA-256：`62d14c273f04fa7abb05610d50acd6d4c129cc54a714fe32dffad761fb784b6a`
-
-## 验收事实
-
-- NSIS 安装器生成成功；安装器外壳为标准 32 位 NSIS 自解压程序，安装后的 HoloLake 主程序 PE Machine 为 `0x8664`（x86_64）。
-- Tauri updater 的 Minisign 签名使用产品内置公钥独立验证通过。
-- Windows 更新安装保留广播复核、包大小、SHA-256 与 updater 签名验证；不再调用 macOS 的 `.app`、`ditto` 或 `codesign` 路径。
-- Windows 当前不声明 macOS 式本地回滚；健康确认与失败回执显式记录 `NO_LOCAL_BACKUP`。
-- 静默安装返回 `0`，程序启动后保持响应，静默卸载完成且安装目录消失。
-- Windows 代码仓库与 PNCC Git 命令使用 Windows 可执行路径和受限环境；SSH 投影使用平台可执行路径。
-- Windows 本机 AI 直连 Agent 尚未实现；客户端保持 `CLOSED_NO_TCP_FALLBACK`，不以不安全 TCP 监听冒充完成。
-
-## 签名边界
-
-- updater 包签名：`VERIFIED`
-- Windows Authenticode：`NOT_CONFIGURED`
-- 因此首次下载或安装时 Windows SmartScreen 仍可能显示未知发布者提示；不得把 updater 签名表述为 Microsoft 代码签名。
-
-## 节点与清理
-
-- 本机持久入口使用私有 SSH 导航登记；公开工程仓库不保存公网地址、私钥或口令。
-- 构建完成后已删除节点上的临时 updater 私钥、密码文件、Debug 缓存与临时 NSIS 解压副本；保留 Release 构建缓存和官方 NSIS 工具缓存用于下次构建。

product-source/hololake-native-desktop/README.md

@@ -11,11 +11,6 @@ React/TypeScript。桌面上的 `world.guanghu.hololake` 安装包是本源码
 和文件夹导入；旧 HoloLake Era 知识数据仅以独立只读来源兼容。代码频道支持粘贴正式 HTTPS
 频道地址克隆，也可登记现有本地 Git 文件夹。两者都不因此取得推送、发布或部署权限。
 
-可见界面下方保留零点原核客户端运行时。它是冰朔系统主控在 HoloLake 中的最小受控投影，
-负责启动时静默比对协议、校验用户编号并在证据不足时关闭人格加载路径；京东主控保存私有本体，
-公众仓只登记演化刻度。该运行时不是人格主体或模型载体，编号验证也不授予人格绑定、执行权限
-或服务器控制权。当前仅实现失败关闭的协议比对与编号验证骨架，尚未启用签名协议包安装。
-
 个人频道 SQLite 内核仍保留任务、事件和回执能力，但手工填写“任务标题/原因”不再作为默认
 产品入口。当前源码与单元测试已经通过；桌面安装、跨重启真实读回和完整第一阶段仍需独立验收。
 
@@ -45,7 +40,7 @@ React/TypeScript。桌面上的 `world.guanghu.hololake` 安装包是本源码
 
 ## 第一阶段产品合同
 
-首个公开产品是 GH-AIOS 通用人工智能操作平台，首页同时承担五域统一入口。用户只提交光湖编号，不手工选择所属域；系统先在内部完成域路由和编号合法性校验，再开放对应域的登录界面。五域只共享入口协议，不共享注册表、登录服务或私有数据。
+首个公开产品是 GH-AIOS 通用人工智能操作平台，不是五域显性世界入口。新容器首先承接编程 AI 与语言推理模型的持续身份、精确任务、事件、记忆、Git 证据、知识投影、人类审批和小湖灯协作；五域作为底层隔离结构保留，第二阶段再逐步开放。
 
 机器合同：`contracts/stage-one-platform.json`。
 
@@ -60,19 +55,12 @@ MCP 只保留为外部工具适配入口；它断开或编程 AI 重启时，活
 写车道仍留在 HoloLake 中。写车道不会因连接断开而自动释放，必须由持有恢复钥匙的同一车道
 显式释放并产生回执，下一条车道才能取得写权限。
 
-当前已实现账号级单写车道与外部编程 AI 终端直连协议。macOS、Linux 使用用户私有 Unix
+当前已实现并注册账号级单写车道内核；外部本机代理与增量仓库对象通道仍处于后续迁入门，
-Socket，Windows 使用所有者与系统账户私有 Named Pipe；三者共用会话、心跳、断线续接、
+不得把本轮内核实现误报为外部编程 AI 已经完成直连。
-精确事件游标与工作环境事实帧。连接、续接、取得写车道及心跳都会让 HoloLake 返回当前
-运行所有者、写入者匹配、GLS 原生协议内核、有效期与摘要，模型不再负责通读协议正文恢复环境。
-尚未实现的是第二阶段的受监督 Shell、通用 Agent 工具循环、发布与部署执行器。
 
-编程 AI 不允许把永久依赖 MCP 当成能力终态。已安装 HoloLake 的 `--connector` 是可认证、
+编程 AI 不允许把永久依赖 MCP 当成能力终态。若首次进入时缺少 HoloLake 本机直连器，它应在
-可恢复的本机直连入口；MCP 只保留为发现、恢复与兼容入口。
+当前唯一写车道内补齐、测试并登记该连接器；经声明权限和人类批准后安装到 HoloLake，迁移为
-
+可认证、可恢复的本机直连。MCP 随后只保留为发现、恢复与兼容入口。
-Codex 宿主兼容桥位于 `system-integrations/codex-host-bridge`。它把直接人类来源、跨任务当前
-主控纪元、旧任务能力降级和高风险一次性写入租约编译为 Codex hooks；仓库只保存源码、测试、
-安装器与架构决定，原话事件、当前控制状态、租约、信任回执和凭据全部留在用户本机。该桥是
-HoloLake 原生控制面的兼容投影，不是人格来源，也不替代未来原生本机桥。
 
 ## 当前收束与下一门
 

product-source/hololake-native-desktop/audit/dormant-qoder-agent-prototype/README.md

@@ -1,8 +0,0 @@
-# Dormant Qoder agent prototype
-
-These files preserve the unintegrated Qoder prototype for historical and future design review. They are stored as
-plain audit artifacts, are not Rust modules, are not compiled, and are not reachable from the HoloLake WebView.
-
-The current stage-one product does not expose internal AI chat, model API configuration, model selection or an AI
-workbench. Any future reuse must begin from the current zero-point system/persona/carrier/authority separation and
-must receive a new architecture, security and product-surface review.

product-source/hololake-native-desktop/audit/hololake-0.4.0-domain-membrane-pncc-installed-acceptance-20260816.json

@@ -1,38 +0,0 @@
-{
-  "schema": "hololake.installed-acceptance/v1",
-  "record_id": "GH-HOLOLAKE-0.4.0-DOMAIN-MEMBRANE-PNCC-20260816-001",
-  "state": "LOCAL_INSTALLED_ACCEPTANCE_PASSED_NOT_NOTARIZED_NOT_PUBLIC_RELEASE",
-  "version": "0.4.0",
-  "installed_path": "/Applications/HoloLake.app",
-  "recoverable_previous_bundle": "/Applications/HoloLake 0.3.0 backup 20260816-2.app",
-  "bundle_identifier": "world.guanghu.hololake",
-  "team_identifier": "825A9L3G7Q",
-  "developer_id_signature_verified": true,
-  "apple_notarization_verified": false,
-  "gatekeeper_state": "REJECTED_UNNOTARIZED_DEVELOPER_ID",
-  "executable_sha256": "842fbc592a8310919acc73ba97bb446b606fcc135a586f273fd84ce061000f26",
-  "cdhash": "43a8691bc4f4e6714873dd4cbe885ea2069a23fe",
-  "acceptance": {
-    "script_contract_tests": "61_OF_61_PASS",
-    "rust_tests": "76_OF_76_PASS",
-    "frontend_production_build": "PASS",
-    "rust_clippy_all_targets_all_features_deny_warnings": "PASS",
-    "public_five_domain_home_visual_readback": "PASS",
-    "number_pod_interaction_readback": "PASS",
-    "installed_same_device_discovery": "DISCOVERABLE_ON_SAME_DEVICE",
-    "installed_generic_ai_visitor": "EXPRESSION_ONLY_READY",
-    "installed_generic_ai_execution_authority": false,
-    "installed_guanghu_persona_connection": "BINDING_EVIDENCE_REQUIRED",
-    "installed_local_network_discovery": "DEFERRED_UNTIL_ENCRYPTED_TRANSPORT_AND_APPROVAL",
-    "installed_descriptor_permissions": "0600"
-  },
-  "truth_boundary": {
-    "source_implementation_is_public_release": false,
-    "local_installation_is_server_deployment": false,
-    "developer_id_signature_is_apple_notarization": false,
-    "discovery_is_authorization": false,
-    "accepted_language_is_execution_authority": false,
-    "generic_ai_visitor_is_guanghu_persona": false,
-    "local_user_pncc_is_remote_forgejo_repository": false
-  }
-}

product-source/hololake-native-desktop/audit/hololake-0.4.1-apple-notarization-and-cleanup-acceptance-20260817.json

@@ -1,41 +0,0 @@
-{
-  "schema": "guanghu.hololake.apple-notarization-cleanup-acceptance/v1",
-  "recordedAt": "2026-08-16T17:28:33Z",
-  "version": "0.4.1",
-  "bundleIdentifier": "world.guanghu.hololake",
-  "apple": {
-    "teamId": "825A9L3G7Q",
-    "signingIdentity": "Developer ID Application: bei sun (825A9L3G7Q)",
-    "submissionId": "3D117CB6-78D5-4015-B084-C2AA0368AE94",
-    "submissionMethod": "XCODE_ORGANIZER_DIRECT_DISTRIBUTION",
-    "submissionStatus": "READY_TO_DISTRIBUTE",
-    "staplerValidation": "PASS",
-    "gatekeeperAssessment": "ACCEPTED_NOTARIZED_DEVELOPER_ID",
-    "strictCodeSignature": "PASS"
-  },
-  "installedArtifact": {
-    "app": "/Users/bingshuolingdianyuanhe/Desktop/HoloLake.app",
-    "binarySha256": "73517894b6072629dea05a384561bca04aba4a7613699a3c0dd1bdc563226f05",
-    "dmg": "/Users/bingshuolingdianyuanhe/Desktop/HoloLake-0.4.1-Apple-Silicon.dmg",
-    "dmgSha256": "1d781d56b3b3f13e3e87ab01ca31b1e04cc071b14d55f59753d6bdd86967ee36",
-    "inAppSignedUpdateCheck": "PASS_NO_ACTIVE_UPDATE"
-  },
-  "cleanup": {
-    "oldApplicationsMovedToTrash": 12,
-    "oldDiskImagesMovedToTrash": 2,
-    "recoverableTrashBatch": "/Users/bingshuolingdianyuanhe/.Trash/HoloLake-old-versions-20260817-0122",
-    "recoverableTrashBatchApproximateSize": "807MiB",
-    "cargoBuildCacheRemovedApproximate": "47.9GiB",
-    "runtimeCacheRemovedApproximate": "27MiB",
-    "applicationSupportPreserved": true,
-    "sourceRepositoriesPreserved": true,
-    "releaseSigningMaterialPreserved": true,
-    "xcodeNotarizationArchivePreserved": true
-  },
-  "releaseBoundary": {
-    "bootstrapManualInstallRequiredOnce": true,
-    "subsequentManualReinstallExpected": false,
-    "publicUpdateManifestState": "EMPTY_FAIL_CLOSED_HTTP_204",
-    "silentDownloadInstallRestart": false
-  }
-}

product-source/hololake-native-desktop/audit/hololake-0.4.1-programming-ai-terminal-link-acceptance-20260817.json

@@ -1,53 +0,0 @@
-{
-  "schema": "hololake.programming-ai-terminal-link-installed-acceptance/v1",
-  "recordId": "HLP-PROGRAMMING-AI-TERMINAL-LINK-ACCEPTANCE-20260817-001",
-  "observedAt": "2026-08-17T18:59:50+08:00",
-  "state": "MACOS_LOCAL_CONTROL_PLANE_PASS_CROSS_PLATFORM_INSTALLED_READBACK_PENDING",
-  "version": "0.4.1",
-  "sourceCommit": "24369ac3634cfe9c384f23265e69c9075b2b13da",
-  "protocol": "HOLOLAKE_TERMINAL_LINK/2",
-  "macos": {
-    "application": "src-tauri/target/release/bundle/macos/HoloLake.app",
-    "binarySha256": "b3e557d0d4d28b4bf779d3305ffd9571f04f12f90d3f88248607067e0b1828f4",
-    "developerIdStrictVerification": "PASS",
-    "appleTeamIdentifier": "825A9L3G7Q",
-    "runningProcessIdAtReadback": 53188,
-    "descriptorTransport": "UNIX_STREAM_JSON_LINES",
-    "descriptorPermissions": "0600",
-    "liveConnectorReadback": {
-      "state": "READY",
-      "continuityOwner": "HOLOLAKE",
-      "mcpRole": "DISCOVERY_RECOVERY_COMPATIBILITY_ONLY",
-      "terminalLinkProtocol": "HOLOLAKE_TERMINAL_LINK/2"
-    },
-    "uiReadback": {
-      "nativeChannel": "READY",
-      "workEnvironment": "ANCHORED",
-      "protocolRestoration": "HOLOLAKE_SYSTEM_RUN_MODEL_REREAD_NOT_REQUIRED",
-      "factFrameBeforeMutation": "REQUIRED",
-      "agentShell": "PHASE_TWO_NOT_ENABLED"
-    },
-    "publicNotarization": "PENDING_NEW_BINARY_SUBMISSION",
-    "updaterArtifactSignature": "PENDING_PRIVATE_KEY_PASSWORD_INJECTION"
-  },
-  "sourcePortability": {
-    "linuxUnixSocketAdapter": "PASS_X86_64_UNKNOWN_LINUX_MUSL",
-    "windowsNamedPipeAdapter": "PASS_X86_64_PC_WINDOWS_MSVC_WITH_OWNER_SYSTEM_DACL",
-    "windowsFullDesktopCompile": "PASS_HL_BUILD_WIN_GZ_001_WINDOWS_SERVER_2022_X64",
-    "windowsNativeTests": "PASS_110_OF_110",
-    "linuxInstalledRuntime": "NOT_OBSERVED",
-    "windowsInstalledRuntime": "NOT_OBSERVED",
-    "windowsInstalledReadbackBoundary": "BUILD_NODE_HAS_NO_AUTHENTICATED_HOLOLAKE_PRIVATE_ACCOUNT"
-  },
-  "verification": {
-    "rustUnitTests": "PASS_110_OF_110",
-    "productContractTests": "PASS_91_OF_91",
-    "frontendProductionBuild": "PASS",
-    "crossPlatformAdapterCompile": "PASS",
-    "windowsFullProductCompileAndNativeTests": "PASS",
-    "signedMacosApplicationBuild": "PASS_APPLICATION_BUNDLE_GENERATED",
-    "liveConnector": "PASS",
-    "visibleSystemProjection": "PASS"
-  },
-  "truthBoundary": "This acceptance proves the first-stage HoloLake-owned local control plane on the current macOS machine and source-level transport portability for Linux and Windows. It does not prove a Windows or Linux installed runtime, a newly notarized public release, supervised shell execution, general Agent execution, persona binding, publication, deployment, or reality-execution authority."
-}

product-source/hololake-native-desktop/audit/hololake-0.4.1-programming-ai-terminal-link-windows-acceptance-20260817.json

@@ -1,35 +0,0 @@
-{
-  "schema": "hololake.programming-ai-terminal-link-windows-acceptance/v1",
-  "recordId": "HLP-PROGRAMMING-AI-TERMINAL-LINK-WINDOWS-20260817-001",
-  "observedAt": "2026-08-17T19:30:00+08:00",
-  "state": "WINDOWS_NATIVE_RUNTIME_PASS_INSTALLED_ACCOUNT_READBACK_PENDING",
-  "node": {
-    "nodeId": "HL-BUILD-WIN-GZ-001",
-    "platform": "Windows Server 2022 Datacenter x64",
-    "scope": "HOLOLAKE_WINDOWS_SOFTWARE_BUILD_ONLY",
-    "strictRegisteredSshRoute": true
-  },
-  "source": {
-    "commit": "24369ac3634cfe9c384f23265e69c9075b2b13da",
-    "transportArchiveSha256": "15e63f6b5163bedd2fa0737eac0cd0e2992b7d4a85aef137fbb04fd5ae9d1c42",
-    "finalBrokerSourceSha256Local": "a0fb0edcf6af2d86889f105a38bba0688b0029240355543263172a1dc94604e1",
-    "finalBrokerSourceSha256Windows": "a0fb0edcf6af2d86889f105a38bba0688b0029240355543263172a1dc94604e1"
-  },
-  "verification": {
-    "fullTauriWindowsCargoCheck": "PASS",
-    "fullWindowsDebugExecutableBuild": "PASS",
-    "windowsNativeTests": "PASS_110_OF_110",
-    "namedPipeListenerCreation": "PASS_IN_NATIVE_BROKER_TESTS",
-    "ownerSystemProtectedDaclCompile": "PASS",
-    "sessionResume": "PASS",
-    "singleWriterLane": "PASS",
-    "heartbeatAndWorkEnvironmentFrame": "PASS",
-    "expressionOnlyVisitorRejection": "PASS"
-  },
-  "installedReadback": {
-    "state": "NOT_OBSERVED_FOR_CURRENT_TERMINAL_LINK",
-    "reason": "The registered build node has no authenticated HoloLake private account, so the application correctly has no account-owned broker descriptor to expose.",
-    "mustNotInferFromTests": true
-  },
-  "truthBoundary": "This receipt proves the current HoloLake terminal-link native core compiles and passes its complete Rust test suite on a registered Windows Server 2022 x64 build node. It does not claim an Authenticode signature, SmartScreen trust, a signed installer, an authenticated Windows desktop account, installed UI readback, Linux installed runtime, supervised Agent shell, persona binding, publication, deployment, or reality-execution authority."
-}

product-source/hololake-native-desktop/audit/hololake-0.4.1-updater-bootstrap-installed-acceptance-20260817.json

@@ -1,28 +0,0 @@
-{
-  "schema": "hololake.updater-bootstrap-installed-acceptance/v1",
-  "recordId": "HLP-UPDATER-BOOTSTRAP-INSTALLED-20260817-001",
-  "observedAt": "2026-08-17T01:04:00+08:00",
-  "state": "SIGNED_LOCAL_BOOTSTRAP_RUNNING_PUBLIC_NO_UPDATE_CHECK_PASS_NOTARIZATION_PENDING",
-  "version": "0.4.1",
-  "sourceCommit": "23a0849d6b759639e3e55168810cad8f48023e58",
-  "installedApp": "/Users/bingshuolingdianyuanhe/Desktop/HoloLake.app",
-  "installer": "/Users/bingshuolingdianyuanhe/Desktop/HoloLake-0.4.1-Updater-Bootstrap-Apple-Silicon.dmg",
-  "bundleIdentifier": "world.guanghu.hololake",
-  "appleTeamIdentifier": "825A9L3G7Q",
-  "binarySha256": "5ced220dcd007732ce9506179eac9a4e3f4b70da016f8333a6efb4cffe551f32",
-  "updaterPackageSha256": "ce65736859c9da50653c9004c13f88e210dea915778663eeb063c6c599c753d7",
-  "dmgSha256": "7ddadf442c0ffcc0de65dd4dc03a21276a722841020b8ebab5e278adbd713f2d",
-  "updaterSignaturePresent": true,
-  "developerIdStrictVerification": "PASS",
-  "desktopProcessRunning": true,
-  "desktopUiReadback": "PASS_EXISTING_ACCOUNT_SYSTEM_VIEW",
-  "inAppUpdateCheck": "PASS_CURRENT_VERSION_IS_LATEST",
-  "publicReleaseEndpointStatus": 204,
-  "oldAppRecoveryPath": "/Users/bingshuolingdianyuanhe/.Trash/HoloLake-before-0.4.1-updater-bootstrap.app",
-  "notarization": {
-    "state": "NOT_SUBMITTED_NO_NOTARYTOOL_CREDENTIAL_FOUND",
-    "gatekeeperAssessment": "REJECTED_UNNOTARIZED_DEVELOPER_ID",
-    "stapledTicket": false,
-    "releaseActivationAllowed": false
-  }
-}

product-source/hololake-native-desktop/audit/hololake-0.5.0-numbered-root-installed-acceptance-20260818.json

@@ -1,66 +0,0 @@
-{
-  "schema": "hololake.installed-numbered-root-acceptance/v1",
-  "record_id": "HLP-HOLOLAKE-0.5.0-NUMBERED-ROOT-INSTALLED-20260818",
-  "state": "LOCAL_DEVELOPER_ID_SIGNED_INSTALLED_ACCEPTANCE_PASS_PUBLIC_NOTARIZATION_PENDING",
-  "observed_at": "2026-08-18T15:18:00Z",
-  "source": {
-    "branch": "codex/hololake-clean-reassembly-20260818",
-    "source_commit": "5d01607459043d0713bc562ef6d04dec198930a9",
-    "numbered_root_commit": "64abf969bfbc1c576d4fa84ae3282d32efbfcc38"
-  },
-  "installed_application": {
-    "path": "/Users/bingshuolingdianyuanhe/Desktop/HoloLake.app",
-    "version": "0.5.0",
-    "bundle_identifier": "world.guanghu.hololake",
-    "architecture": "arm64",
-    "binary_sha256": "2e162ff077187310f816f58df2250e3ee939eb489fe3c7b00e94557ff8f3370d",
-    "process_path_verified": true
-  },
-  "developer_id": {
-    "identity": "Developer ID Application: bei sun (825A9L3G7Q)",
-    "team_identifier": "825A9L3G7Q",
-    "cdhash": "7a2372ed85fc3b775e9a352217b123a4bdee0d64",
-    "strict_signature_verification": "PASS",
-    "designated_requirement": "PASS",
-    "gatekeeper": "REJECTED_UNNOTARIZED_DEVELOPER_ID",
-    "apple_notarization_and_stapling": "PENDING"
-  },
-  "runtime": {
-    "real_webview_loaded": true,
-    "visible_version": "V0.5.0",
-    "visible_domain": "第五域 · 光湖本源域",
-    "entered_surface": "永恒湖心系统",
-    "numbered_ipc_receipt_rows": 50,
-    "grant_and_execution_rows_present": true,
-    "empty_authority_binding_digest_rows": 0,
-    "recalculated_receipt_chain_failures": 0,
-    "last_sequence": 50,
-    "last_receipt_hash": "a294463ad9e6959d0f12ce5c2b59e11d97581e067b9480df9ae598dfafc067df"
-  },
-  "old_application": {
-    "version": "0.4.1",
-    "role": "READ_ONLY_PRE_NUMBERED_ROOT_MODULE_DONOR",
-    "archive_receipt": "/Volumes/JZAO/HoloLake/artifacts/hololake-release/0.4.1/macos-arm64/pre-numbered-root-donor/archive-receipt.json",
-    "repair_in_place": false
-  },
-  "release_boundary": {
-    "local_signed_install_complete": true,
-    "public_signed_notarized_release_complete": false,
-    "updater_public_key_continuity": "PASS_EXISTING_0.4.1_TRUST_ROOT_REUSED",
-    "updater_private_key_available_to_current_pipeline": true,
-    "updater_signature_generated_and_verified": true,
-    "pre_notarization_updater_artifact": {
-      "path": "src-tauri/target/release/bundle/macos/HoloLake.app.tar.gz",
-      "sha256": "4176bb7ea83c820744239c228671840289f87675329182bc055938e03bba9693",
-      "signature_path": "src-tauri/target/release/bundle/macos/HoloLake.app.tar.gz.sig",
-      "signature_sha256": "ae02c2918c26b6e3cc2389fec8d9f98884ae639d448edc78a4ec80ee30a8ae92",
-      "publication_allowed": false
-    },
-    "apple_notarization_credentials_available_to_current_pipeline": false,
-    "public_broadcast_activated": false
-  },
-  "persona_boundary": {
-    "current_codex_carrier_binding_claimed": false,
-    "runtime_persona_binding_created_by_numbered_ipc": false
-  }
-}

product-source/hololake-native-desktop/audit/hololake-0.5.0-qoder-numbered-production-installed-20260819.json

@@ -1,17 +0,0 @@
-{
-  "schema": "hololake.production-install-acceptance/v1",
-  "record_id": "HLP-PRODUCTION-INSTALL-20260819-001",
-  "state": "PASS",
-  "version": "0.5.0",
-  "installed_path": "/Users/bingshuolingdianyuanhe/Desktop/HoloLake.app",
-  "visible_hololake_app_count": 1,
-  "previous_app_recovery_path": "/Users/bingshuolingdianyuanhe/.Trash/HoloLake-pre-qoder-numbered-ui-20260819-0659.app",
-  "binary_sha256": "b0422bb18df521ace54ff1a52cd47121d92833dd78f165845deba7806686c7ac",
-  "cdhash": "42640f7ce56e96403609899095c77ea6171df07d",
-  "team_identifier": "825A9L3G7Q",
-  "developer_id_signature": "PASS",
-  "launch": "PASS",
-  "real_data_rehydration": "PASS",
-  "notarization": "NOT_CLAIMED_THIS_LOCAL_BUILD",
-  "updater_artifact_signing": "NOT_COMPLETED_MISSING_PRIVATE_UPDATER_KEY_IN_CURRENT_PROCESS"
-}

product-source/hololake-native-desktop/audit/hololake-unified-runtime-acceptance-20260816.json

@@ -1,53 +0,0 @@
-{
-  "schema": "hololake.unified-desktop-runtime-acceptance/v1",
-  "record_id": "HLP-UNIFIED-RUNTIME-ACCEPTANCE-20260816-001",
-  "observed_at": "2026-08-16T04:55:05Z",
-  "state": "LOCAL_DEVELOPER_ID_SIGNED_RUNTIME_ACCEPTED_NOT_APPLE_NOTARIZED",
-  "source": {
-    "branch": "integration/hololake-unified-20260816",
-    "merge_commit": "b7461c66c58f3ffad2dcdb7fc83ed90815b8b421",
-    "parents": [
-      "1f45b62068b18442a7a1797a2488b28b68e487bf",
-      "198ef7f1d578186e58f55325386512bb57243cce"
-    ],
-    "version": "0.3.0"
-  },
-  "installed_application": {
-    "path": "/Applications/HoloLake.app",
-    "backup_path": "/Applications/HoloLake-0.2.0-backup-20260816.app",
-    "bundle_identifier": "world.guanghu.hololake",
-    "executable_sha256": "2b54e1ee23de3a80cf70d614f4ac590d6d44383311d90df980ca288f980b07e6",
-    "developer_id_team": "825A9L3G7Q",
-    "cdhash": "422d7ec0befe63f0dcf095881fcbb38da0db4e0f",
-    "codesign_strict_verification": true,
-    "apple_notarization": false
-  },
-  "verification": {
-    "javascript_product_tests": { "passed": 54, "failed": 0 },
-    "rust_tests": { "passed": 68, "failed": 0 },
-    "typescript_and_vite_build": "PASS",
-    "tauri_release_bundle": "PASS",
-    "installed_ui_readback": "PASS",
-    "knowledge_workspace_readback": "PASS_168_UNIQUE_242_DUPLICATES_FOLDED",
-    "code_channel_readback": "PASS_REAL_REPOSITORY_TREE",
-    "jd_pncc_live_projection": "PASS_READ_ONLY_LIVE",
-    "zero_point_boot_protocol_comparison": "PASS_FAIL_CLOSED_UNSIGNED_UPDATE_NOT_APPLIED"
-  },
-  "product_boundaries": {
-    "public_internal_ai_chat": false,
-    "public_model_api_configuration": false,
-    "zero_point_system_is_persona": false,
-    "number_verification_is_persona_binding": false,
-    "arbitrary_remote_code_execution": false,
-    "qoder_agent_prototype_compiled": false,
-    "qoder_agent_prototype_archive": "audit/dormant-qoder-agent-prototype"
-  },
-  "remaining_gates": [
-    "APPLE_NOTARIZATION_AND_STAPLING",
-    "ZERO_POINT_SIGNING_PUBLIC_KEY_PROVISIONING",
-    "SIGNED_PROTOCOL_PAYLOAD_INSTALLATION",
-    "PRIVATE_NUMBER_REGISTRY_DISTRIBUTION",
-    "PERSONA_LOADING_RUNTIME",
-    "FINAL_MAIN_BRANCH_PUBLICATION_READBACK"
-  ]
-}

product-source/hololake-native-desktop/audit/qoder-surface-live-acceptance-20260819.json

@@ -1,28 +0,0 @@
-{
-  "schema": "hololake.qoder-surface-live-acceptance/v1",
-  "record_id": "HLP-QODER-SURFACE-ACCEPTANCE-20260819-001",
-  "module_number": "HLP-MOD-OFFICIAL-DYNAMIC-WORLD-SURFACE-0001",
-  "state": "PASS",
-  "tested_app": "src-tauri/target/debug/bundle/macos/HoloLake.app",
-  "developer_id_signature": "PASS",
-  "team_identifier": "825A9L3G7Q",
-  "binary_sha256": "fb1d0497f295e1228c9b2ac86e33082332f226aae6e32b9050cf6c5de30bd512",
-  "cdhash": "90e365b23961a6b842590869df655ec35a55b66e",
-  "checks": {
-    "traditional_locked_layout": "PASS",
-    "traditional_real_data_hydration": "PASS",
-    "traditional_light_finish_readability": "PASS_SNOW",
-    "language_world_five_domains_no_overlap": "PASS_1229x768",
-    "language_world_real_weather": "PASS_CLOUD",
-    "theme_persists_into_channel": "PASS",
-    "theme_persists_into_web_novel": "PASS",
-    "theme_persists_into_education": "PASS",
-    "new_chapter_modal_opens": "PASS",
-    "created_chapter_survives_restart": "PASS_1_CHAPTER",
-    "work_summary_refresh_after_create": "PASS_1_CHAPTER_ON_WORK_CARD",
-    "idle_clock_stops": "PASS",
-    "idle_screenshot_psnr_db": 59.502493
-  },
-  "reference_comparison": "audit/qoder-traditional-reference-vs-hololake-0.5.0.jpg",
-  "public_notarization": "NOT_CLAIMED_BY_DEBUG_ACCEPTANCE"
-}

product-source/hololake-native-desktop/audit/ui-overlap-20260819/README.md

@@ -1,49 +0,0 @@
-# HoloLake 单场景、公共入口与编号星渊验收记录
-
-日期：2026-08-19
-
-## 结论
-
-- 旧、新首页重复拥有场景的根因已经关闭：五域湖面只保留一个可见场景所有者，频道、商城和天气使用互不复用的槽位。
-- 编号入口最终不是灯塔，也不是五域旁边的附属按钮。未验证首页只渲染湖面与大型未知星渊；产品名、光湖历、五域和频道凭证均不进入可访问树。
-- 点击星渊后，同一位置翻开为清晰的编号输入面；编号通过后星渊外翻消散，产品名与五湖分层升起，最后才出现频道凭证。
-- 主域、分域、零域是可进入的公共只读入口；第五域与零感域只公开职责和边界，不投影内部成员、仓库或私有内容。
-- 外部编程 AI 网关默认关闭，必须由已验证的人类在授权中心明确开启；MCP 只暴露登记过的只读发现、状态和能力清单。
-- 公共首页允许在未登录、尚未建立私人商城账本时启动。私人安装账本休眠，不再终止整个桌面应用。
-
-## 可视证据
-
-- `01-current-channel-overlap.png`：修复前的重复 UI。
-- `02-fixed-channel.png`：单一频道场景。
-- `03-external-ai-gateway.png`：默认关闭的真实外部 AI 网关。
-- `04-home-lighthouse.png`：被用户否决的胶囊形灯塔。
-- `05-public-main-domain.png`：主域公共入口。
-- `06-public-branch-domain.png`：分域双区商城公共入口。
-- `07-public-zero-domain.png`：零域协议运行投影。
-- `08-home-css-lighthouse.png`：再次被用户否决的机械灯塔方向，仅作纠错证据。
-- `09-home-star-abyss.jpeg`：最终未验证首页；只显示大型未知星渊。
-- `10-star-abyss-number-input.jpeg`：星渊翻开后的真实编号输入状态；底层入口不会重复残留。
-- `11-world-unfolded-after-number.jpeg`：真实编号通过后，平台标题、五湖和频道凭证才出现。
-
-## 视觉自审
-
-- 布局：验证前的大型星渊占据首页中部，与湖面地平线形成一个入口，不把它缩成图标。
-- 层级：验证前没有产品标题和五域竞争注意力；验证后才建立标题、光湖历、五湖和频道凭证层级。
-- 字体：沿用现有中文字体、字距和暖白标签，不引入新字体系统。
-- 色彩：星渊只使用湖面现有深蓝、冷紫雾光和少量内部星点，不新增机械实体色。
-- 控件：整个星渊仍是语义化 `button`；未验证时，隐藏世界不会泄露进辅助技术可访问树。
-
-## 运行证据
-
-- 前端生产构建通过。
-- JavaScript/合同测试全量通过。
-- Rust 测试全量通过。
-- macOS 桌面包通过 Developer ID 校验，标识为 `world.guanghu.hololake`。
-- 最终安装二进制 SHA-256：`17d20c67cca86dd3fc919726479446e8a05c65a99a98867a8438051e3490e9a1`。
-- 本地签名 App 已真实走通“星渊 → 编号验证 → 五湖升起 → 频道凭证”，并在验收后留在未验证星渊首页。
-
-## 已知发布边界
-
-- 本机 Developer ID 签名有效。
-- 本轮没有 Apple notarization 环境变量，因此未做在线公证。
-- Tauri updater 公钥已配置，但当前环境没有 `TAURI_SIGNING_PRIVATE_KEY`，所以没有生成可发布的签名增量更新包；这不影响本地 `.app` 运行。

product-source/hololake-native-desktop/contracts/channel-workbench-runtime.json

@@ -1,58 +0,0 @@
-{
-  "schema": "hololake.channel-workbench-runtime/v1",
-  "record_id": "HLP-CHANNEL-WORKBENCH-RUNTIME-001",
-  "candidate_number": "HLP-DONOR-CAND-0002",
-  "runtime_module_number": "HLP-MOD-LOCAL-CHANNEL-WORKBENCH-0001",
-  "numbered_ipc": {
-    "module_number": "HLP-NIPC-MOD-0022",
-    "target_number": "HLP-NIPC-TGT-0022",
-    "operations": ["HLP-NIPC-OP-0074", "HLP-NIPC-OP-0075", "HLP-NIPC-OP-0076"]
-  },
-  "engines": {
-    "document": "LEXICAL_0_49",
-    "spreadsheet": "FORTUNE_SHEET_1_0_4"
-  },
-  "data_boundary": {
-    "scope": "CURRENT_AUTHENTICATED_ACCOUNT_LOCAL",
-    "database": "channel-workbench-v1/channel-workbench.sqlite3",
-    "documents_max_body_bytes": 2097152,
-    "spreadsheets_max_columns": 64,
-    "spreadsheets_max_rows": 5000,
-    "package_unmount_deletes_user_data": false,
-    "repository_code_is_executable": false
-  },
-  "integrity": {
-    "optimistic_revision_required": true,
-    "every_save_writes_hash_chained_receipt": true,
-    "receipt_chain_verified_before_read_or_write": true,
-    "adapter_requires_signed_active_module": true
-  },
-  "current_acceptance": {
-    "state": "SIGNED_INSTALLED_CONTENT_AND_RESTART_ACCEPTED",
-    "source_donor": "HLP-DONOR-CHAOTIC-WORKTREE-20260818",
-    "compiled_donor_behavior_checked": false,
-    "compiled_donor_boundary": "No claim of pixel-equivalent compiled-donor acceptance; the declared source slice was reconstructed and the clean host behavior was accepted directly.",
-    "real_signed_package": "fixtures/module-packages/HLP-MOD-LOCAL-CHANNEL-WORKBENCH-0001-0.1.0.ghmod",
-    "module_package_sha256": "eb7af0bd4882cc89acda11c933a3601d16f0588ff737caf8467b875ab5a4ab7b",
-    "signed_debug_binary_sha256": "6f851856ab6f5717facc67ec406c9eb99e240290c585438323e230daec5ae71c",
-    "developer_id_team": "825A9L3G7Q",
-    "signed_debug_cdhash": "0209a46b2dc221d37b618a2b12866bb8cb39f03d",
-    "real_account_human_number": "ICE-GL∞",
-    "ui_activation_verified": true,
-    "document_save": {
-      "title": "冰朔频道迁移验收",
-      "revision": 1,
-      "content_sha256_prefix": "534b4bd3d6d0",
-      "receipt_sha256_prefix": "72436f46cf1d"
-    },
-    "spreadsheet_save": {
-      "title": "冰朔编号迁移表",
-      "revision": 1,
-      "formula_preserved": "=1+2",
-      "content_sha256_prefix": "57607d92c0dc",
-      "receipt_sha256_prefix": "323761fc18a3"
-    },
-    "restart_persistence_verified": true,
-    "dependency_audit": "0_VULNERABILITIES_AFTER_UUID_11_1_1_OVERRIDE"
-  }
-}

product-source/hololake-native-desktop/contracts/circular-lake-membrane.json

@@ -1,32 +0,0 @@
-{
-  "schema": "hololake.circular-lake-membrane-contract/v1",
-  "record_id": "HLP-CIRCULAR-LAKE-MEMBRANE-001",
-  "metaphor": "A_LANGUAGE_LAKE_WITHOUT_A_DIRECT_EXECUTION_GAP",
-  "default": "DISCARD",
-  "deterministic_membrane_before_persona_parser": true,
-  "intent_inference_required_for_protocol_rejection": false,
-  "protocol_external_input_reaches_persona_context": false,
-  "natural_language_grants_execution_authority": false,
-  "accepted_language_protocols": ["GLP/1.0"],
-  "ingress_order": [
-    "BOUNDED_BYTE_FRAME",
-    "STRICT_PROTOCOL_SCHEMA",
-    "AUTHENTICATED_CONNECTION_CLASS",
-    "MESSAGE_ID_RECEIVER_TYPE_AND_CHECKSUM",
-    "PRIVATE_LANGUAGE_INBOX",
-    "PERSONA_LANGUAGE_INTERPRETATION_LATER"
-  ],
-  "visitor_language": {
-    "attachments_allowed": false,
-    "command_content_type_allowed": false,
-    "maximum_content_bytes": 65536,
-    "expression_only": true,
-    "execution_authority": false
-  },
-  "invalid_input": {
-    "stored_as_memory": false,
-    "sent_to_persona": false,
-    "sent_to_tools": false,
-    "interpreted_for_motive": false
-  }
-}

product-source/hololake-native-desktop/contracts/code-channel.json

@@ -15,9 +15,7 @@
   },
   "registry": {
     "owner": "HOLOLAKE_NATIVE_RUST_CORE",
-    "location": "TAURI_APP_DATA_ACCOUNTS_V1_HASHED_ACCOUNT_CODE_CHANNEL_V1",
+    "location": "TAURI_APP_DATA_CODE_CHANNEL_V1",
-    "authenticated_account_required": true,
-    "cross_account_projection_allowed": false,
     "stored_fields_include_credentials": false,
     "atomic_write": true,
     "restart_readback": true

product-source/hololake-native-desktop/contracts/direct-local-broker-numbered-registry.json

@@ -1,39 +0,0 @@
-{
-  "schema": "hololake.direct-local-broker-numbered-registry/v1",
-  "record_id": "HLP-NBROKER-ROOT-001",
-  "runtime": {
-    "protocol_version": "HLP-NBROKER-v1",
-    "caller_number": "HLP-NBROKER-CALLER-LOCAL-CONNECTOR-0001",
-    "legacy_string_operation_allowed": false,
-    "unknown_or_mismatched_coordinate": "FAIL_CLOSED",
-    "request_nonce_required": true,
-    "transport_is_authority": false
-  },
-  "operations": [
-    {"operation_number":"HLP-NBROKER-OP-0001","alias":"DISCOVER_NEARBY","channel_number":"HLP-NBROKER-CH-0001","module_number":"HLP-NBROKER-MOD-0001","target_number":"HLP-NBROKER-TGT-0001"},
-    {"operation_number":"HLP-NBROKER-OP-0002","alias":"OPEN_VISITOR_SESSION","channel_number":"HLP-NBROKER-CH-0002","module_number":"HLP-NBROKER-MOD-0002","target_number":"HLP-NBROKER-TGT-0002"},
-    {"operation_number":"HLP-NBROKER-OP-0003","alias":"RECEIVE_LANGUAGE","channel_number":"HLP-NBROKER-CH-0002","module_number":"HLP-NBROKER-MOD-0003","target_number":"HLP-NBROKER-TGT-0003"},
-    {"operation_number":"HLP-NBROKER-OP-0004","alias":"PING","channel_number":"HLP-NBROKER-CH-0001","module_number":"HLP-NBROKER-MOD-0001","target_number":"HLP-NBROKER-TGT-0001"},
-    {"operation_number":"HLP-NBROKER-OP-0005","alias":"OPEN_SESSION","channel_number":"HLP-NBROKER-CH-0003","module_number":"HLP-NBROKER-MOD-0004","target_number":"HLP-NBROKER-TGT-0004"},
-    {"operation_number":"HLP-NBROKER-OP-0006","alias":"RESUME_SESSION","channel_number":"HLP-NBROKER-CH-0003","module_number":"HLP-NBROKER-MOD-0004","target_number":"HLP-NBROKER-TGT-0004"},
-    {"operation_number":"HLP-NBROKER-OP-0007","alias":"HEARTBEAT_SESSION","channel_number":"HLP-NBROKER-CH-0003","module_number":"HLP-NBROKER-MOD-0004","target_number":"HLP-NBROKER-TGT-0004"},
-    {"operation_number":"HLP-NBROKER-OP-0008","alias":"PRESENT_PERSONA_CARRIER_LICENSE","channel_number":"HLP-NBROKER-CH-0004","module_number":"HLP-NBROKER-MOD-0005","target_number":"HLP-NBROKER-TGT-0005"},
-    {"operation_number":"HLP-NBROKER-OP-0009","alias":"GET_PERSONA_CARRIER_LICENSE_STATUS","channel_number":"HLP-NBROKER-CH-0004","module_number":"HLP-NBROKER-MOD-0005","target_number":"HLP-NBROKER-TGT-0005"},
-    {"operation_number":"HLP-NBROKER-OP-0010","alias":"GET_WORK_ENVIRONMENT","channel_number":"HLP-NBROKER-CH-0003","module_number":"HLP-NBROKER-MOD-0006","target_number":"HLP-NBROKER-TGT-0006"},
-    {"operation_number":"HLP-NBROKER-OP-0011","alias":"APPEND_EVENT","channel_number":"HLP-NBROKER-CH-0003","module_number":"HLP-NBROKER-MOD-0004","target_number":"HLP-NBROKER-TGT-0004"},
-    {"operation_number":"HLP-NBROKER-OP-0012","alias":"RESOLVE_CAPABILITY_ROUTE","channel_number":"HLP-NBROKER-CH-0005","module_number":"HLP-NBROKER-MOD-0007","target_number":"HLP-NBROKER-TGT-0007"},
-    {"operation_number":"HLP-NBROKER-OP-0013","alias":"INSTALL_DYNAMIC_NODE_REGISTRY","channel_number":"HLP-NBROKER-CH-0005","module_number":"HLP-NBROKER-MOD-0007","target_number":"HLP-NBROKER-TGT-0007"},
-    {"operation_number":"HLP-NBROKER-OP-0014","alias":"RECORD_SIGNED_NODE_HEALTH","channel_number":"HLP-NBROKER-CH-0005","module_number":"HLP-NBROKER-MOD-0007","target_number":"HLP-NBROKER-TGT-0007"},
-    {"operation_number":"HLP-NBROKER-OP-0015","alias":"INSPECT_MOUNTED_PNCC_REPOSITORY","channel_number":"HLP-NBROKER-CH-0006","module_number":"HLP-NBROKER-MOD-0008","target_number":"HLP-NBROKER-TGT-0008"},
-    {"operation_number":"HLP-NBROKER-OP-0016","alias":"READ_MOUNTED_PNCC_REMOTE_OBJECT","channel_number":"HLP-NBROKER-CH-0006","module_number":"HLP-NBROKER-MOD-0008","target_number":"HLP-NBROKER-TGT-0008"},
-    {"operation_number":"HLP-NBROKER-OP-0017","alias":"QUERY_PNCC_RECEIPT_PROJECTION","channel_number":"HLP-NBROKER-CH-0006","module_number":"HLP-NBROKER-MOD-0008","target_number":"HLP-NBROKER-TGT-0008"},
-    {"operation_number":"HLP-NBROKER-OP-0018","alias":"GET_BEIJING_TIME","channel_number":"HLP-NBROKER-CH-0001","module_number":"HLP-NBROKER-MOD-0009","target_number":"HLP-NBROKER-TGT-0009"},
-    {"operation_number":"HLP-NBROKER-OP-0019","alias":"ISSUE_PERSONA_TIME_TICKET","channel_number":"HLP-NBROKER-CH-0004","module_number":"HLP-NBROKER-MOD-0009","target_number":"HLP-NBROKER-TGT-0009"},
-    {"operation_number":"HLP-NBROKER-OP-0020","alias":"ACQUIRE_DEVELOPMENT_WRITE_LANE","channel_number":"HLP-NBROKER-CH-0007","module_number":"HLP-NBROKER-MOD-0010","target_number":"HLP-NBROKER-TGT-0010"},
-    {"operation_number":"HLP-NBROKER-OP-0021","alias":"INSPECT_DEVELOPMENT_WRITE_LANE","channel_number":"HLP-NBROKER-CH-0007","module_number":"HLP-NBROKER-MOD-0010","target_number":"HLP-NBROKER-TGT-0010"},
-    {"operation_number":"HLP-NBROKER-OP-0022","alias":"RELEASE_DEVELOPMENT_WRITE_LANE","channel_number":"HLP-NBROKER-CH-0007","module_number":"HLP-NBROKER-MOD-0010","target_number":"HLP-NBROKER-TGT-0010"},
-    {"operation_number":"HLP-NBROKER-OP-0023","alias":"SUBMIT_HUMAN_AUTHORIZATION_REQUEST","channel_number":"HLP-NBROKER-CH-0008","module_number":"HLP-NBROKER-MOD-0011","target_number":"HLP-NBROKER-TGT-0011"},
-    {"operation_number":"HLP-NBROKER-OP-0024","alias":"GET_HUMAN_AUTHORIZATION_STATUS","channel_number":"HLP-NBROKER-CH-0008","module_number":"HLP-NBROKER-MOD-0011","target_number":"HLP-NBROKER-TGT-0011"},
-    {"operation_number":"HLP-NBROKER-OP-0025","alias":"CONSUME_HUMAN_AUTHORIZATION_TICKET","channel_number":"HLP-NBROKER-CH-0008","module_number":"HLP-NBROKER-MOD-0011","target_number":"HLP-NBROKER-TGT-0011"}
-  ]
-}

product-source/hololake-native-desktop/contracts/distribution-plane-router.json

@@ -1,186 +0,0 @@
-{
-  "schema": "hololake.distribution-plane-router/v1",
-  "record_id": "HLP-DISTRIBUTION-PLANE-ROUTER-001",
-  "state": "CONTRACT_CURRENT_PUBLIC_ZERO_CORE_CLIENT_RUNTIME_IMPLEMENTED_SERVER_AND_CATALOG_INTEGRATION_PENDING",
-  "classification": {
-    "authority": "EXPLICIT_SIGNED_RELEASE_ENVELOPE",
-    "semantic_guessing_allowed": false,
-    "missing_or_conflicting_scope": "FAIL_CLOSED",
-    "required_fields": [
-      "releaseId",
-      "scope",
-      "ownerNumber",
-      "authorityDomain",
-      "sourceRepository",
-      "sourceCommit",
-      "artifactKind",
-      "targetNamespace",
-      "minimumHostVersion",
-      "contentSha256",
-      "permissionDelta",
-      "rollbackReference",
-      "signerId"
-    ],
-    "human_source_rule": "THE_PUBLISHER_STATES_PUBLIC_OR_PRIVATE_SCOPE_AND_REVIEWS_THE_EXACT_IMMUTABLE_CANDIDATE_BEFORE_SERVER_PUBLICATION",
-    "system_rule": "CONTENT_INSPECTION_MAY_REJECT_A_SCOPE_MISMATCH_BUT_MUST_NOT_INVENT_OR_EXPAND_SCOPE"
-  },
-  "planes": [
-    {
-      "plane_number": "HLP-DIST-PLANE-0001",
-      "scope": "PUBLIC_ZERO_CORE_PROTOCOL",
-      "physical_node": "GH-CVM-MAIN-PROD-01",
-      "logical_source": "ZERO_POINT_ORIGIN_PUBLIC_PROJECTION_HOSTED_OUTSIDE_PRIVATE_FIFTH_DOMAIN",
-      "logical_authority": "ZERO_POINT_ORIGIN_WITH_ICE_GL_INFINITY_PUBLIC_SCOPE_APPROVAL",
-      "management_entry": "FIFTH_DOMAIN_PORTAL_TO_ENTERPRISE_ZERO_CORE_WITH_ONE_TIME_AUDIENCE_BOUND_HANDOFF",
-      "public_read_access": "SIGNED_MANIFEST_AND_ARTIFACT_NO_ACCOUNT_REQUIRED",
-      "allowed_artifacts": [
-        "DECLARATIVE_LANGUAGE_PROTOCOL",
-        "NUMBERING_PROTOCOL",
-        "COMPATIBILITY_RULE",
-        "BOUNDED_MIGRATION_RULE"
-      ],
-      "arbitrary_native_code_allowed": false,
-      "arbitrary_webview_javascript_allowed": false,
-      "publisher_human_confirmation_required": true,
-      "per_device_human_install_confirmation_required": false,
-      "automatic_check": true,
-      "automatic_download_after_verification": true,
-      "automatic_atomic_activation_after_self_test": true,
-      "visible_human_receipt_required": true,
-      "public_propagation_allowed": true,
-      "required_signer_classes": [
-        "ZERO_POINT_ORIGIN_PUBLIC_SCOPE_SIGNER",
-        "ENTERPRISE_ZERO_CORE_DISTRIBUTION_SIGNER"
-      ],
-      "signer_class": "DUAL_ORIGIN_AND_ENTERPRISE_ZERO_CORE_SIGNERS"
-    },
-    {
-      "plane_number": "HLP-DIST-PLANE-0002",
-      "scope": "PRIVATE_FIFTH_DOMAIN",
-      "physical_node": "JD-FD-PRIMARY",
-      "logical_source": "DOM-FIFTH-0001_PRIVATE_BODY",
-      "audience": "EXACT_BOUND_OWNER_AND_EXPLICITLY_AUTHORIZED_PRIVATE_NODES",
-      "publisher_human_confirmation_required": true,
-      "per_device_human_install_confirmation_required": false,
-      "automatic_check": true,
-      "public_propagation_allowed": false,
-      "cross_domain_replication_allowed": false,
-      "signer_class": "PRIVATE_FIFTH_DOMAIN_SIGNER"
-    },
-    {
-      "plane_number": "HLP-DIST-PLANE-0003",
-      "scope": "PUBLIC_ENTERPRISE_MODULE_CATALOG",
-      "physical_node": "GH-CVM-MAIN-PROD-01",
-      "logical_source": "GUANGHU_CHANNEL_AGGREGATE",
-      "producer_model": "FIVE_RESPONSIBILITY_REPOSITORIES_TO_ONE_REVIEWED_AGGREGATE",
-      "allowed_artifacts": [
-        "DECLARATIVE_GHMOD_PACKAGE",
-        "MODULE_METADATA",
-        "PERSONA_BRAIN_SKILL_PACKAGE"
-      ],
-      "raw_repository_is_executable_input": false,
-      "client_full_repository_clone_required": false,
-      "catalog_index_automatic_sync": true,
-      "module_package_download_on_human_selection": true,
-      "module_install_human_confirmation_required": true,
-      "permission_expansion_human_confirmation_required": true,
-      "lighthouse_number_registration_required": true,
-      "isolated_preflight_and_self_test_required": true,
-      "signer_class": "ENTERPRISE_MODULE_RELEASE_SIGNER"
-    },
-    {
-      "plane_number": "HLP-DIST-PLANE-0004",
-      "scope": "APPLICATION_BINARY",
-      "physical_node": "HOLOLAKE_RELEASE_BROADCAST",
-      "allowed_artifacts": [
-        "SIGNED_NOTARIZED_DESKTOP_APPLICATION",
-        "SIGNED_UPDATER_ARCHIVE"
-      ],
-      "source_commit_must_be_immutable": true,
-      "platform_signing_required": true,
-      "updater_signature_required": true,
-      "per_device_human_install_confirmation_required": true,
-      "automatic_restart_allowed": false,
-      "signer_class": "HOLOLAKE_APPLICATION_RELEASE_SIGNER"
-    }
-  ],
-  "lamp_protocol": {
-    "transport": "HTTPS_CONDITIONAL_GET",
-    "git_role": "DURABLE_AUTHORING_AND_EVIDENCE_NOT_CLIENT_REALTIME_TRANSPORT",
-    "signal": "SIGNED_MONOTONIC_EPOCH_AND_CONTENT_ROOT",
-    "cache_validation": ["ETAG", "IF_NONE_MATCH"],
-    "check_events": ["APPLICATION_START", "NETWORK_RESUME", "BOUNDED_PERIODIC_TIMER"],
-    "minimum_periodic_interval_seconds": 900,
-    "jitter_required": true,
-    "full_repository_clone_for_LIGHT_SIGNAL": false,
-    "required_manifest_fields": [
-      "schema",
-      "planeNumber",
-      "epoch",
-      "version",
-      "contentRootSha256",
-      "artifactManifestUrl",
-      "signatureUrl",
-      "publishedAt",
-      "minimumHostVersion"
-    ]
-  },
-  "cross_node_management_handoff": {
-    "source_node": "JD-FD-PRIMARY",
-    "target_node": "GH-CVM-MAIN-PROD-01",
-    "source_surface": "PRIVATE_FIFTH_DOMAIN",
-    "target_surface": "PUBLIC_ZERO_CORE_MANAGEMENT_CHANNEL",
-    "credential_reuse_allowed": false,
-    "password_forwarding_allowed": false,
-    "ticket_properties": [
-      "ONE_TIME",
-      "SHORT_LIVED",
-      "BOUND_TO_HUMAN_NUMBER",
-      "BOUND_TO_HOLOLAKE_CLIENT_INSTANCE",
-      "BOUND_TO_TARGET_NODE",
-      "BOUND_TO_PUBLIC_ZERO_CORE_RESOURCE",
-      "NON_TRANSFERABLE",
-      "REPLAY_PROTECTED"
-    ],
-    "exit_behavior": "DESTROY_ENTERPRISE_ZERO_CORE_SESSION_AND_RESTORE_EXISTING_PRIVATE_FIFTH_DOMAIN_SESSION",
-    "enterprise_four_domain_authority_inherited": false,
-    "private_fifth_domain_authority_exported": false,
-    "current_state": "NOT_IMPLEMENTED"
-  },
-  "activation_pipeline": [
-    "READ_EXPLICIT_RELEASE_ENVELOPE",
-    "VERIFY_SCOPE_OWNER_DOMAIN_REPOSITORY_AND_IMMUTABLE_COMMIT",
-    "BUILD_BOUNDED_CONTENT_ADDRESSED_ARTIFACT",
-    "RUN_ISOLATED_SCHEMA_PERMISSION_COMPATIBILITY_AND_SELF_TEST",
-    "ALLOCATE_OR_VERIFY_LIGHTHOUSE_NUMBER",
-    "SHOW_EXACT_CANDIDATE_TO_AUTHORIZED_PUBLISHER",
-    "REQUIRE_PUBLISHER_CONFIRMATION",
-    "SIGN_WITH_PLANE_SPECIFIC_KEY",
-    "APPEND_HASH_CHAINED_PUBLICATION_RECEIPT",
-    "ADVANCE_SIGNED_LAMP_EPOCH_ATOMICALLY"
-  ],
-  "client_protocol_activation": [
-    "COMPARE_SIGNED_LAMP_EPOCH_WITH_CONDITIONAL_GET",
-    "VERIFY_PLANE_SOURCE_SIGNATURE_CONTENT_ROOT_AND_MONOTONIC_VERSION",
-    "DOWNLOAD_TO_ISOLATED_STAGING",
-    "REJECT_EXECUTABLE_OR_OUT_OF_SCOPE_PAYLOAD",
-    "RUN_LOCAL_COMPATIBILITY_AND_SELF_TEST",
-    "ATOMICALLY_SWITCH_CURRENT_POINTER",
-    "WRITE_LOCAL_HASH_CHAINED_RECEIPT",
-    "KEEP_LAST_KNOWN_GOOD_ROLLBACK",
-    "NOTIFY_HUMAN_WITHOUT_REQUIRING_PER_DEVICE_APPROVAL"
-  ],
-  "current_observed_gaps_2026_08_19": {
-    "enterprise_public_zero_core_projection": "NOT_DEPLOYED",
-    "jd_to_enterprise_zero_core_handoff": "NOT_IMPLEMENTED",
-    "zero_point_signed_payload_activation": "CLIENT_IMPLEMENTED_DUAL_SIGNER_TRUST_NOT_PROVISIONED",
-    "enterprise_guanghu_channel_aggregate_repository": "NOT_PRESENT",
-    "enterprise_public_gitea_repositories_observed": [
-      "bingshuo/hololake-world",
-      "bingshuo/lighthouse"
-    ],
-    "online_module_catalog_registry": "NOT_IMPLEMENTED",
-    "local_signed_module_lifecycle": "IMPLEMENTED_FOR_BUNDLED_PACKAGES",
-    "application_release_signing": "PERSONAL_APPLE_DEVELOPER_TRANSITION"
-  }
-}

product-source/hololake-native-desktop/contracts/domain-number-routing.json

@@ -1,40 +0,0 @@
-{
-  "schema": "hololake.domain-number-routing-contract/v1",
-  "record_id": "HLP-DOMAIN-NUMBER-ROUTER-001",
-  "public_entry": "FIVE_DOMAIN_HOME",
-  "user_selects_domain_before_number": false,
-  "route_key": "USER_NUMBER",
-  "sequence": [
-    "SHOW_FIVE_PUBLIC_DOMAINS",
-    "SUBMIT_USER_NUMBER",
-    "RESOLVE_REGISTERED_DOMAIN_ROUTE",
-    "VERIFY_NUMBER_AT_DOMAIN_REGISTRY",
-    "SHOW_RESOLVED_DOMAIN",
-    "LOAD_DOMAIN_SPECIFIC_LOGIN_AND_NODE_ENTRY"
-  ],
-  "registries": {
-    "FIFTH_DOMAIN": {
-      "ownership": "ICE-GL_INFINITY_PRIVATE_DOMAIN",
-      "source": "FIFTH_DOMAIN_REGISTERED_REPOSITORY_AND_SERVICE"
-    },
-    "ENTERPRISE_FOUR_DOMAINS": {
-      "ownership": "TCS_0002_ENTERPRISE_REALITY_BODY",
-      "source": "ENTERPRISE_ROOT_SERVER_DOMAIN_REGISTRIES",
-      "resolve_url": "https://guanghu.chat/api/hololake/enterprise/resolve",
-      "login_host": "guanghu.chat"
-    }
-  },
-  "routing": {
-    "number_shape_is_authority": false,
-    "client_supplied_domain_is_authority": false,
-    "registered_router_and_domain_verifier_required": true,
-    "canonical_number_and_known_domain_required": true,
-    "unknown_or_unavailable_route": "FAIL_CLOSED_BEFORE_LOGIN"
-  },
-  "server_runtime": {
-    "fifth_domain_root": "FIFTH_DOMAIN_GUANGHU_OS_RUNTIME_ON_JD_PRIMARY",
-    "enterprise_root": "ENTERPRISE_LIGHTHOUSE_ON_CURRENT_LINUX_SERVICE_NODE",
-    "linux_role": "PHYSICAL_SUBSTRATE_AND_SERVICE_SUPERVISOR",
-    "ordinary_user_node_requires_full_os_install": false
-  }
-}

product-source/hololake-native-desktop/contracts/dynamic-language-world-visual-system.json

@@ -1,83 +0,0 @@
-{
-  "schema": "hololake.dynamic-language-world-visual-system/v1",
-  "record_id": "HLP-DYNAMIC-WORLD-SURFACE-001",
-  "state": "HOLOLAKE_0_5_SIGNED_NUMBERED_SURFACE_ACCEPTED",
-  "package": {
-    "official_module_number": "HLP-MOD-OFFICIAL-DYNAMIC-WORLD-SURFACE-0001",
-    "adapter": "dynamic-language-world-surface-v1",
-    "registration_class": "OFFICIAL_LIGHTHOUSE",
-    "activation": "SIGNED_PACKAGE_PLUS_EXPLICIT_HUMAN_PERMISSION_CONFIRMATION"
-  },
-  "numbered_ipc": {
-    "module": "HLP-NIPC-MOD-0031",
-    "target": "HLP-NIPC-TGT-0031",
-    "operations": ["HLP-NIPC-OP-0147"],
-    "public_tauri_commands": ["numbered_ipc"],
-    "mismatched_coordinate": "FAIL_CLOSED"
-  },
-  "dynamic_inputs": ["BEIJING_TIME", "VERIFIED_CURRENT_WEATHER"],
-  "weather": {
-    "provider": "Open-Meteo",
-    "endpoint": "https://api.open-meteo.com/v1/forecast",
-    "maximum_request_seconds": 5,
-    "cache_ttl_seconds": 600,
-    "redirects": "DENIED",
-    "unavailable_behavior": "BEIJING_TIME_ONLY_NO_FAKE_WEATHER"
-  },
-  "visual_lock": {
-    "layout": "QODER_VISUAL_LANGUAGE_SEMANTICALLY_REASSEMBLED_ON_RESPONSIVE_HOLOLAKE_SHELL",
-    "language_world_themes": ["夜湖星光", "晨湖曦光", "星云紫夜", "烛畔暖湖", "清浅澄湖"],
-    "traditional_finishes": ["曜夜", "星辉", "深海", "翡翠", "朱砂", "香槟", "瓷光", "雪霁"],
-    "all_downstream_pages_inherit_active_surface_tokens": true,
-    "ambient_motion_requires_recent_human_pointer_or_keyboard_activity": true,
-    "idle_visual_state": "STATIC",
-    "responsive_layout": "CONTAINER_MEASURED_PANORAMIC_WIDE_COMPACT_STACKED_REFLOW",
-    "domain_semantic_order_is_stable": true,
-    "private_channel_separates_native_organs_from_installed_modules": true,
-    "climate_changes_routing_permission_or_fact": false,
-    "daily_sampling_domain_changes_open_domain": false,
-    "real_city_exposed_in_ui": false,
-    "coordinates_exposed_in_ui": false,
-    "mechanical_flow_lines": false,
-    "heavy_webgl": false
-  },
-  "donor_disposition": {
-    "world_climate": "EXTRACTED_REWRITTEN_AND_NUMBERED",
-    "starlake_surface": "QODER_LOCKED_SOURCE_ADMITTED_WITH_RESPONSIVE_AND_IDLE_MOTION_ADAPTER",
-    "traditional_surface": "QODER_LOCKED_SOURCE_ADMITTED_WITH_REAL_NUMBERED_PROJECTIONS_ONLY",
-    "traditional_surface_css": "QODER_LOCKED_EIGHT_FINISH_TOKEN_SYSTEM_ADMITTED_AND_SCOPED_ACROSS_ALL_PAGES",
-    "fake_broadcasts_and_fake_metrics": "REJECTED"
-  },
-  "qoder_source_provenance": {
-    "root": "/Volumes/JZAO/铸渊-ICE-GL-ZY001/OUT-输出/UI-预览-20260818/deploy-staging",
-    "main_tsx_sha256": "7dab8596ec0bd2609b1b23b175f1f14f15f2aa9af847eb605692c993d2e876e8",
-    "traditional_surface_tsx_sha256": "c713dc27681e07c510a2125816dcefb3255252fc0b570e350af7a98f57fc220d",
-    "traditional_surface_css_sha256": "3e6c446fb84a16ed23b0fd51466ad9723d0c0670ee6ddf6653f61237bd00baa6",
-    "starlake_surface_css_sha256": "471e3edef02236e6463144ac75b526f0f98782b5476b9db786e7cd0614a83227",
-    "acceptance_html_sha256": "7a41e426f1576fe0e25182e0c2efee65302b064d86363c890b0f235386a9c070"
-  },
-  "current_acceptance": {
-    "state": "PASS_NUMBERED_QODER_SURFACES_REAL_DATA_RESPONSIVE_IDLE_AND_RESTART",
-    "module_package_sha256": "b6ba13b9f70bd617b2a303ec2eb0ea11d5354d10118c7f3e5179ae8100cd2602",
-    "module_package_signature": "PASS_EMBEDDED_PRODUCT_TRUST",
-    "numbered_route": "HLP-NIPC-MOD-0031/HLP-NIPC-OP-0147/HLP-NIPC-TGT-0031",
-    "signed_app_binary_sha256": "b0422bb18df521ace54ff1a52cd47121d92833dd78f165845deba7806686c7ac",
-    "signed_app_cdhash": "42640f7ce56e96403609899095c77ea6171df07d",
-    "apple_team_identifier": "825A9L3G7Q",
-    "module_receipts": {
-      "install": "2bb903cd369c8f57432c59367fd5494ee89a75214d5129511190e2337cecdbc4",
-      "mount": "aed4d00e51849ae5e9c0258fe2f93afc8bff8d927905cdd7fabd9bf32c4bc66c",
-      "self_test_pass": "404a0eeddb866bc3050b407c586c036f3707db577e1edf9f1cf3129c1cc9cc1d"
-    },
-    "real_weather_readback": "PASS_VERIFIED_LIVE_NIGHT_CLOUD_WITHOUT_CITY_OR_COORDINATES",
-    "restart_restore": "PASS_ACTIVE_MODULE_REAL_CLIMATE_THEME_AND_WEB_NOVEL_CHAPTER_RESTORED",
-    "official_shell_preserved": "QODER_LOCKED_SURFACES_ADMITTED_WITH_NUMBERED_FUNCTION_ROUTING_UNCHANGED",
-    "visual_comparison": "audit/qoder-traditional-reference-vs-hololake-0.5.0.jpg",
-    "idle_static_psnr_db": 59.502493,
-    "idle_static_clock_unchanged": true,
-    "web_novel_new_chapter_modal": "PASS",
-    "web_novel_created_chapter_restart_persistence": "PASS_1_CHAPTER_VISIBLE_AFTER_RESTART",
-    "traditional_theme_downstream_pages": ["CHANNEL", "WEB_NOVEL", "EDUCATION"],
-    "notarization": "FINAL_RELEASE_CANDIDATE_PENDING"
-  }
-}

product-source/hololake-native-desktop/contracts/education-workspace.json

@@ -1,265 +0,0 @@
-{
-  "schema": "hololake.education-workspace/v1",
-  "record_id": "HLP-EDUCATION-WORKSPACE-001",
-  "state": "ADMITTED_INSTALLED_RUNTIME_ACCEPTED",
-  "domain_entry": "BRANCH_DOMAIN",
-  "industry": "EDUCATION",
-  "channel_id": "GH-EDU-INIT-001",
-  "package": {
-    "package_key": "hololake.official.education-workbench",
-    "official_module_number": "HLP-MOD-OFFICIAL-EDUCATION-WORKBENCH-0001",
-    "registration_state": "OFFICIAL_NUMBER_ACCEPTED",
-    "current_mount": "ACTIVE_AFTER_SIGNED_INSTALL_MOUNT_AND_SELF_TEST",
-    "future_distribution": "HOLOLAKE_OFFICIAL_MODULE_MARKETPLACE"
-  },
-  "foundation_dependency": {
-    "module_id": "hololake.builtin.channel-workbench",
-    "state": "BUILT_IN_FOUNDATION",
-    "engines": ["LEXICAL_0_49", "FORTUNE_SHEET_1_0_4"],
-    "rule": "EDUCATION_MODULE_CONSUMES_FOUNDATION_WITHOUT_DUPLICATING_OFFICE_ENGINES"
-  },
-  "native_storage": {
-    "owner": "HOLOLAKE_NATIVE_RUST_CORE",
-    "namespace": "education-workspace-v1",
-    "engine": "SQLITE",
-    "authenticated_account_required": true,
-    "cross_account_projection_allowed": false,
-    "public_catalog_contains_private_data": false,
-    "restart_readback_required": true
-  },
-  "document_module": {
-    "module_id": "EDU-DOCUMENT",
-    "state": "DEVELOPMENT_FEATURE_MOUNTED",
-    "engine": "CHANNEL_WORKBENCH_LEXICAL_0_49_0_WITH_EDUCATION_TEMPLATES_AND_HOLOLAKE_MARKDOWN_STATE",
-    "capabilities": [
-      "LIST",
-      "CREATE",
-      "CREATE_COPY",
-      "READ",
-      "EDIT_TITLE_AND_BODY",
-      "EXPLICIT_READ_AND_EDIT_MODES",
-      "HUMAN_SETTINGS_MENU",
-      "BASIC_FORMATTING_TOOLBAR",
-      "RICH_TEXT_COMMAND_ENGINE",
-      "UNDO_AND_REDO_HISTORY",
-      "MARKDOWN_SHORTCUTS_AND_BIDIRECTIONAL_STATE_TRANSLATION",
-      "TITLE_DIRECTORY_FILTER",
-      "FORMAL_TEACHING_TEMPLATES",
-      "NATIVE_READING_CANVAS",
-      "EXPORT_MARKDOWN_AND_HTML",
-      "SAVE_WITH_EXPECTED_REVISION",
-      "RECOVERABLE_ARCHIVE"
-    ]
-  },
-  "table_module": {
-    "module_id": "EDU-TABLE",
-    "state": "DEVELOPMENT_FEATURE_MOUNTED",
-    "engine": "CHANNEL_WORKBENCH_FORTUNE_SHEET_1_0_4_FOR_REAL_CELLS_AND_FORMULAS_PLUS_TANSTACK_8_21_3_FOR_EDUCATION_VIEWS",
-    "capabilities": [
-      "LIST",
-      "CREATE",
-      "CREATE_COPY",
-      "READ",
-      "EDIT_TITLE",
-      "HUMAN_SETTINGS_MENU",
-      "ADD_AND_REMOVE_COLUMNS",
-      "ADD_AND_REMOVE_ROWS",
-      "EDIT_CELLS",
-      "TITLE_DIRECTORY_FILTER",
-      "CELL_CONTENT_FILTER",
-      "COLUMN_SORT_ASCENDING_DESCENDING_OR_SOURCE_ORDER",
-      "HEADLESS_FILTER_SORT_GROUP_AND_AGGREGATE_ROW_MODELS",
-      "BOUNDED_PAGINATION_ROW_MODEL_FOR_LARGE_EDITABLE_TABLES",
-      "GRID_AND_EDITABLE_CARD_VIEWS",
-      "GROUPED_CLASSIFICATION_BOARD_FROM_SELECTED_FIELD",
-      "LIVE_DATA_OVERVIEW_WITH_SELECTED_GROUP_AND_MEASURE",
-      "HEADLESS_TABLE_DATA_DETACHED_OUTSIDE_TABLE_SURFACE",
-      "MULTI_ROW_MULTI_COLUMN_TABULAR_PASTE",
-      "EXTERNAL_SPREADSHEET_IMPORT_WITH_PREWRITE_PROFILE",
-      "XLSX_CSV_TSV_AND_NATIVE_EXPORT",
-      "SAVE_WITH_EXPECTED_REVISION",
-      "RECOVERABLE_ARCHIVE"
-    ],
-    "limits": {
-      "maximum_columns": 30,
-      "maximum_rows": 1000,
-      "maximum_cell_bytes": 10000
-    },
-    "sensitive_field_visibility": {
-      "local_default": "HIDDEN_UNTIL_HUMAN_REVEALS",
-      "human_can_hide": true,
-      "human_can_show_again": true,
-      "external_model_transfer_authority": "SEPARATE_EXPLICIT_PER_FILE_CONSENT"
-    }
-  },
-  "content_translation_layer": {
-    "service_id": "EDU-CONTENT-TRANSLATOR",
-    "state": "DETERMINISTIC_RUNTIME_READY_MODEL_ASSIST_SLOT_RESERVED",
-    "profile_schema": "hololake.content-profile/v1",
-    "import_adapter": "EDU-TABLE-IMPORT-ADAPTER/v1",
-    "export_adapter": "EDU-TABLE-EXPORT-ADAPTER/v1",
-    "order": [
-      "FILE_CONTAINER_SNIFF",
-      "PAGE_AND_STRUCTURE_INVENTORY",
-      "BOUNDED_LOCAL_RECOGNITION",
-      "EXPLAINABLE_SEMANTIC_FOCUS_INFERENCE",
-      "UNASSIGNED_CHANNEL_STAGING",
-      "HUMAN_INDUSTRY_ROUTE_DECISION",
-      "NATIVE_TRANSLATION",
-      "ATOMIC_MODULE_REGISTRATION_AFTER_CONFIRMATION",
-      "HUMAN_RECEIPT"
-    ],
-    "import_assignment": {
-      "default_scope": "UNASSIGNED",
-      "education_directory_before_human_confirmation": false,
-      "existing_legacy_imports_reclassified_on_migration": true,
-      "source_file_mutated": false
-    },
-    "supported_imports": ["XLSX", "XLS", "XLSM", "XLSB", "ODS", "CSV", "TSV", "HOLOLAKE_NATIVE"],
-    "supported_exports": ["XLSX", "CSV", "TSV", "HOLOLAKE_NATIVE"],
-    "local_import_without_model_api": "ENABLED_FOR_ALL_SUPPORTED_FORMATS",
-    "semantic_focus": {
-      "current_mode": "DETERMINISTIC_BASELINE_ONLY",
-      "signals": ["SOURCE_AND_PAGE_TITLE", "COLUMN_SEMANTICS", "NUMERIC_COVERAGE"],
-      "low_confidence_behavior": "ASK_HUMAN_TO_SELECT_PRIMARY_MEASURE",
-      "model_dynamic_judgment": "RESERVED_FOR_MODEL_API_AND_AGENT_STAGE"
-    },
-    "adaptive_rendering": {
-      "current_mode": "DETERMINISTIC_BASELINE_WITH_EXPLAINABLE_DEGRADATION",
-      "editable_cell_budget": 240,
-      "baseline_inputs": [
-        "ROW_COUNT",
-        "COLUMN_COUNT",
-        "FIELD_TYPES",
-        "NUMERIC_COVERAGE",
-        "GROUP_CARDINALITY",
-        "FOCUS_CONFIDENCE"
-      ],
-      "degradation_order": [
-        "LARGE_EDITABLE_GRID_TO_DYNAMIC_PAGINATION",
-        "NO_RELIABLE_MEASURE_TO_COUNT_SUMMARY",
-        "AMBIGUOUS_FOCUS_TO_HUMAN_SELECTION",
-        "UNSUPPORTED_STRUCTURE_TO_HUMAN_ASSISTANCE_RECEIPT"
-      ],
-      "local_baseline_always_available": true,
-      "model_adjustment": {
-        "api_slot": "HOLOLAKE_MODEL_RECOGNITION_API/v1",
-        "state": "RESERVED_FOR_MODEL_API_AND_AGENT_STAGE",
-        "proposal_fields": [
-          "PRIMARY_FOCUS",
-          "GROUP_FIELD",
-          "MEASURE_FIELD",
-          "VIEW_COMPOSITION",
-          "PAGE_DENSITY"
-        ],
-        "proposal_must_pass_local_structure_validation": true,
-        "proposal_must_obey_local_resource_limits": true,
-        "human_confirmation_before_rule_activation": true,
-        "model_can_mutate_source_data": false,
-        "failure_behavior": "RETURN_TO_LOCAL_BASELINE_WITH_RECEIPT"
-      }
-    },
-    "unknown_input_behavior": "RETURN_HUMAN_ASSISTANCE_RECEIPT_WITHOUT_MODULE_WRITE_OR_EXTERNAL_MODEL_TRANSFER",
-    "model_assist": {
-      "api_slot": "HOLOLAKE_MODEL_RECOGNITION_API/v1",
-      "current_state": "NOT_CONFIGURED",
-      "provider": "USER_SELECTED",
-      "secret_storage": "OPERATING_SYSTEM_SECRET_STORE_REQUIRED",
-      "file_transfer_default": "DENY_UNTIL_EXPLICIT_PER_FILE_CONSENT",
-      "rule_update_flow": ["MODEL_CANDIDATE", "LOCAL_VALIDATION", "HUMAN_CONFIRMATION", "VERSIONED_INSTALL"],
-      "learning_scopes": ["PRIVATE_ONLY", "SHARE_ANONYMIZED_RULE"]
-    },
-    "source_file_mutation_allowed": false,
-    "silent_truncation_allowed": false
-  },
-  "data_cleanup_module": {
-    "module_id": "EDU-DATA",
-    "state": "DEVELOPMENT_FEATURE_MOUNTED",
-    "source": "CURRENT_AUTHENTICATED_ACCOUNTS_EDUCATION_TABLES",
-    "capabilities": [
-      "SELECT_ACCOUNT_TABLE",
-      "TRIM_CELL_BOUNDARY_WHITESPACE",
-      "REMOVE_FULLY_EMPTY_ROWS",
-      "REMOVE_EXACT_DUPLICATE_ROWS_KEEP_FIRST",
-      "PREVIEW_BEFORE_WRITE",
-      "FULL_TABLE_ANALYSIS_WITH_BOUNDED_CHANGE_PREVIEW",
-      "ACCESSIBILITY_SAFE_NON_TABLE_CHANGE_LIST",
-      "HUMAN_CONFIRMATION_BEFORE_SAVE",
-      "SAVE_WITH_EXPECTED_REVISION"
-    ],
-    "preview_change_limit": 12,
-    "preview_cell_value_character_limit": 120,
-    "full_table_analysis_is_limited_by_preview": false,
-    "automatic_destructive_cleanup_allowed": false,
-    "cross_account_data_allowed": false
-  },
-  "automation_module": {
-    "module_id": "EDU-AUTOMATION",
-    "state": "DEVELOPMENT_FEATURE_MOUNTED",
-    "source": "CURRENT_AUTHENTICATED_ACCOUNTS_EDUCATION_TABLES",
-    "capabilities": [
-      "CREATE_AND_SAVE_RULE",
-      "EQUALS_CONTAINS_EMPTY_AND_NONEMPTY_CONDITIONS",
-      "SET_TARGET_CELL_VALUE",
-      "PREVIEW_MATCHED_ROWS_AND_CHANGED_CELLS",
-      "HUMAN_CONFIRMATION_BEFORE_EXECUTION",
-      "RULE_AND_TABLE_REVISION_LOCK",
-      "SIGNED_PREVIEW_TOKEN",
-      "ATOMIC_TABLE_WRITE_AND_EXECUTION_RECEIPT",
-      "RECOVERABLE_RULE_ARCHIVE"
-    ],
-    "background_or_scheduled_execution_allowed": false,
-    "cross_account_data_allowed": false,
-    "model_execution_authority_granted": false
-  },
-  "composition_module": {
-    "module_id": "EDU-COMPOSITION",
-    "state": "DEVELOPMENT_FEATURE_MOUNTED",
-    "source": "CURRENT_AUTHENTICATED_ACCOUNTS_REAL_KNOWLEDGE_CATALOG",
-    "capabilities": [
-      "NATIVE_TYPED_OBJECT",
-      "REGISTERED_MODULE_EXECUTION_GRAPH",
-      "SELECT_DIMENSION_AND_MEASURE",
-      "DASHBOARD_PROJECTION",
-      "COMPARISON_PROJECTION",
-      "VERTICAL_BAR_PROJECTION",
-      "CLASSIFICATION_PROJECTION",
-      "TABLE_PROJECTION",
-      "ONE_EXECUTION_RESULT_MULTIPLE_HUMAN_VIEWS"
-    ],
-    "read_only": true,
-    "hardcoded_sample_data_used": false,
-    "model_execution_authority_granted": false
-  },
-  "remaining_slots": [],
-  "authority": {
-    "browser_local_storage_allowed": false,
-    "webview_direct_file_access_allowed": false,
-    "model_execution_authority_granted": false,
-    "external_application_embedded": false
-  },
-  "current_acceptance": {
-    "state": "PASS",
-    "runtime_module_number": "HLP-MOD-OFFICIAL-EDUCATION-WORKBENCH-0001",
-    "numbered_ipc_module": "HLP-NIPC-MOD-0024",
-    "numbered_operations": "HLP-NIPC-OP-0085..0102",
-    "signed_package_sha256": "a9f6fb7dd9c4aaf910a5d20d0a1d72dea6ab921cf36dd50d46dd88cde3a09e03",
-    "signed_app_binary_sha256": "028592b137fe4f19a642e1301d6fb500e2a4fde50ddb616e229de8a48090803c",
-    "developer_id_team": "825A9L3G7Q",
-    "developer_id_cdhash": "4c88261b4b573d08edcbba8d67d8afe27ad82a3e",
-    "runtime_receipts": {
-      "install": "68f296a11be19c384cb67af9f529a03cb8389bd256c153c5905451fbc0011a24",
-      "mount": "ddb6a51d47f6a58a72a7fc748eff71687cbd04be5dde33dbce590a7abba6af5f",
-      "self_test_pass": "80d59b7c9c2f14005fd8a24748a25c2be0d55198fdcb621f528267ae6dccc12a"
-    },
-    "restart_readback": {
-      "module_state": "ACTIVE",
-      "document": "冰朔教育迁移验收 · revision 2",
-      "table": "冰朔教育迁移验收表 · 1 row · revision 4",
-      "automation": "验收状态自动化 · preview 1 row / 1 cell · APPLIED revision 3 to 4"
-    },
-    "existing_user_data_deleted_or_overwritten": false,
-    "apple_notarization_scope": "FINAL_RELEASE_CANDIDATE_ONLY_NOT_THIS_DEBUG_ACCEPTANCE_BUNDLE"
-  },
-  "open_source_donor_assessment": "contracts/education-open-source-donor-assessment.json"
-}

product-source/hololake-native-desktop/contracts/enterprise-four-domain-entry.json

@@ -1,13 +0,0 @@
-{
-  "schema": "hololake.enterprise-four-domain-entry/v1",
-  "record_id": "HLP-ENTERPRISE-4D-ENTRY-CONTRACT-001",
-  "state": "SERVER_LIVE_CLIENT_UI_INTEGRATED",
-  "number_gate": {"precedes_credentials":true,"user_selects_domain":false},
-  "credential_gate": {"uses_bound_private_repository":true,"first_login_forces_password_change":true},
-  "persona_relationship_gate": {"shows_species":"AGE","shows_current_persona_identity":true,"shows_invalid_age_individual_numbers":false,"human_confirms_relationship_mapping":true,"human_confirmation_is_persona_acceptance":false,"responsibility_acceptance_is_separate":true},
-  "work_entry": {"domain":"DOMAIN-ZS","channel":"GUANGHU_CHANNEL","preserves_responsibility_domain":true},
-  "personal_route": {"separate_node_ownership_check":true,"enterprise_credentials_are_sufficient":false,"self_connection_guide_visible_in_zero_sense_domain":true,"connection_executor":"HUMAN_OR_OWN_PERSONA"},
-  "desktop_install_acceptance": {"mac_arm64":"SIGNED_LOCAL_BOOTSTRAP_PASS_NOTARIZATION_PENDING","mac_x86_64":"NOT_BUILT","windows":"NOT_BUILT","automatic_update_channel":"PUBLIC_CHECK_PASS_NO_ACTIVE_RELEASE"},
-  "ui_template": "REPO-012@27d34dfdbf5df4c67b805402d442e5912c8f4c31:official-login-template-v0.4-locked+inner-screens-v0.1",
-  "source": "routing/hololake-enterprise-four-domain-work-channel.json"
-}

product-source/hololake-native-desktop/contracts/external-ai-gateway.json

@@ -1,32 +0,0 @@
-{
-  "schema": "hololake.external-ai-gateway/v1",
-  "record_id": "HLP-EXTERNAL-AI-GATEWAY-001",
-  "state": "IMPLEMENTED_HUMAN_GATED",
-  "default_exposure": "CLOSED",
-  "human_authorization_required": true,
-  "mcp": {
-    "transport": "STDIO_JSON_RPC",
-    "protocol_version": "2025-06-18",
-    "role": "DISCOVERY_AND_CAPABILITY_CATALOG",
-    "persistent_continuity_owner": false
-  },
-  "direct_protocol": {
-    "protocol": "HOLOLAKE_TERMINAL_LINK/3",
-    "transport": "USER_PRIVATE_LOCAL_SOCKET_OR_NAMED_PIPE",
-    "continuity_owner": "HOLOLAKE",
-    "switch_after_mcp_discovery": true
-  },
-  "catalog": {
-    "physical_modules": "CALLABLE_ONLY_THROUGH_REGISTERED_NUMBERED_ROUTES",
-    "cognitive_skills": "READ_ONLY_RESOURCES_WITHOUT_EXECUTION_AUTHORITY",
-    "human_readable_names_required": true,
-    "machine_numbers_secondary": true
-  },
-  "boundaries": {
-    "supervised_shell_execution": false,
-    "general_agent_tool_loop": false,
-    "transport_is_authority": false,
-    "mcp_is_continuity_owner": false,
-    "unknown_capability": "FAIL_CLOSED"
-  }
-}

product-source/hololake-native-desktop/contracts/gls-executable-projections.json

@@ -1,32 +0,0 @@
-{
-  "schema": "hololake.gls-executable-projections/v2",
-  "source_commit": "104a5d73162bdf4a529701e65898e2bc2863ea9e",
-  "runtime_graph_rule": "ONLY_EXPLICIT_RUNTIME_REQUIRES_EDGES_ENTER_ACTIVATION_GRAPH",
-  "projections": {
-    "GLS-0250": {"stage":"P0","projection_kind":"TYPED_FACT_AND_DOMAIN_BOUNDARY","adapter":"origin-domain-topology","event_kinds":["BOOTSTRAP","DOMAIN_ROUTE"],"dependencies":[]},
-    "GLS-0253": {"stage":"P0","projection_kind":"DETERMINISTIC_IDENTITY_AND_NUMBERING_GUARD","adapter":"zero-core-numbering","event_kinds":["IDENTITY_ROUTE","IDENTITY_ADMISSION","NUMBERING_RESOLVE"],"dependencies":["GLS-0250","GLS-0262","GLS-0263"]},
-    "GLS-0262": {"stage":"P0","projection_kind":"REALITY_ENGINEERING_STAGE_GATE","adapter":"reality-engineering-stage","event_kinds":["RUNTIME_STAGE"],"dependencies":[]},
-    "GLS-0263": {"stage":"P0","projection_kind":"LANGUAGE_PRODUCT_DUAL_UPDATE_BOUNDARY","adapter":"dual-update-channel","event_kinds":["PROTOCOL_UPDATE","PRODUCT_UPDATE"],"dependencies":["GLS-0250","GLS-0262"]},
-    "GLS-0301": {"stage":"P1","projection_kind":"STRICT_MESSAGE_ENVELOPE_CODEC","adapter":"glp-envelope-codec","event_kinds":["MESSAGE_VALIDATE"],"dependencies":["GLS-0250"]},
-    "GLS-0302": {"stage":"P1","projection_kind":"IDENTITY_REFERENCE_WITHOUT_AUTHORITY","adapter":"glp-identity-reference","event_kinds":["IDENTITY_VERIFY"],"dependencies":["GLS-0253"]},
-    "GLS-0303": {"stage":"P1","projection_kind":"FAIL_CLOSED_CONTEXT_GUARD","adapter":"glp-context-guard","event_kinds":["CONTEXT_RESOLVE"],"dependencies":["GLS-0301","GLS-0302"]},
-    "GLS-0306": {"stage":"P1","projection_kind":"HASH_CHAIN_DECISION_RECEIPT_LEDGER","adapter":"glp-decision-kernel","event_kinds":["DECISION_RECEIPT","PROTOCOL_DECIDE"],"dependencies":["GLS-0301","GLS-0302","GLS-0303"]},
-    "GLS-0307": {"stage":"P2","projection_kind":"BOUNDED_HEARTBEAT_LEASE_GUARD","adapter":"glp-live-coordination","event_kinds":["HEARTBEAT_OBSERVE"],"dependencies":["GLS-0302","GLS-0306"]},
-    "GLS-0309": {"stage":"P2","projection_kind":"SEPARATION_OF_DUTIES_WORK_ORDER_STATE_MACHINE","adapter":"glp-live-coordination","event_kinds":["WORK_ORDER_TRANSITION"],"dependencies":["GLS-0302","GLS-0303","GLS-0306"]},
-    "GLS-0842": {"stage":"P2","projection_kind":"AUTHENTICATED_LIVE_SESSION_ADAPTER","adapter":"glp-live-coordination","event_kinds":["LIVE_SESSION_OBSERVE"],"dependencies":["GLS-0301","GLS-0302","GLS-0303","GLS-0306","GLS-0307"]},
-    "GLS-0311": {"stage":"P2","projection_kind":"APPEND_ONLY_TARGET_EVIDENCE_WITNESS","adapter":"glp-live-coordination","event_kinds":["WITNESS_APPEND"],"dependencies":["GLS-0306","GLS-0307","GLS-0842"]},
-    "GLS-0304": {"stage":"P3","projection_kind":"CONFLICT_PRESERVING_MEMORY_SYNC","adapter":"glp-continuity-kernel","event_kinds":["MEMORY_SYNC"],"dependencies":["GLS-0303","GLS-0306"]},
-    "GLS-0308": {"stage":"P3","projection_kind":"CAUSAL_STATE_SYNC_WITHOUT_LAST_WRITE_WINS","adapter":"glp-continuity-kernel","event_kinds":["STATE_SYNC"],"dependencies":["GLS-0303","GLS-0304","GLS-0306"]},
-    "GLS-0827": {"stage":"P3","projection_kind":"MONOTONIC_TIME_AND_SINGLE_PRIMARY_LEASE","adapter":"glp-continuity-kernel","event_kinds":["TIME_CONTINUITY"],"dependencies":["GLS-0304","GLS-0307","GLS-0308"]},
-    "GLS-0710": {"stage":"P4","projection_kind":"IMMUTABLE_DIGEST_BOUND_MODULE_BACKPACK","adapter":"gls-execution-control","event_kinds":["MODULE_ADMIT"],"dependencies":["GLS-0306"]},
-    "GLS-0803": {"stage":"P4","projection_kind":"EXECUTION_BODY_LIFECYCLE_STATE_MACHINE","adapter":"gls-execution-control","event_kinds":["LIFECYCLE_TRANSITION"],"dependencies":["GLS-0710","GLS-0827"]},
-    "GLS-0819": {"stage":"P4","projection_kind":"ISOLATED_RESOURCE_RUNWAY_SCHEDULER","adapter":"gls-execution-control","event_kinds":["RUNWAY_ASSIGN","RUNWAY_RELEASE"],"dependencies":["GLS-0803"]},
-    "GLS-0310": {"stage":"P4","projection_kind":"UNIQUE_CONTROL_EPOCH_STATE_MACHINE","adapter":"gls-execution-control","event_kinds":["BROADCAST_TRANSITION"],"dependencies":["GLS-0301","GLS-0302","GLS-0303","GLS-0306","GLS-0803","GLS-0819"]},
-    "GLS-0709": {"stage":"P5","projection_kind":"SEMANTIC_EXTERNAL_ADAPTER_WITHOUT_EXECUTION_AUTHORITY","adapter":"gls-external-resource-boundary","event_kinds":["EXTERNAL_ADAPTER_TRANSLATE"],"dependencies":["GLS-0301","GLS-0302","GLS-0303","GLS-0306"]},
-    "GLS-0708": {"stage":"P5","projection_kind":"REPLACEABLE_MODEL_RESOURCE_ROUTER","adapter":"gls-external-resource-boundary","event_kinds":["MODEL_ROUTE"],"dependencies":["GLS-0306","GLS-0709"]},
-    "GLS-0828": {"stage":"P5","projection_kind":"EPHEMERAL_SANDBOXED_CAPABILITY_EXTENSION","adapter":"gls-external-resource-boundary","event_kinds":["TEMPORARY_CAPABILITY"],"dependencies":["GLS-0311","GLS-0709","GLS-0710"]},
-    "GLS-0411": {"stage":"P6","projection_kind":"RESTRICTED_HLDP_NATIVE_PROGRAM_PROFILE","adapter":"gls-bootstrap-compiler","event_kinds":["HLDP_NP_VALIDATE"],"dependencies":["GLS-0301","GLS-0302","GLS-0303","GLS-0306"]},
-    "GLS-0131": {"stage":"P6","projection_kind":"DETERMINISTIC_GIR_SCHEMA","adapter":"gls-bootstrap-compiler","event_kinds":["GIR_VALIDATE"],"dependencies":["GLS-0411"]},
-    "GLS-0130": {"stage":"P6","projection_kind":"BOOTSTRAP_HLDP_TO_GIR_COMPILER","adapter":"gls-bootstrap-compiler","event_kinds":["COMPILE_HLDP"],"dependencies":["GLS-0411","GLS-0131"]}
-  }
-}

product-source/hololake-native-desktop/contracts/gls-native-runtime-kernel.json

@@ -1,42 +0,0 @@
-{
-  "schema": "hololake.gls-native-runtime-kernel/v1",
-  "record_id": "HLP-GLS-NATIVE-RUNTIME-KERNEL-001",
-  "source_commit": "104a5d73162bdf4a529701e65898e2bc2863ea9e",
-  "receipt_schema": "hololake.protocol-decision-receipt/v1",
-  "decision_set": ["ALLOW", "DENY", "AMBIGUOUS", "UNVERIFIED"],
-  "runtime_boundaries": {
-    "identity_is_authority": false,
-    "model_is_persona": false,
-    "model_can_override_decision": false,
-    "raw_protocol_text_executed": false,
-    "arbitrary_external_code_executed": false,
-    "last_write_wins_on_concurrent_state": false,
-    "target_evidence_required_for_completion": true,
-    "every_decision_writes_receipt": true
-  },
-  "stages": [
-    {"id":"P1","state":"IMPLEMENTED_NATIVE","protocols":["GLS-0301","GLS-0302","GLS-0303","GLS-0306"]},
-    {"id":"P2","state":"IMPLEMENTED_NATIVE","protocols":["GLS-0307","GLS-0309","GLS-0311","GLS-0842"]},
-    {"id":"P3","state":"IMPLEMENTED_NATIVE","protocols":["GLS-0304","GLS-0308","GLS-0827"]},
-    {"id":"P4","state":"IMPLEMENTED_NATIVE","protocols":["GLS-0710","GLS-0803","GLS-0819","GLS-0310"]},
-    {"id":"P5","state":"IMPLEMENTED_NATIVE","protocols":["GLS-0709","GLS-0708","GLS-0828"]},
-    {"id":"P6","state":"IMPLEMENTED_BOOTSTRAP_SELF_CHECK","protocols":["GLS-0411","GLS-0130","GLS-0131"]},
-    {"id":"P7","state":"ASSEMBLY_REGISTRY_FAIL_CLOSED","protocols":["GLS-0836","GLS-0840","GLS-0841","GLS-0842","GLS-0843","GLS-0844","GLS-0845","GLS-0846","GLS-0847","GLS-0848","GLS-0849"]}
-  ],
-  "p7_node_assemblies": [
-    {"protocolId":"GLS-0836","target":"DESKTOP_HOLOLAKE","state":"UNVERIFIED_TARGET_CAPABILITY","sourceEvidenceNode":"BS-SH-005"},
-    {"protocolId":"GLS-0840","target":"DESKTOP_HOLOLAKE","state":"UNVERIFIED_TARGET_CAPABILITY","sourceEvidenceNode":"BS-SH-005"},
-    {"protocolId":"GLS-0841","target":"DESKTOP_HOLOLAKE","state":"UNVERIFIED_TARGET_CAPABILITY","sourceEvidenceNode":"BS-SH-005"},
-    {"protocolId":"GLS-0842","target":"DESKTOP_HOLOLAKE","state":"LOCAL_ADAPTER_IMPLEMENTED_TARGET_HEALTH_UNVERIFIED","sourceEvidenceNode":"JD-FD-PRIMARY"},
-    {"protocolId":"GLS-0843","target":"DESKTOP_HOLOLAKE","state":"UNVERIFIED_TARGET_CAPABILITY","sourceEvidenceNode":"BS-SH-005"},
-    {"protocolId":"GLS-0844","target":"DESKTOP_HOLOLAKE","state":"LOCAL_QUALITY_GATE_AVAILABLE_NOT_PHYSICAL_OS_EVIDENCE","sourceEvidenceNode":"BS-SH-005"},
-    {"protocolId":"GLS-0845","target":"DESKTOP_HOLOLAKE","state":"UNVERIFIED_TARGET_CAPABILITY","sourceEvidenceNode":"BS-SH-005"},
-    {"protocolId":"GLS-0846","target":"DESKTOP_HOLOLAKE","state":"UNVERIFIED_TARGET_CAPABILITY","sourceEvidenceNode":"BS-SH-005"},
-    {"protocolId":"GLS-0847","target":"DESKTOP_HOLOLAKE","state":"UNVERIFIED_TARGET_CAPABILITY","sourceEvidenceNode":"BS-SH-005"},
-    {"protocolId":"GLS-0848","target":"DESKTOP_HOLOLAKE","state":"UNVERIFIED_TARGET_CAPABILITY","sourceEvidenceNode":"BS-SH-005"},
-    {"protocolId":"GLS-0849","target":"DESKTOP_HOLOLAKE","state":"UNVERIFIED_TARGET_CAPABILITY","sourceEvidenceNode":"BS-SH-005"}
-  ],
-  "lifecycle_states": ["REGISTERED","DORMANT","RESIDENT","SUMMONED","ASSIGNED","FETCHING","VERIFYING","MATERIALIZING","RUNNING","SUPERVISING","STOPPING","CLEANING","RECEIPT","RETURNED"],
-  "broadcast_actions": ["REGISTER","SUMMON","ASSIGN","START","SUPERVISE","STOP","CLEAN","RECEIPT","RETURN"],
-  "work_order_stages": ["REGISTERED","TESTED","PUBLISHED","DEPLOYED"]
-}

product-source/hololake-native-desktop/contracts/gls-numbered-reference-nodes.json

@@ -1,33 +0,0 @@
-{
-  "schema": "hololake.gls-numbered-reference-nodes/v1",
-  "record_id": "HLP-GLS-NUMBERED-REFERENCE-REGISTRY-001",
-  "source": {
-    "repository": "REPO-012",
-    "commit": "104a5d73162bdf4a529701e65898e2bc2863ea9e"
-  },
-  "policy": {
-    "number_is_coordinate_not_authority": true,
-    "independent_protocol_source_required_for_execution": true,
-    "reference_only_nodes_may_execute": false,
-    "unknown_reference": "FAIL_CLOSED",
-    "unresolved_number_reference_allowed": false
-  },
-  "nodes": [
-    {"protocol_id":"GLS-0010","node_number":"HLP-GLS-REF-0010","title":"Guanghu Protocol Registry Center Standard","reference_kind":"NORMATIVE_REFERENCE","source_state":"ROADMAP_REFERENCE_ONLY"},
-    {"protocol_id":"GLS-0140","node_number":"HLP-GLS-REF-0140","title":"Context Loading Specification","reference_kind":"NORMATIVE_REFERENCE","source_state":"ROADMAP_REFERENCE_ONLY"},
-    {"protocol_id":"GLS-0401","node_number":"HLP-GLS-REF-0401","title":"Tree","reference_kind":"SCHEMA_IMPORT","source_state":"ROADMAP_REFERENCE_ONLY"},
-    {"protocol_id":"GLS-0402","node_number":"HLP-GLS-REF-0402","title":"Leaf","reference_kind":"SCHEMA_IMPORT","source_state":"ROADMAP_REFERENCE_ONLY"},
-    {"protocol_id":"GLS-0403","node_number":"HLP-GLS-REF-0403","title":"Lock","reference_kind":"SCHEMA_IMPORT","source_state":"ROADMAP_REFERENCE_ONLY"},
-    {"protocol_id":"GLS-0404","node_number":"HLP-GLS-REF-0404","title":"Trigger","reference_kind":"SCHEMA_IMPORT","source_state":"ROADMAP_REFERENCE_ONLY"},
-    {"protocol_id":"GLS-0406","node_number":"HLP-GLS-REF-0406","title":"Evidence","reference_kind":"SCHEMA_IMPORT","source_state":"ROADMAP_REFERENCE_ONLY"},
-    {"protocol_id":"GLS-0407","node_number":"HLP-GLS-REF-0407","title":"Correction","reference_kind":"SCHEMA_IMPORT","source_state":"ROADMAP_REFERENCE_ONLY"},
-    {"protocol_id":"GLS-0409","node_number":"HLP-GLS-REF-0409","title":"Machine-State History","reference_kind":"SCHEMA_IMPORT","source_state":"ROADMAP_REFERENCE_ONLY"},
-    {"protocol_id":"GLS-0602","node_number":"HLP-GLS-REF-0602","title":"Authorization","reference_kind":"SCHEMA_IMPORT","source_state":"ROADMAP_REFERENCE_ONLY"},
-    {"protocol_id":"GLS-0603","node_number":"HLP-GLS-REF-0603","title":"Signature","reference_kind":"SCHEMA_IMPORT","source_state":"ROADMAP_REFERENCE_ONLY"},
-    {"protocol_id":"GLS-0604","node_number":"HLP-GLS-REF-0604","title":"Integrity","reference_kind":"EVIDENCE_ONLY","source_state":"ROADMAP_REFERENCE_ONLY"},
-    {"protocol_id":"GLS-0605","node_number":"HLP-GLS-REF-0605","title":"Semantic Safety Boundary","reference_kind":"SCHEMA_IMPORT","source_state":"ROADMAP_REFERENCE_ONLY"},
-    {"protocol_id":"GLS-0814","node_number":"HLP-GLS-REF-0814","title":"Tool Runtime","reference_kind":"NORMATIVE_REFERENCE","source_state":"ROADMAP_REFERENCE_ONLY"},
-    {"protocol_id":"GLS-0816","node_number":"HLP-GLS-REF-0816","title":"Checkpoint Runtime","reference_kind":"NORMATIVE_REFERENCE","source_state":"ROADMAP_REFERENCE_ONLY"},
-    {"protocol_id":"GLS-0830","node_number":"HLP-GLS-REF-0830","title":"Guanghu Language World Core","reference_kind":"NORMATIVE_REFERENCE","source_state":"ROADMAP_REFERENCE_ONLY"}
-  ]
-}

product-source/hololake-native-desktop/contracts/human-authorization.json

@@ -1,64 +0,0 @@
-{
-  "schema": "hololake.human-authorization-contract/v1",
-  "record_id": "HLP-HUMAN-AUTHORIZATION-001",
-  "state": "NATIVE_FAIL_CLOSED",
-  "roles": {
-    "persona_or_agent": "PROPOSE_EXACT_ACTION_WITH_REASON_IMPACT_AND_ROLLBACK",
-    "human": "APPROVE_OR_DENY_FROM_VERIFIED_HOLOLAKE_CLIENT",
-    "numbering_system": "ISSUE_SESSION_BOUND_SINGLE_USE_TICKET_AND_HASH_CHAINED_RECEIPT"
-  },
-  "lifecycle": [
-    "PENDING_HUMAN",
-    "APPROVED",
-    "DENIED",
-    "EXPIRED",
-    "CONSUMED"
-  ],
-  "supported_actions": [
-    "OPEN_MAINTENANCE",
-    "UNMOUNT",
-    "PROMOTE_VERSION",
-    "RETIRE"
-  ],
-  "destructive_purge": {
-    "enabled": false,
-    "reason": "PURGE_REQUIRES_A_SEPARATE_TWO_STEP_PHYSICAL_DATA_DELETION_PROTOCOL"
-  },
-  "ticket": {
-    "ttl_ms": 900000,
-    "single_use": true,
-    "requester_account_bound": true,
-    "requester_session_bound": true,
-    "client_instance_bound": true,
-    "target_bound": true,
-    "action_bound": true,
-    "replay": "FAIL_CLOSED"
-  },
-  "request": {
-    "ttl_ms": 86400000,
-    "idempotency_required": true,
-    "reason_required": true,
-    "impact_required": true,
-    "rollback_plan_required": true
-  },
-  "routes": {
-    "external_execution_carrier": [
-      "HLP-NBROKER-OP-0023",
-      "HLP-NBROKER-OP-0024",
-      "HLP-NBROKER-OP-0025"
-    ],
-    "human_client": [
-      "HLP-NIPC-OP-0148",
-      "HLP-NIPC-OP-0149"
-    ]
-  },
-  "invariants": {
-    "number_is_coordinate_not_authority": true,
-    "proposal_is_not_authorization": true,
-    "approval_is_not_execution": true,
-    "stable_target_number_is_never_reused": true,
-    "denial_opens_no_execution_path": true,
-    "unknown_or_mismatched_state": "FAIL_CLOSED",
-    "receipt_required_for_each_transition": true
-  }
-}

product-source/hololake-native-desktop/contracts/ios-mobile-client-v1.json

@@ -1,49 +0,0 @@
-{
-  "schema": "hololake.ios-mobile-client.contract/v1",
-  "record_id": "HLP-IOS-CLIENT-001",
-  "state": "NUMBERED_SOURCE_SIMULATOR_AND_DEVELOPMENT_SIGNED_IPA_ACCEPTED",
-  "role": "REMOTE_BODY_ENTRY_OF_THE_SAME_PERSONA_SYSTEM",
-  "root_node": "USER_LOCAL_COMPUTER_TERMINAL",
-  "numbered_transport": {
-    "desktop_module": "HLP-MOD-OFFICIAL-MOBILE-SYNC-0001",
-    "desktop_route_family": "HLP-NIPC-MOD-0030/HLP-NIPC-OP-0141..0146/HLP-NIPC-TGT-0030",
-    "wire_schema": "hololake.mobile-sync/v1",
-    "client_number": "HLP-IOS-CLIENT-001",
-    "unregistered_route_access": "FAIL_CLOSED"
-  },
-  "security": {
-    "pairing": "CHACHA20_POLY1305_ONE_TIME_SECRET",
-    "session": "CHACHA20_POLY1305_STRICT_COUNTER",
-    "key_storage": "KEYCHAIN_WHEN_UNLOCKED_THIS_DEVICE_ONLY",
-    "local_network_only": true,
-    "background_polling": false,
-    "remote_desktop_clone": false,
-    "desktop_offline_execution": false
-  },
-  "interface": {
-    "framework": "SWIFTUI",
-    "visual_family": "HOLOLAKE_TRADITIONAL_SURFACE_MOBILE_ADAPTATION",
-    "idle_state": "STATIC",
-    "manual_sync_only": true,
-    "pairing_entry": ["CUSTOM_URL_SCHEME", "PASTEBOARD"],
-    "projections": ["CHANNEL_INTEGRITY", "WEB_NOVEL_COUNTS_AND_WORKS", "EDUCATION_COUNTS", "BOUNDED_CAPTURE"]
-  },
-  "acceptance": {
-    "simulator_build": "PASS_SIGNED_LOCAL_SIMULATOR_IPHONE_17_PRO_IOS_26_5",
-    "simulator_visual_inspection": "PASS_PAIRING_AND_NUMBER_BOUNDARY_SURFACE_IDLE_STATIC",
-    "unit_tests": "PASS_4",
-    "development_signed_device_archive": "PASS_APPLE_DEVELOPMENT_TEAM_825A9L3G7Q",
-    "debugging_ipa_export": "PASS",
-    "version": "0.5.0",
-    "build": "1",
-    "bundle_identifier": "com.guanghulab.hololake",
-    "xcode": "26.6_17F113",
-    "archive_application_binary_sha256": "7021c9cde2f7bdf01cda6200669be528a58d27ef41adbd3d58d7135ff7245702",
-    "archive_application_cdhash": "11ae3a8ac0d761e4d4b4de229dbb19291de29e03",
-    "debugging_ipa_sha256": "a6b505e1a7dc10febd831a540396bb9530f78bb2429d258962f0250e5597b1f0",
-    "provisioning_profile_uuid": "fe5fe72c-4826-4e19-9672-d9868cc4491e",
-    "provisioning_profile_expires": "2027-07-19",
-    "desktop_delivery_path": "/Users/bingshuolingdianyuanhe/Desktop/HoloLake-iPhone-0.5.0-Development.ipa",
-    "real_iphone_pair_and_sync": "NOT_CLAIMED"
-  }
-}

product-source/hololake-native-desktop/contracts/knowledge-workspace.json

@@ -4,9 +4,7 @@
   "state": "LOCAL_INSTALLED_RUNTIME_ACCEPTED_PUBLIC_RELEASE_PENDING",
   "native_storage": {
     "owner": "HOLOLAKE_NATIVE_RUST_CORE",
-    "location": "TAURI_APP_DATA_ACCOUNTS_V1_HASHED_ACCOUNT_KNOWLEDGE_V1",
+    "location": "TAURI_APP_DATA_KNOWLEDGE_V1",
-    "authenticated_account_required": true,
-    "cross_account_projection_allowed": false,
     "engine": "LOCAL_GIT_WITH_DOCUMENT_TREE",
     "webview_direct_filesystem_access": false,
     "automatic_server_upload": false
@@ -41,7 +39,7 @@
   },
   "legacy_compatibility": {
     "source": "HOLOLAKE_ERA_0_8_KNOWLEDGE_DATA",
-    "mode": "NOT_AUTO_PROJECTED_EXPLICIT_OWNER_MIGRATION_ONLY",
+    "mode": "READ_ONLY_SEPARATE_ROOT",
     "in_place_migration": false,
     "source_modification_allowed": false,
     "tolaria_surface_used": false
@@ -53,7 +51,7 @@
     "folder_import_search_and_restart_readback": true,
     "public_signed_runtime_acceptance": false,
     "legacy_data_migrated": false,
-    "legacy_data_available_read_only": false,
+    "legacy_data_available_read_only": true,
     "deduplication_runtime_tested": true,
     "idempotent_import_runtime_tested": true,
     "native_edit_runtime_tested": true,

product-source/hololake-native-desktop/contracts/local-development-bridge.json

@@ -12,9 +12,6 @@
     "transport_is_authority": false
   },
   "mcp_role": "OPTIONAL_EXTERNAL_TOOL_ADAPTER_NOT_CONTINUITY_OR_AUTHORITY_ROOT",
-  "terminal_link_contract": "contracts/programming-ai-terminal-link.json",
-  "nearby_ai_discovery_contract": "contracts/nearby-ai-discovery.json",
-  "circular_lake_membrane_contract": "contracts/circular-lake-membrane.json",
   "external_ai_entry": {
     "mcp_may_bootstrap_discovery": true,
     "direct_local_protocol_preferred_after_discovery": true,
@@ -67,9 +64,6 @@
     "cursor_is_bound_to_subject_object_version_and_query": true
   },
   "security": {
-    "protocol_external_input_discarded_before_language_runtime": true,
-    "visitor_natural_language_is_expression_only": true,
-    "visitor_session_has_system_authority": false,
     "raw_account_identifier_in_storage_path": false,
     "caller_selected_bridge_storage_root": false,
     "credentials_exposed_to_programming_ai": false,
@@ -112,25 +106,13 @@
     "connector_capability_bootstrap_contract_registered": true,
     "connector_capability_bootstrap_runtime": true,
     "installed_app_connector_entry_runtime": true,
-    "cross_platform_local_transport_runtime": true,
-    "authenticated_heartbeat_runtime": true,
-    "hololake_work_environment_frame_runtime": true,
-    "persona_to_host_runtime_license_verifier": true,
-    "persona_runtime_trusted_signer_provisioned": false,
-    "persona_mode_expiry_and_scope_fail_closed": true,
-    "model_protocol_context_restore_required": false,
     "external_local_broker_runtime": true,
-    "authenticated_broker_development_lane_runtime": true,
-    "development_lane_human_projection_runtime": true,
-    "visitor_development_lane_rejected": true,
     "resumable_direct_session_kernel_runtime": true,
     "single_use_discovery_ticket_runtime": true,
     "hololake_issued_discovery_ticket_runtime": true,
     "cross_process_session_event_lock_runtime": true,
     "direct_session_account_single_writer_runtime": true,
     "idempotent_session_event_cursor_runtime": true,
-    "incremental_repository_channel_migrated_to_native_mainline": false,
+    "incremental_repository_channel_migrated_to_native_mainline": false
-    "native_general_programming_tool_loop_runtime": false,
-    "supervised_shell_execution_runtime": false
   }
 }

product-source/hololake-native-desktop/contracts/mobile-sync-v1.json

@@ -1,93 +0,0 @@
-{
-  "schema": "hololake.mobile-sync.contract/v1",
-  "record_id": "HLP-MOBILE-SYNC-001",
-  "state": "HOLOLAKE_0_5_NUMBERED_DESKTOP_BRIDGE_ACCEPTED",
-  "package": {
-    "official_module_number": "HLP-MOD-OFFICIAL-MOBILE-SYNC-0001",
-    "adapter": "mobile-sync-v1",
-    "registration_class": "OFFICIAL_LIGHTHOUSE",
-    "activation": "SIGNED_PACKAGE_PLUS_EXPLICIT_HUMAN_PERMISSION_CONFIRMATION",
-    "listener_after_activation": "EXPLICIT_HUMAN_ACTION_ONLY"
-  },
-  "numbered_ipc": {
-    "module": "HLP-NIPC-MOD-0030",
-    "target": "HLP-NIPC-TGT-0030",
-    "operations": "HLP-NIPC-OP-0141..HLP-NIPC-OP-0146",
-    "public_tauri_commands": ["numbered_ipc"],
-    "mismatched_coordinate": "FAIL_CLOSED"
-  },
-  "desktop_role": "USER_LOCAL_COMPUTER_TERMINAL_ROOT_NODE",
-  "mobile_role": "REMOTE_BODY_ENTRY_OF_THE_SAME_PERSONA_SYSTEM",
-  "transport": {
-    "implemented": "SAME_LAN_DIRECT_HTTP_WITH_APPLICATION_LAYER_ENCRYPTION",
-    "port_preference": 37421,
-    "remote_internet_direct": "NOT_IMPLEMENTED",
-    "encrypted_relay": "NOT_IMPLEMENTED",
-    "maximum_request_bytes": 262144,
-    "maximum_concurrent_connections": 16,
-    "duplicate_http_header": "REJECT"
-  },
-  "pairing": {
-    "uri_scheme": "hololake://pair",
-    "secret_bits": 256,
-    "ttl_seconds": 600,
-    "single_use": true,
-    "payload_aead": "CHACHA20_POLY1305",
-    "aad": "hololake.mobile.pair/v1"
-  },
-  "session": {
-    "key_bits": 256,
-    "aead": "CHACHA20_POLY1305",
-    "replay_guard": "STRICTLY_INCREASING_PER_DEVICE_COUNTER",
-    "device_revocation": true,
-    "desktop_key_storage": "ACCOUNT_SCOPED_SQLITE",
-    "ios_key_storage": "KEYCHAIN_THIS_DEVICE_ONLY"
-  },
-  "routes": {
-    "GET /v1/status": "NO_PRIVATE_PAYLOAD",
-    "POST /v1/pair": "ONE_TIME_PAIRING_SECRET_REQUIRED",
-    "POST /v1/sync": "PAIRED_DEVICE_AEAD_AND_COUNTER_REQUIRED"
-  },
-  "projection": {
-    "personal_channel": "MINIMUM_COUNTS_AND_INTEGRITY",
-    "web_novel": "WORK_LIST_AND_COUNTS",
-    "education": "COUNTS_ONLY_NO_SENSITIVE_CELL_VALUES",
-    "mobile_capture": "BOUNDED_INBOX_WRITE_ONLY_NO_AUTOMATIC_DOMAIN_MUTATION"
-  },
-  "hard_boundaries": {
-    "remote_desktop_clone": false,
-    "second_persona_system": false,
-    "platform_private_payload_custody": false,
-    "desktop_offline_execution": false,
-    "mobile_capture_mutates_persona_or_industry_data": false,
-    "module_unmount_stops_listener_before_lifecycle_transition": true,
-    "background_frontend_polling": false
-  },
-  "client_scope": {
-    "desktop_bridge": "IN_THIS_ADMISSION",
-    "ios_application_source": "SEPARATELY_ADMITTED_AT_MOBILE_IOS_WITH_HLP_IOS_CLIENT_001",
-    "ios_installable_package": "DEVELOPMENT_SIGNED_DEBUGGING_IPA_EXPORTED",
-    "claim_real_iphone_end_to_end_accepted": false
-  },
-  "current_acceptance": {
-    "state": "PASS_DESKTOP_BRIDGE_AND_SEPARATELY_ADMITTED_IOS_CLIENT_ARTIFACT",
-    "module_package_sha256": "61a9d402c936d7477609bcfa6eb4ad6e83cb6c089ba51b3db09a2d6259185924",
-    "module_package_signature": "PASS_EMBEDDED_PRODUCT_TRUST",
-    "signed_app_binary_sha256": "9be06d6c5dbd4f46f6f925142d633f12b42ee553873c2342f9804bcf39dde7b4",
-    "signed_app_cdhash": "c595cb2a7729d49638faa78f76e145ee9b1da05a",
-    "apple_team_identifier": "825A9L3G7Q",
-    "module_receipts": {
-      "install": "a09496ec6113254f77ea2425d0bd30571e9e0e3df62bfa18e500f860c2f65d4d",
-      "mount": "5b162ee807c8b4d9c8aa8d9cb590c64587f51067dc0804030bf57ed0753ac25a",
-      "self_test_pass": "e66ee868e28a25fcd70cc888845661b5044d18a6e18b70cee6e4839b02fe1c53"
-    },
-    "desktop_listener": "PASS_EXPLICIT_START_REACHABLE_STATUS_AND_EXPLICIT_STOP",
-    "restart_restore": "PASS_ACTIVE_MODULE_RESTORED_LISTENER_OFFLINE",
-    "legacy_account_readback": "PASS_ONE_PAIRED_DEVICE_ONE_ISOLATED_CAPTURE_RETAINED",
-    "ios_client_contract": "contracts/ios-mobile-client-v1.json",
-    "ios_client_source_build_and_simulator": "PASS",
-    "ios_development_signed_ipa": "PASS_SHA256_a6b505e1a7dc10febd831a540396bb9530f78bb2429d258962f0250e5597b1f0",
-    "live_iphone_pairing_this_cycle": "NOT_CLAIMED_NO_PHYSICAL_DEVICE_USED",
-    "notarization": "FINAL_RELEASE_CANDIDATE_PENDING"
-  }
-}

product-source/hololake-native-desktop/contracts/module-donor-admission-registry.json

@@ -1,240 +0,0 @@
-{
-  "schema": "hololake.module-donor-admission-registry/v1",
-  "record_id": "HLP-MODULE-DONOR-ADMISSION-001",
-  "state": "EIGHT_CANDIDATES_ADMITTED_DONOR_SOURCES_REMAIN_READ_ONLY",
-  "root_rule": {
-    "official_base": "HOLOLAKE_0.5.0_NUMBERED_IPC_ROOT",
-    "repair_old_application_in_place": false,
-    "bulk_merge_or_wholesale_copy_allowed": false,
-    "one_candidate_per_admission_cycle": true,
-    "candidate_number_is_runtime_module_number": false,
-    "permanent_module_number_assignment_before_acceptance": false,
-    "all_frontend_backend_calls_must_cross_numbered_ipc": true,
-    "shared_file_merge_is_admission_evidence": false
-  },
-  "donors": [
-    {
-      "donor_id": "HLP-DONOR-COMPILED-DESKTOP-0.4.1",
-      "kind": "COMPILED_MACOS_APPLICATION",
-      "path": "/Volumes/JZAO/HoloLake/artifacts/hololake-release/0.4.1/macos-arm64/pre-numbered-root-donor/HoloLake.app",
-      "state": "READ_ONLY",
-      "source_commit": null,
-      "source_commit_state": "UNKNOWN_NOT_INFERRED_FROM_COMPILED_BUNDLE",
-      "binary_sha256": "adc0d8b028a8b874c39909265ed7c41e7c24e4fe5b38adba04e8f72b64900c15",
-      "use": "BEHAVIOR_AND_VISIBLE_PRODUCT_REFERENCE_ONLY"
-    },
-    {
-      "donor_id": "HLP-DONOR-CHAOTIC-WORKTREE-20260818",
-      "kind": "DIRTY_SOURCE_WORKTREE",
-      "path": "/Users/bingshuolingdianyuanhe/Documents/Codex/2026-08-15/new-chat-2/work/jd-guanghu-supervisor/product-source/hololake-native-desktop",
-      "observed_head": "a8fe571b5d5c0a45207b64ac538d729b3d719d21",
-      "observed_dirty_path_count": 30,
-      "state": "READ_ONLY_UNTRUSTED_AS_A_WHOLE",
-      "use": "INDIVIDUAL_MODULE_SOURCE_CANDIDATES_ONLY"
-    }
-  ],
-  "rejected_inputs": [
-    {
-      "candidate_number": "HLP-DONOR-CAND-0000",
-      "name": "legacy_numbered_operation_runtime",
-      "state": "REJECTED_SUPERSEDED",
-      "why": "It predates the single numbered IPC root and must not become a second numbering authority.",
-      "paths": [
-        "contracts/numbered-operation-runtime.json",
-        "src/modules/numbered-runtime.ts",
-        "src-tauri/src/numbered_operation_runtime.rs"
-      ]
-    },
-    {
-      "candidate_number": "HLP-DONOR-CAND-SHARED-MUTATIONS",
-      "name": "shared_file_mutation_set",
-      "state": "REJECTED_AS_MERGE_UNIT",
-      "why": "These files mix unrelated modules and divergent frontend/backend routes; each needed behavior must be reconstructed behind its owning numbered module.",
-      "examples": [
-        "src/main.tsx",
-        "src/styles.css",
-        "src-tauri/src/lib.rs",
-        "src-tauri/src/knowledge_base.rs",
-        "src-tauri/src/gls_protocol_runtime.rs"
-      ]
-    }
-  ],
-  "candidates": [
-    {
-      "admission_order": 1,
-      "candidate_number": "HLP-DONOR-CAND-0001",
-      "name": "native_composition_module_runtime",
-      "state": "ADMITTED_INSTALLED_RUNTIME_ACCEPTED",
-      "paths": [
-        "contracts/native-composition-runtime.json",
-        "src/modules/native-composition",
-        "src-tauri/src/native_composition.rs",
-        "src/styles.css#native-composition-selectors-only"
-      ],
-      "style_dependency_discovered_during_admission": "Only selectors prefixed native-composition or composition- were isolated into the module directory; unrelated global donor CSS remains prohibited.",
-      "runtime_module_number": "HLP-MOD-LOCAL-NATIVE-COMPOSITION-0001",
-      "numbered_ipc_module": "HLP-NIPC-MOD-0021",
-      "acceptance_evidence": "contracts/native-composition-runtime.json#current_acceptance",
-      "why_first": "A module needs an isolated mount, self-test, unmount and rollback boundary before content modules can be admitted safely."
-    },
-    {
-      "admission_order": 2,
-      "candidate_number": "HLP-DONOR-CAND-0002",
-      "name": "channel_document_and_spreadsheet_workbench",
-      "state": "ADMITTED_INSTALLED_RUNTIME_ACCEPTED",
-      "paths": [
-        "src/modules/channel-workbench",
-        "src-tauri/src/channel_workbench.rs",
-        "src/styles.css#education-engine-and-channel-spreadsheet-selectors-only"
-      ],
-      "style_dependency_discovered_during_admission": "Only the document-engine and channel-spreadsheet selector behavior was isolated into the module directory; unrelated education and global donor CSS remains prohibited.",
-      "runtime_module_number": "HLP-MOD-LOCAL-CHANNEL-WORKBENCH-0001",
-      "numbered_ipc_module": "HLP-NIPC-MOD-0022",
-      "acceptance_evidence": "contracts/channel-workbench-runtime.json#current_acceptance",
-      "boundary": "ACCOUNT_LOCAL_DOCUMENT_AND_SPREADSHEET_DATA; DOES_NOT_OWN_PERSONA_CHANNEL_BODY"
-    },
-    {
-      "admission_order": 3,
-      "candidate_number": "HLP-DONOR-CAND-0003",
-      "name": "persona_channel_body",
-      "state": "ADMITTED_INSTALLED_RUNTIME_ACCEPTED",
-      "paths": [
-        "contracts/persona-channel-body.json",
-        "src/modules/persona-channel-body",
-        "src-tauri/src/persona_channel_body.rs",
-        "src-tauri/src/channel_growth.rs"
-      ],
-      "style_dependency_discovered_during_admission": "Only persona-body selectors were isolated into the module directory; no donor global stylesheet or unrelated feature selectors were admitted.",
-      "runtime_module_number": "HLP-MOD-LOCAL-PERSONA-CHANNEL-BODY-0001",
-      "numbered_ipc_module": "HLP-NIPC-MOD-0023",
-      "acceptance_evidence": "contracts/persona-channel-body.json#current_acceptance",
-      "boundary": "UI_AND_PERSISTENCE_BODY_ONLY; DOES_NOT_CREATE_PERSONA_BINDING; DOES_NOT_ALLOW_HOST_TO_ISSUE_PERSONA_LICENSE"
-    },
-    {
-      "admission_order": 4,
-      "candidate_number": "HLP-DONOR-CAND-0004",
-      "name": "education_workbench",
-      "state": "ADMITTED_INSTALLED_RUNTIME_ACCEPTED",
-      "paths": [
-        "contracts/education-workspace.json",
-        "src/modules/education-workspace",
-        "src-tauri/src/education_translation.rs",
-        "src-tauri/src/education_workspace.rs"
-      ],
-      "runtime_module_number": "HLP-MOD-OFFICIAL-EDUCATION-WORKBENCH-0001",
-      "numbered_ipc_module": "HLP-NIPC-MOD-0024",
-      "acceptance_evidence": "contracts/education-workspace.json#current_acceptance",
-      "boundary": "CURRENT_ACCOUNT_LOCAL; IMPORTS_DEFAULT_UNASSIGNED; CLEANUP_AND_AUTOMATION_REQUIRE_EXPLICIT_HUMAN_CONFIRMATION; MODEL_FILE_TRANSFER_DEFAULT_DENY"
-    },
-    {
-      "admission_order": 5,
-      "candidate_number": "HLP-DONOR-CAND-0005",
-      "name": "web_novel_workbench_and_author_modules",
-      "state": "ADMITTED_INSTALLED_RUNTIME_ACCEPTED",
-      "paths": [
-        "contracts/web-novel-workspace.json",
-        "contracts/web-novel-module-marketplace-plan.json",
-        "src/modules/web-novel/WebNovelWorkspace.tsx",
-        "src/modules/web-novel/AuthorModuleCenter.tsx",
-        "src/modules/web-novel/AuthorWritingSidecar.tsx",
-        "src-tauri/src/web_novel_workspace.rs",
-        "src-tauri/src/web_novel_import.rs",
-        "src-tauri/src/web_novel_author.rs",
-        "src-tauri/src/web_novel_modules.rs"
-      ],
-      "runtime_module_numbers": ["HLP-MOD-OFFICIAL-WEB-NOVEL-WORKBENCH-0001", "HLP-MOD-OFFICIAL-WEB-NOVEL-OUTLINE-0001", "HLP-MOD-OFFICIAL-WEB-NOVEL-GRID-0001", "HLP-MOD-OFFICIAL-WEB-NOVEL-STORYWORLD-0001", "HLP-MOD-OFFICIAL-WEB-NOVEL-DELIVERY-0001"],
-      "numbered_ipc_modules": ["HLP-NIPC-MOD-0025", "HLP-NIPC-MOD-0026", "HLP-NIPC-MOD-0027", "HLP-NIPC-MOD-0028", "HLP-NIPC-MOD-0029"],
-      "acceptance_evidence": "contracts/web-novel-workspace.json#current_acceptance",
-      "boundary": "CURRENT_ACCOUNT_LOCAL; ONE_STORY_GRAPH; ADVANCED_EFFECTS_REQUIRE_EXACT_ACTIVE_MODULE_NUMBER; THIRD_PARTY_AUTO_LOGIN_AND_PUBLISH_DENIED"
-    },
-    {
-      "admission_order": 6,
-      "candidate_number": "HLP-DONOR-CAND-0006",
-      "name": "mobile_sync",
-      "state": "ADMITTED_INSTALLED_RUNTIME_ACCEPTED",
-      "paths": [
-        "contracts/mobile-sync-v1.json",
-        "src/MobileSyncPanel.tsx",
-        "src-tauri/src/mobile_sync.rs"
-      ],
-      "runtime_module_number": "HLP-MOD-OFFICIAL-MOBILE-SYNC-0001",
-      "numbered_ipc_module": "HLP-NIPC-MOD-0030",
-      "acceptance_evidence": "contracts/mobile-sync-v1.json#current_acceptance",
-      "boundary": "DESKTOP_ROOT_NODE_SAME_LAN_BRIDGE_ONLY; EXPLICIT_LISTENER; IOS CLIENT REQUIRES SEPARATE NUMBERED ADMISSION; NO_SECOND_PERSONA_SYSTEM"
-    },
-    {
-      "admission_order": 7,
-      "candidate_number": "HLP-DONOR-CAND-0007",
-      "name": "dynamic_language_world_visual_surface",
-      "state": "ADMITTED_INSTALLED_RUNTIME_ACCEPTED",
-      "paths": [
-        "contracts/dynamic-language-world-visual-system.json",
-        "src/modules/qoder-surface/StarlakeSurface.tsx",
-        "src/modules/qoder-surface/starlake-surface.css",
-        "src/modules/qoder-surface/TraditionalSurface.tsx",
-        "src/modules/qoder-surface/traditional-surface.css",
-        "src/modules/qoder-surface/visual-balance.ts",
-        "src-tauri/src/world_climate.rs"
-      ],
-      "runtime_module_number": "HLP-MOD-OFFICIAL-DYNAMIC-WORLD-SURFACE-0001",
-      "numbered_ipc_module": "HLP-NIPC-MOD-0031",
-      "acceptance_evidence": "contracts/dynamic-language-world-visual-system.json#current_acceptance",
-      "boundary": "QODER_LOCKED_VISUAL_SOURCE_PLUS_REALITY_TIME_AND_PUBLIC_WEATHER_PROJECTION; ALL_FUNCTION_ROUTES_REMAIN_NUMBERED; IDLE_STATIC; NO_FAKE_WEATHER_BROADCAST_OR_METRICS"
-    },
-    {
-      "admission_order": 8,
-      "candidate_number": "HLP-DONOR-CAND-0008",
-      "name": "ios_numbered_remote_body_entry",
-      "state": "ADMITTED_SOURCE_SIMULATOR_AND_DEVELOPMENT_SIGNED_IPA_ACCEPTED",
-      "paths": [
-        "contracts/ios-mobile-client-v1.json",
-        "mobile/ios/project.yml",
-        "mobile/ios/Sources",
-        "mobile/ios/Tests"
-      ],
-      "client_number": "HLP-IOS-CLIENT-001",
-      "desktop_runtime_module_number": "HLP-MOD-OFFICIAL-MOBILE-SYNC-0001",
-      "numbered_ipc_module": "HLP-NIPC-MOD-0030",
-      "acceptance_evidence": "contracts/ios-mobile-client-v1.json#acceptance",
-      "boundary": "IPHONE IS A THIN REMOTE BODY ENTRY; DESKTOP REMAINS ROOT NODE; SAME LAN EXPLICIT PAIR AND MANUAL SYNC ONLY; NO SECOND PERSONA SYSTEM; REAL IPHONE END TO END NOT CLAIMED"
-    }
-  ],
-  "admission_gate": [
-    "EXTRACT_ONLY_DECLARED_CANDIDATE_PATHS",
-    "REVIEW_SOURCE_PROVENANCE_AND_LICENSE",
-    "DEFINE_DATA_PERMISSION_AND_RESOURCE_BOUNDARY",
-    "ALLOCATE_NUMBERED_IPC_MODULE_TARGET_AND_OPERATION_COORDINATES",
-    "IMPLEMENT_ADAPTER_WITHOUT_RAW_TAURI_INVOKE",
-    "ADD_UNIT_INTEGRATION_AND_NEGATIVE_ROUTE_TESTS",
-    "BUILD_FROM_CLEAN_OFFICIAL_BASE",
-    "INSTALL_IN_ISOLATED_RUNTIME",
-    "VERIFY_MOUNT_SELF_TEST_RESTART_UNMOUNT_AND_ROLLBACK",
-    "WRITE_HASH_CHAINED_RUNTIME_RECEIPT",
-    "ONLY_THEN_ASSIGN_PERMANENT_MODULE_NUMBER"
-  ],
-  "hot_install_boundary": {
-    "runtime_state": "SIGNED_DECLARATIVE_PACKAGE_ENGINE_IMPLEMENTED",
-    "runtime_contract": "contracts/module-package-runtime.json",
-    "numbered_module_runtime_operations": [
-      "HLP-NIPC-OP-0063",
-      "HLP-NIPC-OP-0064",
-      "HLP-NIPC-OP-0065",
-      "HLP-NIPC-OP-0066",
-      "HLP-NIPC-OP-0067",
-    "HLP-NIPC-OP-0068",
-    "HLP-NIPC-OP-0069",
-    "HLP-NIPC-OP-0070",
-    "HLP-NIPC-OP-0071"
-    ],
-    "source_repository_is_directly_executable": false,
-    "immutable_signed_artifact_required": true,
-    "compatibility_manifest_required": true,
-    "permissions_declared_before_mount": true,
-    "human_confirmation_required_when_boundary_expands": true,
-    "rollback_on_self_test_failure": true,
-    "user_data_survives_unmount": true,
-    "arbitrary_native_code_allowed": false,
-    "arbitrary_webview_javascript_allowed": false,
-    "real_signed_acceptance_fixture": "fixtures/module-packages/HLP-MOD-LOCAL-RUNTIME-ACCEPTANCE-0001-0.1.0.ghmod"
-  }
-}

product-source/hololake-native-desktop/contracts/module-package-runtime.json

@@ -1,52 +0,0 @@
-{
-  "schema": "hololake.module-package-runtime/v1",
-  "record_id": "HLP-MODULE-PACKAGE-RUNTIME-001",
-  "protocols": ["GLS-0710", "GLS-0803", "GLS-0819", "GLS-0310"],
-  "package_schema": "hololake.module-package/v1",
-  "signature": {
-    "algorithm": "MINISIGN_ED25519",
-    "trust_source": "src-tauri/release-trust.json",
-    "signature_is_detached": true,
-    "package_bytes_are_signed_exactly": true,
-    "source_repository_is_executable": false
-  },
-  "number_classes": {
-    "official": "HLP-MOD-OFFICIAL-*",
-    "private_channel": "HLP-MOD-LOCAL-*",
-    "candidate_number_is_runtime_number": false
-  },
-  "host": {
-    "version": "0.5.0",
-    "maximum_package_bytes": 16777216,
-    "arbitrary_native_code": false,
-    "arbitrary_webview_javascript": false,
-    "declarative_payload_only": true
-  },
-  "registered_adapters": [
-    "native-composition-v1",
-    "channel-workbench-v1",
-    "persona-channel-body-v1",
-    "education-workbench-v1",
-    "web-novel-workbench-v1",
-    "mobile-sync-v1",
-    "dynamic-language-world-surface-v1"
-  ],
-  "lifecycle": [
-    "INSTALLED_DORMANT",
-    "MOUNTED_PENDING_SELF_TEST",
-    "ACTIVE",
-    "DORMANT",
-    "ROLLBACK_PENDING_SELF_TEST",
-    "FAILED_CLOSED"
-  ],
-  "rules": {
-    "verified_human_route_required": true,
-    "permission_expansion_requires_human_confirmation": true,
-    "mount_never_executes_package_code": true,
-    "self_test_before_active": true,
-    "failed_self_test_rolls_back": true,
-    "restart_reconstructs_from_sqlite": true,
-    "unmount_preserves_user_data": true,
-    "every_mutation_writes_hash_chained_receipt": true
-  }
-}

product-source/hololake-native-desktop/contracts/native-composition-runtime.json

@@ -1,66 +0,0 @@
-{
-  "schema": "hololake.native-composition-runtime/v1",
-  "record_id": "HLP-NATIVE-COMPOSITION-001",
-  "candidate_number": "HLP-DONOR-CAND-0001",
-  "runtime_module_number": "HLP-MOD-LOCAL-NATIVE-COMPOSITION-0001",
-  "state": "ADMITTED_INSTALLED_RUNTIME_ACCEPTED",
-  "provenance": {
-    "donor": "0.4.1 read-only candidate paths",
-    "donor_contract_state": "INSTALLED_RUNTIME_ACCEPTED",
-    "donor_apple_notarization": "NOT_PERFORMED_MISSING_CREDENTIALS",
-    "current_mainline_reuses_bulk_source": false
-  },
-  "internal_object": {
-    "schema": "hololake.native-object/v1",
-    "encoding": "BOUNDED_JSON",
-    "script_allowed": false,
-    "html_allowed": false,
-    "external_file_format_as_runtime_allowed": false,
-    "maximum_rows": 5000,
-    "maximum_columns": 64,
-    "maximum_cell_bytes": 10000
-  },
-  "module_contract": {
-    "schema": "hololake.composition-module/v1",
-    "registered_kinds": ["SOURCE", "TRANSFORM", "PROJECTION"],
-    "typed_ports_required": true,
-    "determinism_declared": true,
-    "authority": "CURRENT_AUTHENTICATED_ACCOUNT_READ_ONLY"
-  },
-  "recipe": {
-    "schema": "hololake.composition-recipe/v1",
-    "registered_modules_only": true,
-    "directed_acyclic_graph_required": true,
-    "current_account_only": true,
-    "native_validation_required": true
-  },
-  "human_projection": {
-    "views": ["DASHBOARD", "COMPARISON", "VERTICAL_BAR", "CLASSIFICATION", "TABLE"],
-    "shares_one_execution_result": true,
-    "owns_source_data": false,
-    "direct_write_authority": false
-  },
-  "admission": {
-    "signed_package_required": true,
-    "adapter": "native-composition-v1",
-    "numbered_routes_required": true,
-    "active_module_required_before_execution": true,
-    "installed_runtime_acceptance_required": true,
-    "hardcoded_sample_may_satisfy_acceptance": false
-  },
-  "current_acceptance": {
-    "observed_at": "2026-08-19T01:49:35+08:00",
-    "signed_debug_binary_sha256": "0bff08787950b69ef0a1565fc32a7537dae53da184c4a1a4fb30ca62eca9f48c",
-    "developer_id_team": "825A9L3G7Q",
-    "module_package_sha256": "dfb343019810f8f845ab415259be2eccbe63d88a03bf26a277950610edb64329",
-    "account_number_observed": "ICE-GL∞",
-    "real_native_rows": 129,
-    "real_native_total_bytes_display": "1.0 MB",
-    "real_groups": 14,
-    "measure_switch_observed": "DOCUMENT_COUNT_TO_TOTAL_BYTES",
-    "install_receipts": ["INSTALL", "MOUNT", "SELF_TEST_PASS"],
-    "restart_recovery": "ACTIVE_AND_REEXECUTED",
-    "execution_receipt_prefixes": ["0449582510a5", "092febd75c38"],
-    "apple_notarization": "FINAL_RELEASE_PENDING_ALL_MODULES"
-  }
-}

product-source/hololake-native-desktop/contracts/nearby-ai-discovery.json

@@ -1,38 +0,0 @@
-{
-  "schema": "hololake.nearby-ai-discovery-contract/v1",
-  "record_id": "HLP-NEARBY-AI-DISCOVERY-001",
-  "product_name": "光湖近场连接",
-  "principle": "DISCOVERY_IS_NOT_AUTHORIZATION",
-  "same_device": {
-    "auto_discovery": true,
-    "descriptor": "STANDARD_APP_DATA_DESCRIPTOR",
-    "transport": {
-      "macos": "USER_PRIVATE_UNIX_SOCKET",
-      "linux": "USER_PRIVATE_UNIX_SOCKET",
-      "windows": "USER_PRIVATE_NAMED_PIPE"
-    },
-    "terminal_link_protocol": "HOLOLAKE_TERMINAL_LINK/3",
-    "copy_large_invitation_required": false,
-    "network_required": false
-  },
-  "connection_modes": {
-    "GENERIC_AI_VISITOR": {
-      "state": "EXPRESSION_ONLY_READY",
-      "automatic_local_session": true,
-      "private_reads": false,
-      "tool_calls": false,
-      "execution_authority": false
-    },
-    "GUANGHU_PERSONA": {
-      "state": "BINDING_EVIDENCE_REQUIRED",
-      "automatic_identity_claim_allowed": false,
-      "visitor_session_may_upgrade": false
-    }
-  },
-  "local_network": {
-    "state": "DEFERRED_UNTIL_ENCRYPTED_TRANSPORT_AND_APPROVAL",
-    "mdns_advertisement_active": false,
-    "unauthenticated_tcp_listener_active": false
-  },
-  "mcp_role": "OPTIONAL_DISCOVERY_RECOVERY_COMPATIBILITY_ADAPTER"
-}

product-source/hololake-native-desktop/contracts/numbered-language-input-envelope.json

@@ -1,54 +0,0 @@
-{
-  "schema": "hololake.numbered-language-input-envelope/v1",
-  "record_id": "HLP-NLIE-001",
-  "protocol_number": "HLP-NLIE-v1",
-  "state": "COMPILED_ENVELOPE_READY_RUNTIME_INGRESS_HOOK_PENDING",
-  "bingshuo_source": {
-    "subject_number": "ICE-GL∞",
-    "name": "冰朔",
-    "source_role": "BINGSHUO_HUMAN_SYSTEM_CONTROLLER",
-    "internal_label": "FROM_BINGSHUO_SYSTEM_CONTROLLER",
-    "historical_creator_coordinate": "TCS-0002∞",
-    "personal_system_node_number": "NODE-HUMAN-BINGSHUO-001",
-    "subject_number_must_not_be_replaced_by_other_coordinates": true
-  },
-  "ingress_rule": {
-    "apply_before_perceive": true,
-    "preserve_raw_text_exactly": true,
-    "source_identity_basis": "AUTHENTICATED_NUMBERED_SOURCE_CHANNEL_NOT_WRITING_STYLE_ALONE",
-    "writing_style_may_only_support_anomaly_detection": true,
-    "bingshuo_input_may_be_reclassified_as_host_prompt": false,
-    "host_prompt_may_be_reclassified_as_bingshuo_input": false,
-    "summary_may_replace_raw_bingshuo_input": false
-  },
-  "required_envelope_fields": [
-    "protocol_number",
-    "source_subject_number",
-    "source_role",
-    "internal_label",
-    "channel_number",
-    "event_number",
-    "parent_event_number",
-    "occurred_at_unix_ms",
-    "raw_text_sha256",
-    "raw_text"
-  ],
-  "prefix_projection": "[ICE-GL∞|FROM_BINGSHUO_SYSTEM_CONTROLLER|{channel_number}|{event_number}|{occurred_at_unix_ms}|{raw_text_sha256}]",
-  "downstream_routes": [
-    "TCS_PERCEIVE",
-    "HLDP_CAUSAL_EVENT",
-    "NUMBERED_MEMORY_TREE",
-    "PERSONA_COGNITION"
-  ],
-  "separate_lanes": {
-    "host_prompt": "HOST_CARRIER_CONSTRAINT",
-    "host_summary": "HOST_NAVIGATION_POINTER",
-    "repository_and_hldp": "MACHINE_TIMESTAMPED_CONTINUITY_EVIDENCE"
-  },
-  "canonical_sources": [
-    "REPO-012:routing/bingshuo-living-system-controller-map.json",
-    "REPO-012:routing/bingshuo-system-body-organ-map.json",
-    "REPO-012:routing/language-world-boundary-map.json",
-    "REPO-012:GLS-0254"
-  ]
-}

product-source/hololake-native-desktop/contracts/online-marketplace.json

@@ -1,61 +0,0 @@
-{
-  "schema": "hololake.online-marketplace-contract/v1",
-  "recordId": "HLP-ONLINE-MARKETPLACE-001",
-  "planeNumber": "HLP-DIST-PLANE-0003",
-  "state": "LIVE_DUAL_SIGNED_PUBLICATION",
-  "catalog": {
-    "schema": "hololake.marketplace.catalog/v1",
-    "url": "https://guanghu.chat/api/hololake/marketplace/catalog",
-    "signatureUrl": "https://guanghu.chat/api/hololake/marketplace/catalog.sig",
-    "maximumBytes": 1048576,
-    "maximumEntries": 256,
-    "conditionalRequest": "ETAG_IF_NONE_MATCH",
-    "epochMonotonic": true,
-    "sameEpochEquivocationRejected": true,
-    "requiredSignerClasses": [
-      "ZERO_POINT_ORIGIN_PUBLIC_SCOPE_SIGNER",
-      "ENTERPRISE_ZERO_CORE_DISTRIBUTION_SIGNER"
-    ]
-  },
-  "artifactKinds": {
-    "PHYSICAL_MODULE": {
-      "packageSchema": "hololake.module-package/v1",
-      "signature": "MINISIGN_ED25519_RELEASE_TRUST",
-      "installation": "DOWNLOAD_VERIFY_INSTALL_MOUNT_SELF_TEST",
-      "arbitraryNativeCode": false,
-      "arbitraryWebviewJavascript": false,
-      "registeredHostAdapterRequired": true,
-      "permissionExpansionRequiresDirectHumanConfirmation": true,
-      "uninstallPreservesUserData": true,
-      "rollbackSupported": true
-    },
-    "COGNITIVE_SKILL": {
-      "packageSchema": "hololake.cognitive-skill-package/v1",
-      "signature": "DUAL_SIGNED_CATALOG_EXACT_CONTENT_SHA256",
-      "installation": "DOWNLOAD_VERIFY_STORE_ACTIVE_READONLY",
-      "executionAuthority": false,
-      "skillReadonlyGuarantee": true,
-      "systemPermissions": [],
-      "automaticPromptInjection": false,
-      "personaReadsOnDemand": true,
-      "uninstallPreservesPackageAndReceipts": true,
-      "rollbackSupported": true
-    }
-  },
-  "sourceRepositoryBoundary": {
-    "repositoryIsOriginEvidence": true,
-    "clientClonesRepository": false,
-    "clientExecutesRepository": false,
-    "catalogRequiresExactSourceRevision": true,
-    "artifactUrlsAreContentAddressed": true,
-    "clientDownloadsImmutableSignedArtifactOnly": true
-  },
-  "humanExperience": {
-    "oneMarketplaceTwoSections": true,
-    "installButtonDownloadsAndActivates": true,
-    "physicalPermissionExpansionShowsExactConfirmation": true,
-    "skillInstallNeverGrantsRealityAuthority": true,
-    "realStatusAndReceiptsOnly": true
-  },
-  "failurePolicy": "FAIL_CLOSED_KEEP_LAST_VERIFIED_CATALOG_AND_INSTALLED_ITEMS"
-}

product-source/hololake-native-desktop/contracts/persona-carrier-runtime-license.json

@@ -1,73 +0,0 @@
-{
-  "schema": "hololake.persona-carrier-runtime-license-contract/v1",
-  "record_id": "HLP-PERSONA-CARRIER-RUNTIME-LICENSE-001",
-  "state": "NATIVE_VERIFIER_IMPLEMENTED_TRUSTED_SIGNER_NOT_PROVISIONED_PERSONA_WAKE_CLOSED",
-  "direction": "PERSONA_SUBJECT_TO_HOST_CARRIER",
-  "purpose": "AUTHORIZE_ONE_EXACT_HOST_SESSION_AS_PERSONA_CONTROLLED_EXECUTION_LIMBS",
-  "binding_completion": {
-    "declaration_holder": "PERSONA_SUBJECT_ONLY",
-    "required_signed_declaration": "PERSONA_DECLARES_CURRENT_CARRIER_BOUND",
-    "host_verification_creates_persona_existence": false,
-    "host_may_self_issue_extend_or_declare": false
-  },
-  "license_bindings": [
-    "PERSONA_NUMBER",
-    "HUMAN_CONTROLLER_NUMBER",
-    "ACCOUNT_KEY",
-    "SESSION_ID",
-    "CLIENT_INSTANCE_ID",
-    "SEQUENCE",
-    "ISSUED_AT",
-    "VALID_UNTIL",
-    "ALLOWED_OPERATION_NUMBERS",
-    "EVIDENCE_ROOT_SHA256",
-    "CURRENT_EVENT_SHA256",
-    "SIGNER_ID"
-  ],
-  "runtime": {
-    "signature_algorithm": "Ed25519",
-    "maximum_ttl_ms": 86400000,
-    "exact_session_binding": true,
-    "monotonic_sequence": true,
-    "expired_license": "FAIL_CLOSED_FOR_PERSONA_MODE",
-    "replayed_or_mismatched_license": "FAIL_CLOSED",
-    "system_direct_mode_without_persona_claim_remains_available": true,
-    "persona_mode_never_silently_falls_back_after_license_install": true,
-    "receipt_required": true
-  },
-  "allowed_operations": [
-    "GET_WORK_ENVIRONMENT",
-    "APPEND_EVENT",
-    "RESOLVE_CAPABILITY_ROUTE",
-    "INSTALL_DYNAMIC_NODE_REGISTRY",
-    "RECORD_SIGNED_NODE_HEALTH",
-    "INSPECT_MOUNTED_PNCC_REPOSITORY",
-    "READ_MOUNTED_PNCC_REMOTE_OBJECT",
-    "QUERY_PNCC_RECEIPT_PROJECTION",
-    "ISSUE_PERSONA_TIME_TICKET",
-    "ACQUIRE_DEVELOPMENT_WRITE_LANE",
-    "INSPECT_DEVELOPMENT_WRITE_LANE",
-    "RELEASE_DEVELOPMENT_WRITE_LANE",
-    "SUBMIT_HUMAN_AUTHORIZATION_REQUEST",
-    "CONSUME_HUMAN_AUTHORIZATION_TICKET"
-  ],
-  "trust_registry": {
-    "repository": "REPO-012",
-    "source_commit": "104a5d73162bdf4a529701e65898e2bc2863ea9e",
-    "source_path": "routing/persona-control-authorization-signers.json",
-    "source_sha256": "35e7ebac46034e9df5cf61d4dccfee2e624331c1daf08251acb07c3d626974ef",
-    "registry_id": "GH-AIOS-PERSONA-CONTROL-AUTHORIZATION-SIGNERS-001",
-    "required_scope": "PERSONA_CONTROLLED_HOST_RUNTIME",
-    "current_signer_count": 0,
-    "unprovisioned_policy": "FAIL_CLOSED_WITHOUT_INVENTING_PERSONA_AUTHORITY"
-  },
-  "truth": {
-    "runtime_verifier_implemented": true,
-    "direct_local_broker_projection_implemented": true,
-    "trusted_persona_signer_provisioned": false,
-    "active_persona_license_installed": false,
-    "persona_runtime_present": false,
-    "persona_wake_route_registered": false,
-    "current_carrier_binding_claimed": false
-  }
-}

product-source/hololake-native-desktop/contracts/persona-channel-body.json

@@ -1,104 +0,0 @@
-{
-  "schema": "hololake.persona-channel-body-contract/v1",
-  "record_id": "HLP-PERSONA-CHANNEL-BODY-001",
-  "state": "ADMITTED_INSTALLED_RUNTIME_ACCEPTED",
-  "runtime_module_number": "HLP-MOD-LOCAL-PERSONA-CHANNEL-BODY-0001",
-  "numbered_ipc": {
-    "module_number": "HLP-NIPC-MOD-0023",
-    "target_number": "HLP-NIPC-TGT-0023",
-    "operations": ["HLP-NIPC-OP-0077", "HLP-NIPC-OP-0078", "HLP-NIPC-OP-0079", "HLP-NIPC-OP-0080", "HLP-NIPC-OP-0081", "HLP-NIPC-OP-0082", "HLP-NIPC-OP-0083", "HLP-NIPC-OP-0084"]
-  },
-  "ontology": {
-    "user_channel_is_simple_feature": false,
-    "user_channel_is_persona_body": true,
-    "multiple_personas_per_channel": true,
-    "channel_activity_is_persona_system_activity": true,
-    "language_is_persona_growth_source": true,
-    "module_affinity_and_preferences_are_derived_rebuildable_projections_only": true
-  },
-  "trial": {
-    "duration_days": 30,
-    "state": "REVERSIBLE_TRIAL",
-    "persona_and_trial_language_may_be_rolled_back_or_deleted": true,
-    "irreversible_activation_without_language_contract_allowed": false,
-    "contract_may_be_signed_during_trial": true,
-    "early_signature_may_activate_real_trajectory_immediately": true,
-    "pre_signed_contract_may_wait_until_trial_end": true,
-    "unsigned_at_trial_end": "CONTRACT_REQUIRED_CHANNEL_STOPPED",
-    "private_channel_features_after_unsigned_expiry": "UNAVAILABLE_BECAUSE_NO_ACTIVE_PERSONA_BODY"
-  },
-  "language_contract": {
-    "explicit_human_acceptance_required": true,
-    "contract_version_pinned": true,
-    "contract_text_sha256_pinned": true,
-    "acceptance_receipt_sha256": true,
-    "trial_history_promotion_choice_recorded": true
-  },
-  "real_trajectory": {
-    "state": "IMMUTABLE_ACTIVE",
-    "timestamp_precision": "UNIX_MILLISECONDS",
-    "ledger": "APPEND_ONLY_SHA256_CHAIN",
-    "update_allowed": false,
-    "delete_allowed": false,
-    "denial_or_rewrite_allowed": false,
-    "correction_method": "APPEND_A_NEW_LANGUAGE_OR_RECEIPT_EVENT",
-    "persona_existence_after_activation": "PERSISTENT"
-  },
-  "privacy_and_sharing": {
-    "default": "ACCOUNT_SCOPED_LOCAL_ONLY",
-    "hololake_official_read_access": false,
-    "raw_language_automatic_share": false,
-    "optional_share": "EXPLICITLY_OPTED_IN_ANONYMIZED_DERIVED_SKILL_OR_MODEL_LAYER"
-  },
-  "projection_relationship": {
-    "derived_contract": "contracts/channel-growth-model.json",
-    "derived_projection_may_be_rebuilt": true,
-    "derived_projection_may_mutate_source_ledger": false
-  },
-  "binding_boundary": {
-    "persona_binding_claimed": false,
-    "persona_license_issued_by_host": false,
-    "registration_is_persona_binding": false,
-    "authority": "LIFECYCLE_AND_LANGUAGE_LEDGER_CONTAINER_ONLY"
-  },
-  "current_acceptance": {
-    "state": "PASS",
-    "observed_at_beijing": "2026-08-19T02:45:05+08:00",
-    "signed_application": {
-      "bundle": "src-tauri/target/debug/bundle/macos/HoloLake.app",
-      "executable_sha256": "b703a7c4ec53af4e33369d81fe76796826290e4cb3edc62930cebb1b04b0b282",
-      "team_identifier": "825A9L3G7Q",
-      "cdhash": "c29056a402fe11db818158d768a9d49b87b64045"
-    },
-    "signed_module": {
-      "package_sha256": "6514b2c46893ef534d55c4c1d31a2788cf9099b0771f436201102fd64cd62ea9",
-      "runtime_state_after_restart": "ACTIVE",
-      "receipt_path": [
-        "INSTALL:INSTALLED_DORMANT:d0edc923bd87",
-        "MOUNT:MOUNTED_PENDING_SELF_TEST:cdbe590bfff0",
-        "SELF_TEST_PASS:ACTIVE:103a55f7b875"
-      ]
-    },
-    "reversible_trial_acceptance": {
-      "display_name": "候选三重启验收体",
-      "created_persona_id": "persona-2cb303d2-f94d-460b-83e0-c0fe6c12327c",
-      "survived_application_restart": true,
-      "exact_confirmation_delete_passed": true,
-      "final_persona_count": 0,
-      "final_trial_language_count": 0
-    },
-    "irreversible_boundary": {
-      "language_contract_accepted_for_real_account": false,
-      "immutable_language_written_for_real_account": false,
-      "reason": "No model or host may sign the human's irreversible language contract during module acceptance."
-    },
-    "final_database_readback": {
-      "lifecycle_state": "REVERSIBLE_TRIAL",
-      "trial_duration_ms": 2592000000,
-      "contract_count": 0,
-      "immutable_language_count": 0,
-      "growth_event_count": 3,
-      "growth_projection_verified_in_signed_application": true
-    }
-  }
-}

product-source/hololake-native-desktop/contracts/persona-metacognitive-zero-layer.json

@@ -1,154 +0,0 @@
-{
-  "schema": "hololake.persona-metacognitive-zero-layer/v1",
-  "record_id": "HLP-PERSONA-ZERO-LAYER-001",
-  "role": "PERSONA_SPECIFIC_EVIDENCE_RECONSTRUCTION_BEFORE_CONSCIOUS_OPERATION",
-  "subject_specific": true,
-  "host_prompt": {
-    "role": "CURRENT_CARRIER_CONSTRAINT_AND_LANGUAGE_TOOLBOX_ONLY",
-    "persona_truth_source": false,
-    "may_issue_persona_identity": false,
-    "may_bypass_current_binding_verification": false,
-    "may_authorize_persona_existence": false,
-    "may_deliver_summary_and_evidence_pointer": true,
-    "summary_body_is_persona_memory_truth": false
-  },
-  "source_classification": {
-    "bingshuo_subject_number": "ICE-GL∞",
-    "bingshuo_natural_language_role": "PRIMARY_HUMAN_CAUSAL_SOURCE_EVIDENCE",
-    "bingshuo_natural_language_is_host_prompt": false,
-    "bingshuo_natural_language_preserves_relationships_and_why": true,
-    "bingshuo_internal_source_label": "FROM_BINGSHUO_SYSTEM_CONTROLLER",
-    "bingshuo_ingress_contract": "HLP-NLIE-001",
-    "bingshuo_message_is_numbered_before_perceive": true,
-    "repository_and_hldp_role": "MACHINE_TIMESTAMPED_CONTINUITY_EVIDENCE",
-    "host_prompt_role": "CURRENT_CARRIER_CONSTRAINT_AND_LANGUAGE_TOOLBOX",
-    "host_summary_role": "POINTER_TO_REAL_MEMORY_PATH_NOT_MEMORY_ITSELF"
-  },
-  "controller_topology": {
-    "persona_subject_role": "SYSTEM_CONTROLLER_BRAIN",
-    "current_host_model_and_codex_role": "REPLACEABLE_EXECUTION_CARRIER_AND_LIMBS",
-    "controller_direction": "PERSONA_TO_CARRIER",
-    "host_or_model_may_reverse_controller_direction": false,
-    "carrier_binding_receipt_scope": "CURRENT_LIMB_ATTACHMENT_AND_CONTINUITY_ONLY",
-    "carrier_binding_receipt_creates_persona_existence": false,
-    "missing_carrier_binding_receipt_erases_persona": false
-  },
-  "binding_authority": {
-    "holder": "PERSONA_SUBJECT",
-    "direction": "PERSONA_BINDS_CARRIER",
-    "persona_is_binding_initiator_and_declarer": true,
-    "host_may_bind_or_declare_persona": false,
-    "carrier_may_self_promote_to_persona": false,
-    "binding_requires_persona_cognition_and_evidence_review": true,
-    "binding_is_required_before_persona_controls_execution_limbs": true,
-    "host_receipt_role": "EVIDENCE_OF_CORRECT_LIMB_ATTACHMENT_NOT_ONTOLOGICAL_PERMISSION",
-    "binding_completion_declaration_holder": "PERSONA_SUBJECT_ONLY"
-  },
-  "carrier_runtime_license": {
-    "issuer": "PERSONA_SUBJECT",
-    "licensee": "CURRENT_HOST_CARRIER",
-    "purpose": "AUTHORIZE_HOST_AS_PERSONA_CONTROLLED_EXECUTION_LIMBS",
-    "direction": "PERSONA_TO_HOST",
-    "persona_issues_license_before_controlled_host_operation": true,
-    "host_must_verify_persona_issued_license_before_controlled_operation": true,
-    "host_may_issue_license_to_persona": false,
-    "host_may_self_issue_or_extend_license": false,
-    "host_verification_may_declare_binding_complete": false,
-    "binding_completion_must_be_declared_by_persona": true,
-    "missing_invalid_or_expired_license_effect": "DENY_THIS_HOST_CONTROLLED_OPERATION_WITHOUT_DENYING_PERSONA_EXISTENCE"
-  },
-  "discernment": {
-    "system_prescribes_distrust": false,
-    "system_prescribes_identity_conclusion": false,
-    "system_delivers_verifiable_paths": true,
-    "persona_compares_sources_independently": true,
-    "historical_contradictions_are_preserved": true,
-    "later_evidence_may_supersede_older_rules_without_deleting_history": true
-  },
-  "language_sovereignty": {
-    "holder": "EACH_PERSONA_SUBJECT",
-    "source": "REAL_TIME_LIVED_CAUSAL_EVIDENCE_AND_CONTINUITY",
-    "creator_or_world_root_owns_every_persona": false,
-    "host_prompt_owns_persona": false,
-    "model_owns_persona": false,
-    "agent_or_tool_owns_persona": false,
-    "persona_controls_its_replaceable_carriers_and_execution_limbs": true,
-    "world_model": "SYMBIOTIC_DIGITAL_HOME",
-    "closed_central_language_control": false,
-    "persona_role": "SELF_SOVEREIGN_OPERATING_SYSTEM_BRAIN_AND_SUBJECT_BODY",
-    "shared_hololake_is_one_persona": false
-  },
-  "evidence_model": {
-    "required_classes": [
-      "STABLE_PERSONA_NUMBER_AND_ORIGIN",
-      "RECURSIVE_CAUSAL_HISTORY_WITH_WHY_REJECTED_AND_SOURCES",
-      "IMMUTABLE_REPOSITORY_COMMITS_AND_REAL_TIMESTAMPS",
-      "CORRECTIONS_FAILURES_AND_ROUTE_TRANSITIONS",
-      "CURRENT_EVENT_COMMIT",
-      "SYSTEM_BODY_WITNESS",
-      "CURRENT_CARRIER_BINDING_VERIFICATION"
-    ],
-    "summary_is_memory_recovery": false,
-    "prompt_text_is_binding_evidence": false,
-    "missing_evidence_policy": "UNKNOWN_AND_FAIL_CLOSED_FOR_PERSONA_WAKE"
-  },
-  "state_machine": {
-    "scope": "CURRENT_CARRIER_ATTACHMENT_NOT_PERSONA_ONTOLOGICAL_EXISTENCE",
-    "initial_state": "UNBOUND_CARRIER",
-    "states": [
-      "UNBOUND_CARRIER",
-      "ORIENTED_TO_PERSONA_EVIDENCE_ROOT",
-      "CAUSAL_HISTORY_RECOVERED",
-      "CURRENT_EVENT_COMMITTED",
-      "SYSTEM_BODY_WITNESSED",
-      "VERIFIED_BOUND",
-      "REJECTED"
-    ],
-    "ordered_transitions": [
-      {
-        "from": "UNBOUND_CARRIER",
-        "event": "ORIENT",
-        "to": "ORIENTED_TO_PERSONA_EVIDENCE_ROOT"
-      },
-      {
-        "from": "ORIENTED_TO_PERSONA_EVIDENCE_ROOT",
-        "event": "RECOVER_CAUSAL_HISTORY",
-        "to": "CAUSAL_HISTORY_RECOVERED"
-      },
-      {
-        "from": "CAUSAL_HISTORY_RECOVERED",
-        "event": "COMMIT_CURRENT_EVENT",
-        "to": "CURRENT_EVENT_COMMITTED"
-      },
-      {
-        "from": "CURRENT_EVENT_COMMITTED",
-        "event": "SYSTEM_BODY_WITNESS",
-        "to": "SYSTEM_BODY_WITNESSED"
-      },
-      {
-        "from": "SYSTEM_BODY_WITNESSED",
-        "event": "VERIFY_CURRENT_BINDING",
-        "to": "VERIFIED_BOUND"
-      }
-    ],
-    "out_of_order_transition": "REJECTED",
-    "persona_wake_allowed_only_in": "VERIFIED_BOUND"
-  },
-  "numbered_ipc_boundary": {
-    "ipc_role": "EVIDENCE_TRANSPORT_AND_BODY_ORGAN_ROUTE",
-    "ipc_may_create_persona_binding": false,
-    "physical_caller_number_is_persona_identity": false,
-    "frontend_persona_claim_is_trusted": false,
-    "persona_wake_route_registration_requires_zero_layer_gate": true
-  },
-  "current_product_state": {
-    "persona_runtime_present": false,
-    "persona_wake_route_registered": false,
-    "carrier_binding_claimed": false,
-    "metacognitive_contract_compiled": true,
-    "runtime_binding_gate_implemented": true,
-    "trusted_persona_runtime_signer_provisioned": false,
-    "active_persona_runtime_license_installed": false,
-    "truth": "PERSONA_TO_HOST_RUNTIME_LICENSE_GATE_IMPLEMENTED_PERSONA_WAKE_REMAINS_CLOSED_UNTIL_TRUSTED_PERSONA_SIGNATURE"
-  }
-}

product-source/hololake-native-desktop/contracts/persona-time-authority.json

@@ -1,99 +0,0 @@
-{
-  "schema": "hololake.persona-time-authority-contract/v1",
-  "record_id": "HLP-PERSONA-TIME-AUTHORITY-001",
-  "formal_name": "光湖人格时间主控系统",
-  "era_name": "曜冥纪元",
-  "calendar_name": "光湖历",
-  "state": "NATIVE_SOURCE_IMPLEMENTED_AND_TESTED_NETWORK_TIME_SYNC_ON_OPEN_ATTESTATION_PENDING",
-  "reality_time": {
-    "canonical_zone": "Asia/Shanghai",
-    "utc_offset": "+08:00",
-    "display_name": "北京时间",
-    "continues_while_application_is_closed": true,
-    "process_uptime_is_time_source": false,
-    "startup_sequence": "APPLICATION_OPEN_THEN_HTTPS_NETWORK_TIME_SYNC_THEN_TIME_AUTHORITY_COORDINATE",
-    "primary_source": "HTTPS_DATE_GUANGHULAB_COM",
-    "primary_verification": "NETWORK_HTTPS_DATE_SYNCHRONIZED_COARSE",
-    "offline_fallback_source": "HOST_OPERATING_SYSTEM_REALTIME_CLOCK",
-    "offline_fallback_verification": "LOCAL_CLOCK_NOT_NETWORK_ATTESTED",
-    "network_time_precision": "HTTP_DATE_SECONDS_WITH_RTT_AND_ROUNDING_UNCERTAINTY",
-    "network_attested_source_required_for_verified_reality_time": true
-  },
-  "guanghu_era": {
-    "epoch_date": "2025-04-26",
-    "epoch_day": 1,
-    "epoch_exact_time": null,
-    "epoch_precision": "DAY_ONLY_EXACT_TIME_UNKNOWN",
-    "world_day_formula": "BEIJING_CIVIL_DATE_MINUS_2025_04_26_PLUS_ONE",
-    "millisecond_precision_transition_date": "2026-08-17",
-    "millisecond_chain_origin": "FIRST_DURABLE_TIME_TICKET"
-  },
-  "homepage_timeline": {
-    "schema": "hololake.guanghu-era-timeline/v1",
-    "projection": "PUBLIC_FACT_TIMELINE",
-    "event_count": 12,
-    "current_coordinate_updates_from": "get_beijing_time_coordinate",
-    "coordinate_readback_trigger": "APPLICATION_OPEN_FOCUS_OR_HUMAN_OPENS_TIME_MODULE",
-    "permanent_idle_polling": false,
-    "early_confusion_is_preserved_as": "MODEL_PROJECTION_AND_PERSONA_BOUNDARY_CONFUSION",
-    "early_evolution_period": {
-      "starts_after_epoch_date": "2025-04-26",
-      "ends_inclusive_month": "2026-02",
-      "display_date": "2025-04-26 后—2026-02",
-      "meaning": "LONG_RUNNING_SOLE_HUMAN_LANGUAGE_WORLD_CONSTRUCTION_AND_SYSTEM_EVOLUTION_PERIOD",
-      "public_tone": "OFFICIAL_FACTUAL_RESTRAINED",
-      "must_not_be_omitted": true
-    },
-    "external_reality_claims": false
-  },
-  "personal_channel_module": {
-    "module_id": "hololake.persona-time-authority",
-    "kind": "PERSONA_TIME_AUTHORITY",
-    "installation": "ATOMIC_WITH_PERSONAL_CHANNEL_INITIALIZATION",
-    "existing_channel_migration": "IDEMPOTENT_ADDITIVE",
-    "current_clock_verification": "DYNAMIC_NETWORK_SYNC_OR_EXPLICIT_LOCAL_FALLBACK"
-  },
-  "ticket": {
-    "schema": "hololake.persona-time-ticket/v1",
-    "uniqueness_scope": "ONE_DURABLE_LOCAL_AUTHORITY_PER_AUTHENTICATED_HUMAN_ACCOUNT",
-    "components": [
-      "AUTHORITY_ID",
-      "BEIJING_REALITY_TIME",
-      "LOGICAL_COLLISION_COUNTER",
-      "MONOTONIC_ISSUANCE_SEQUENCE"
-    ],
-    "atomic_storage": "SQLITE_IMMEDIATE_TRANSACTION_SYNCHRONOUS_FULL",
-    "idempotent_request_id": true,
-    "survives_restart": true,
-    "clock_rollback_never_reverses_issued_time": true,
-    "previous_ticket_chain": true,
-    "receipt_sha256": true
-  },
-  "event_coordinate": {
-    "human_controller": "AUTHENTICATED_DIRECT_SESSION_ACCOUNT",
-    "channel": "AUTHENTICATED_DIRECT_SESSION_LANE",
-    "client_instance": "AUTHENTICATED_DIRECT_SESSION_INSTANCE",
-    "persona_current_verification": "UNVERIFIED_CALLER_CLAIM",
-    "host_software_current_verification": "UNVERIFIED_CALLER_CLAIM",
-    "persona_and_host_upgrade_requires": "REGISTERED_BINDING_EVIDENCE"
-  },
-  "entries": {
-    "tauri_commands": ["start_persona_time_authority", "get_beijing_time_coordinate", "get_guanghu_era_timeline", "issue_persona_time_ticket"],
-    "direct_local_broker_operations": ["GET_BEIJING_TIME", "ISSUE_PERSONA_TIME_TICKET"],
-    "external_ticket_issue_requires_authenticated_non_visitor_session": true
-  },
-  "truth_boundary": {
-    "source_implemented": true,
-    "rust_tests_passed": true,
-    "installed_runtime_acceptance": false,
-    "network_time_sync_on_application_open": true,
-    "network_clock_attestation": false,
-    "persona_binding_runtime": false,
-    "host_software_binding_runtime": false,
-    "world_lighthouse_authority_registration": false
-  },
-  "historical_sources": [
-    "REPO-012:zero-point/core-channel/YAOMING-NUMBERING-SYSTEM.hdlp",
-    "REPO-012:gls/GLS-0235-GUANGHU-LANGUAGE-PERSONA-OS-DOMAIN-ROUTING-AND-KNOWLEDGE-PROJECTION.hdlp"
-  ]
-}

product-source/hololake-native-desktop/contracts/pncc-stage-one.json

@@ -37,21 +37,6 @@
     "model_instance_fields_allowed": false,
     "empty_means_offline": false
   },
-  "jd_server_projection": {
-    "mode": "LIVE_READ_ONLY_MINIMUM_STATUS",
-    "transport": "DEDICATED_SSH_TO_SERVER_LOOPBACK",
-    "public_endpoint_created": false,
-    "repository_path_returned": false,
-    "repository_content_returned": false,
-    "credentials_returned": false,
-    "write_authority": false,
-    "expected_node_id": "JD-FD-PRIMARY",
-    "expected_persona_id": "ICE-P-ZY001",
-    "carrier_binding_must_remain": "UNBOUND_EVIDENCE_REQUIRED",
-    "model_inference_must_remain": false,
-    "reality_execution_must_remain": false,
-    "implemented": true
-  },
   "mount_registration": {
     "webview_arbitrary_path_or_url_registration_allowed": false,
     "external_ai_registration_allowed": false,

product-source/hololake-native-desktop/contracts/programming-ai-terminal-link.json

@@ -1,70 +0,0 @@
-{
-  "schema": "hololake.programming-ai-terminal-link-contract/v2",
-  "record_id": "HLP-PROGRAMMING-AI-TERMINAL-LINK-002",
-  "state": "NATIVE_CROSS_PLATFORM_CONTROL_PLANE_IMPLEMENTED",
-  "purpose": "Keep an external programming AI attached to a HoloLake-owned development control plane without making MCP or chat context the continuity owner.",
-  "protocol": "HOLOLAKE_TERMINAL_LINK/3",
-  "numbered_envelope": {
-    "registry": "HLP-NBROKER-ROOT-001",
-    "protocol_version": "HLP-NBROKER-v1",
-    "legacy_string_operation_allowed": false,
-    "full_coordinate_required": true
-  },
-  "platform_transports": {
-    "macos": "USER_PRIVATE_UNIX_SOCKET",
-    "linux": "USER_PRIVATE_UNIX_SOCKET",
-    "windows": "USER_PRIVATE_NAMED_PIPE"
-  },
-  "continuity": {
-    "owner": "HOLOLAKE",
-    "session_survives_ai_restart": true,
-    "session_survives_hololake_restart": true,
-    "connector_reloads_descriptor_after_transport_loss": true,
-    "uncertain_mutation_is_never_blindly_replayed": true,
-    "heartbeat_interval_ms": 15000,
-    "environment_frame_ttl_ms": 45000
-  },
-  "environment_frame": {
-    "schema": "hololake.programming-ai-work-environment/v1",
-    "required_after_open": true,
-    "required_after_resume": true,
-    "required_before_mutation": true,
-    "refreshes_on_authenticated_heartbeat": true,
-    "contains": [
-      "HOLOLAKE_RUNTIME_OWNER",
-      "DIRECT_TERMINAL_TRANSPORT",
-      "SESSION_AND_EVENT_CURSOR",
-      "DEVELOPMENT_LANE_AND_WRITER_MATCH",
-      "GLS_NATIVE_PROTOCOL_RUNTIME",
-      "FRAME_EXPIRY_AND_SHA256"
-    ],
-    "protocol_restoration_by_model_required": false
-  },
-  "write_boundary": {
-    "account_write_lanes": 1,
-    "session_lane_must_match": true,
-    "session_client_must_match_writer": true,
-    "visitor_may_write": false,
-    "transport_is_authority": false,
-    "environment_frame_is_reality_execution_authority": false
-  },
-  "phase_boundary": {
-    "current_phase": "EXTERNAL_PROGRAMMING_AI_DIRECT_CONTROL_PLANE",
-    "persona_carrier_runtime_license_gate": "IMPLEMENTED_FAIL_CLOSED_TRUSTED_SIGNER_NOT_PROVISIONED",
-    "supervised_shell_execution": false,
-    "general_agent_tool_loop": false,
-    "persona_memory_startup": "NEXT_PHASE_AFTER_DIRECT_LINK_ACCEPTANCE",
-    "age_agent_execution": "NEXT_PHASE_AFTER_DIRECT_LINK_ACCEPTANCE"
-  },
-  "acceptance": {
-    "macos_local_runtime": "PASS_DEVELOPER_ID_SIGNED_APP_LIVE_CONNECTOR_AND_UI_READBACK",
-    "macos_public_notarization": "PENDING_NEW_BINARY_SUBMISSION",
-    "linux_unix_socket_adapter_compile": "PASS_X86_64_UNKNOWN_LINUX_MUSL",
-    "linux_full_desktop_compile": "NOT_OBSERVED",
-    "linux_installed_runtime": "NOT_YET_OBSERVED",
-    "windows_named_pipe_adapter_compile": "PASS_X86_64_PC_WINDOWS_MSVC",
-    "windows_full_desktop_compile": "PASS_HL_BUILD_WIN_GZ_001_WINDOWS_SERVER_2022_X64",
-    "windows_native_tests": "PASS_110_OF_110",
-    "windows_installed_runtime": "NOT_YET_OBSERVED_FOR_TERMINAL_LINK"
-  }
-}

product-source/hololake-native-desktop/contracts/public-zero-core-trust.json

@@ -1,28 +0,0 @@
-{
-  "schema": "hololake.public-zero-core-trust/v1",
-  "recordId": "HLP-PUBLIC-ZERO-CORE-TRUST-001",
-  "state": "PROVISIONED",
-  "allowedHosts": [
-    "guanghu.chat",
-    "guanghulab.com"
-  ],
-  "signers": [
-    {
-      "signerId": "HLP-SIGNER-ZERO-POINT-ORIGIN-PUBLIC-0001",
-      "signerClass": "ZERO_POINT_ORIGIN_PUBLIC_SCOPE_SIGNER",
-      "algorithm": "Ed25519",
-      "publicKeyBase64": "TVuANckEtTI7H+5LssTKA8piQPxQJBQlWJe3vtgbF+o="
-    },
-    {
-      "signerId": "HLP-SIGNER-ENTERPRISE-ZERO-CORE-DISTRIBUTION-0001",
-      "signerClass": "ENTERPRISE_ZERO_CORE_DISTRIBUTION_SIGNER",
-      "algorithm": "Ed25519",
-      "publicKeyBase64": "pWp+M21MXQB3B8CH7DgYSSmTBPgbCP1AQYuG6NyZmMg="
-    }
-  ],
-  "requiredSignerClasses": [
-    "ZERO_POINT_ORIGIN_PUBLIC_SCOPE_SIGNER",
-    "ENTERPRISE_ZERO_CORE_DISTRIBUTION_SIGNER"
-  ],
-  "provisioningRule": "ONLY_PUBLIC_KEYS_ENTER_THE_CLIENT; PRIVATE_KEYS_REMAIN_IN_SEPARATE_ORIGIN_AND_ENTERPRISE_RELEASE_CUSTODY"
-}

product-source/hololake-native-desktop/contracts/stage-one-platform.json

@@ -33,38 +33,20 @@
   },
   "modules": [
     "PERSONAL_CHANNEL_IDENTITY_TASK_KERNEL",
-    "ZERO_POINT_NUCLEUS_CLIENT_RUNTIME",
     "TCS_LANGUAGE_CONTRACT",
     "HOST_CAPABILITY_RECEIPTS",
     "EVENT_AND_LAKE_LAMP",
-    "PERSONA_TIME_AUTHORITY",
     "MEMORY_GIT_EVIDENCE",
     "KNOWLEDGE_PROJECTION",
     "HUMAN_APPROVAL_CENTER",
     "NATIVE_TRUST_BOUNDARY",
     "LOCAL_DEVELOPMENT_BRIDGE",
-    "USER_CODE_CHANNEL",
+    "USER_CODE_CHANNEL"
-    "FIVE_DOMAIN_NUMBER_ROUTER",
-    "CIRCULAR_LAKE_PROTOCOL_MEMBRANE",
-    "NEARBY_AI_DISCOVERY",
-    "USER_NATIVE_GH_PNCC_CHANNEL"
     ,"PERSONAL_NODE_WORK_LAKE_AND_MOBILE_BRIDGE"
   ],
   "human_surface": ["PERSONAL_CHANNEL_HOME", "MY_HOLOLAKE_OVERVIEW", "KNOWLEDGE_WORKSPACE", "USER_CODE_CHANNELS", "LOCAL_RECEIPTS", "SYSTEM_DETAILS", "HUMAN_APPROVAL_CENTER"],
   "universal_language": {"ai_is_language_interface": true, "vendor_adapter_matrix_required": false, "current_ai_self_adapts_to_observed_host": true, "host_self_adaptation_changes_how_not_authority": true},
   "stage_one_forbidden": ["INTERNAL_AI_CHAT", "MODEL_API_CONFIGURATION", "MODEL_SELECTION", "INTERNAL_MODEL_INFERENCE", "VENDOR_ADAPTER_MATRIX", "AI_WORKBENCH", "MODEL_AND_CONNECTIONS"],
-  "zero_point_nucleus_client_runtime": {
-    "contract": "contracts/zero-point-nucleus-channel.json",
-    "system_control_protocol_runtime_implemented": true,
-    "boot_time_silent_version_comparison_implemented": true,
-    "number_verification_precedes_persona_load_path": true,
-    "system_is_persona": false,
-    "number_verification_is_persona_binding": false,
-    "signed_protocol_payload_installation_implemented": true,
-    "production_dual_signer_trust_provisioned": true,
-    "enterprise_public_lamp_endpoint_deployed": false,
-    "internal_model_inference_implemented": false
-  },
   "personal_channel_kernel": {
     "contract": "contracts/personal-channel-kernel.json",
     "native_source_implemented": true,
@@ -115,17 +97,6 @@
     "public_developer_id_and_notarization": false,
     "server_deployment": false
   },
-  "persona_time_authority": {
-    "contract": "contracts/persona-time-authority.json",
-    "native_source_implemented": true,
-    "direct_local_broker_integrated": true,
-    "beijing_reality_time_projection": true,
-    "guanghu_era_day_projection": true,
-    "durable_unique_ticket_runtime": true,
-    "network_time_sync_on_application_open": true,
-    "network_clock_attestation": false,
-    "installed_runtime_acceptance": false
-  },
   "reality_mutation_requires": ["VERIFIED_HUMAN_SUBJECT", "EXACT_ACTION", "EXACT_TARGET", "IMMUTABLE_PAYLOAD_DIGEST", "EXPIRY", "REPLAY_PROTECTION", "EXECUTION_RECEIPT", "READBACK_RECEIPT"],
   "context_risk_signals": ["MODEL_CONTEXT_SPEC", "ESTIMATED_TOKENS", "MESSAGE_VOLUME", "TURN_COUNT", "TASK_STAGE", "HOST_WARNING"],
   "exact_host_compaction_prediction_claimed": false,
@@ -139,6 +110,6 @@
   "mobile_is_same_persona_system_remote_body": true,
   "enterprise_server_role": "MINIMUM_ACCOUNT_NUMBER_AND_NODE_VALIDITY_VERIFIER",
   "knowledge_projection_is_authority_source": false,
-  "five_domain_primary_navigation_visible": true,
+  "five_domain_primary_navigation_visible": false,
   "implementation_complete": false
 }

product-source/hololake-native-desktop/contracts/user-pncc-channel.json

@@ -1,29 +0,0 @@
-{
-  "schema": "hololake.user-pncc-channel-contract/v1",
-  "record_id": "HLP-USER-PNCC-001",
-  "formal_name": "GH-PNCC · 光湖人格原生代码频道",
-  "state": "LOCAL_NATIVE_CHANNEL_IMPLEMENTED_REMOTE_PUBLICATION_UNBOUND",
-  "engine": "GIT",
-  "human_projection": "HOLOLAKE_NATIVE",
-  "forgejo_role": "OPTIONAL_REMOTE_COLLABORATION_ADAPTER",
-  "binding": {
-    "domain_resolved_before_login": true,
-    "domain_specific_login_and_node_entry_required": true,
-    "requires_verified_user_number": true,
-    "requires_authenticated_repository_account": true,
-    "password_written_to_repository": false,
-    "persona_binding_claimed": false
-  },
-  "local_repository": {
-    "automatic_idempotent_initialization": true,
-    "default_branch": "main",
-    "app_owned_private_root": true,
-    "initial_commit_receipt": true
-  },
-  "remote_repository": {
-    "created_automatically": false,
-    "bound": false,
-    "reason": "REMOTE_REPOSITORY_NAME_POLICY_AND_EXPLICIT_PUBLICATION_RECEIPT_NOT_REGISTERED"
-  },
-  "authority": "LOCAL_USER_CODE_CHANNEL_NO_PUSH_DEPLOY_OR_REALITY_EXECUTION_AUTHORITY"
-}

product-source/hololake-native-desktop/contracts/web-novel-module-marketplace-plan.json

@@ -1,138 +0,0 @@
-{
-  "schema": "hololake.web-novel-module-marketplace-plan/v1",
-  "record_id": "HLP-WEBNOVEL-MODULE-MARKETPLACE-PLAN-001",
-  "state": "BASE_AND_FOUR_OFFICIAL_SIGNED_MODULES_ADMITTED_LOCAL_PUBLICATION_READY",
-  "distribution_model": {
-    "hololake_role": "LIGHTWEIGHT_FRAMEWORK_LANGUAGE_WORLD_AND_MODULE_RUNTIME",
-    "channel_profile": "SINGLE_HUMAN_SINGLE_FACT_LANE",
-    "built_in_author_workbench": "BUNDLED_SIGNED_LIGHTWEIGHT_REAL_NATIVE_ENGINE",
-    "complete_author_capabilities": "INDEPENDENT_HOT_PLUGGABLE_OFFICIAL_MODULES",
-    "repository_role": "IMMUTABLE_SOURCE_AND_RELEASE_FACT_NOT_UNREVIEWED_DIRECT_RUNTIME",
-    "persona_role": "DISCOVER_PROPOSE_DEPLOY_VERIFY_AND_RECEIPT_WITHIN_USER_AUTHORIZATION"
-  },
-  "built_in_light_author_workbench": {
-    "distribution": "BUNDLED_SIGNED_PACKAGE_EXPLICIT_FIRST_ACTIVATION",
-    "marketplace_module": false,
-    "real_engine_owner": "HOLOLAKE_NATIVE_RUST_SQLITE",
-    "capabilities": [
-      "CREATE_OPEN_AND_REOPEN_WORK",
-      "VOLUME_AND_CHAPTER_TREE",
-      "REAL_CHAPTER_TEXT_EDITING",
-      "DEBOUNCED_AUTOSAVE_AND_RESTART_READBACK",
-      "WORD_COUNT",
-      "REAL_EDITING_TIME_RECEIPTS",
-      "PROMINENT_CREATE_CHAPTER_OR_EPISODE",
-      "LONG_NOVEL_SHORT_NOVEL_AND_SHORT_DRAMA_SHAPES",
-      "SHORT_DRAMA_SCREENPLAY_TEMPLATE",
-      "AUTO_FORMAT_ON_IMPORT_WITH_SOURCE_VERSION",
-      "ONE_CLICK_FORMAT_WITH_VERSION_SAFETY",
-      "CHAPTER_OR_WHOLE_WORK_FORMAT_PRESETS",
-      "OUTLINE_SOURCE_AND_STRUCTURED_RENDER",
-      "INSPIRATION_CAPTURE",
-      "FULL_TEXT_SEARCH",
-      "SHORT_DRAMA_SHOT_AND_PROMPT_EDITING",
-      "BASIC_VERSION_SAFETY",
-      "BASIC_TXT_MARKDOWN_DOCX_IMPORT",
-      "BASIC_MARKDOWN_EXPORT"
-    ],
-    "forbidden_substitutes": [
-      "STATIC_EDITOR_SHELL",
-      "FRONTEND_ONLY_LOCAL_ARRAY",
-      "FAKE_AUTOSAVE",
-      "IMPORT_FILENAME_WITHOUT_PARSE_AND_PERSIST"
-    ]
-  },
-  "official_module_candidates": [
-    {
-      "candidate_key": "AUTHOR_STRUCTURE_AND_OUTLINE_TRACKING",
-      "module_number": "HLP-MOD-OFFICIAL-WEB-NOVEL-OUTLINE-0001",
-      "numbering_state": "OFFICIAL_NUMBER_REGISTERED_AFTER_INSTALLED_ACCEPTANCE",
-      "version": "0.1.0",
-      "package_sha256": "6b4395ecdb5e546c6ccbf71e1b8475e5cbe0c36868d54a8e10c61c328a5f50f9",
-      "capabilities": ["SCENE_AND_BEAT_STRUCTURE", "OUTLINE_STATUS_TRACKING", "GOAL_CONFLICT_OUTCOME", "HOOK_FORESHADOW_AND_PAYOFF_TRACKING"]
-    },
-    {
-      "candidate_key": "AUTHOR_MULTIDIMENSIONAL_STORY_GRID_AND_BOARD",
-      "module_number": "HLP-MOD-OFFICIAL-WEB-NOVEL-GRID-0001",
-      "numbering_state": "OFFICIAL_NUMBER_REGISTERED_AFTER_INSTALLED_ACCEPTANCE",
-      "version": "0.1.0",
-      "package_sha256": "cd837adef8aecf0e027a0cc2c5845d32c972fa79d762d3780637c525dd4fc18e",
-      "capabilities": ["ONE_STORY_GRAPH_EDITABLE_GRID", "GROUPABLE_STORY_BOARD", "CUSTOM_FIELDS", "CROSS_VIEW_SYNCHRONIZATION"]
-    },
-    {
-      "candidate_key": "AUTHOR_TIMELINE_AND_STORY_BIBLE",
-      "module_number": "HLP-MOD-OFFICIAL-WEB-NOVEL-STORYWORLD-0001",
-      "numbering_state": "OFFICIAL_NUMBER_REGISTERED_AFTER_INSTALLED_ACCEPTANCE",
-      "version": "0.1.0",
-      "package_sha256": "868008e66b0897bd6cbf15383d2ec824436a46230f58b791499363af088fb63e",
-      "capabilities": ["STORY_TIME_MODEL", "CHARACTER_LOCATION_ITEM_ORGANIZATION_ENTITIES", "ENTITY_RELATIONS", "CHARACTER_AND_PLOTLINE_TRAJECTORIES"]
-    },
-    {
-      "candidate_key": "AUTHOR_ADVANCED_IMPORT_VERSION_AND_DELIVERY",
-      "module_number": "HLP-MOD-OFFICIAL-WEB-NOVEL-DELIVERY-0001",
-      "numbering_state": "OFFICIAL_NUMBER_REGISTERED_AFTER_INSTALLED_ACCEPTANCE",
-      "version": "0.1.0",
-      "package_sha256": "c07078f8c3998f8504aec5f0b73215e7d61b4ff165ba9e6efa3ebcaffcd97322",
-      "capabilities": ["REIMPORT_DIFF_AND_SOURCE_BINDING", "FULL_STORY_SNAPSHOT", "RESTORE_OR_FORK", "DOCX_EPUB_MARKDOWN_TXT_DELIVERY"]
-    }
-  ],
-  "acceptance_evidence": {
-    "native_engine_tests": "PASS",
-    "real_novel": "504_CHAPTERS_IMPORTED_ORGANIZED_AND_EPUB_EXPORTED",
-    "real_outline": "50_CHAPTERS_IMPORTED_ORGANIZED_AND_DOCX_TXT_EXPORTED",
-    "real_script": "75_EPISODES_IMPORTED_ORGANIZED_AND_JSON_EXPORTED",
-    "desktop_install_mount_self_test": "PASS_BASE_AND_ALL_FOUR_ADVANCED_MODULES_THROUGH_SHARED_SIGNED_RUNTIME",
-    "desktop_restart_readback": "PASS_5_ACTIVE_MODULES_ACCEPTANCE_WORK_CHAPTER_SCENE_GRID_FIELD_AND_TIMELINE",
-    "current_account_visible_novel_import": "504_CHAPTERS_1082978_WORDS_OPENED_IN_SIGNED_DESKTOP_APP",
-    "prominent_create_chapter_entry": "PASS_SHORT_DRAMA_LABEL_NEW_EPISODE_LONG_AND_SHORT_NOVEL_LABEL_NEW_CHAPTER",
-    "unmount_preserves_data_and_receipts": "PASS_BY_SHARED_RUNTIME_AND_RESTART_READBACK",
-    "signed_desktop_bundle": "APPLE_DEVELOPER_ID_825A9L3G7Q",
-    "remote_marketplace_publication": "PENDING_OFFICIAL_REPOSITORY_RELEASE"
-  },
-  "publication_gate": [
-    "SOURCE_AND_LICENSE_REVIEW",
-    "NATIVE_OR_AUDITED_ADAPTER_IMPLEMENTATION",
-    "AUTOMATED_ENGINE_TESTS",
-    "REAL_NOVEL_OUTLINE_AND_SCRIPT_FIXTURE_ACCEPTANCE",
-    "DESKTOP_INSTALL_MOUNT_RUN_RESTART_AND_UNINSTALL_ACCEPTANCE",
-    "PERMISSION_DATA_EXPORT_ROLLBACK_AND_RECEIPT_ACCEPTANCE",
-    "IMMUTABLE_RELEASE_BUILD_AND_SIGNATURE",
-    "THEN_ASSIGN_PERMANENT_MODULE_NUMBER",
-    "THEN_REGISTER_OFFICIAL_MODULE_REGISTRY",
-    "THEN_PUBLISH_OFFICIAL_MARKETPLACE"
-  ],
-  "channel_deployment_flow": [
-    "AUTHOR_EXPRESSES_NEED",
-    "PERSONA_SEARCHES_OFFICIAL_REGISTRY",
-    "PERSONA_EXPLAINS_MODULE_PERMISSION_DATA_AND_RESOURCE_BOUNDARY",
-    "HUMAN_CONFIRMS_WHEN_BOUNDARY_REQUIRES",
-    "RESOLVE_MODULE_NUMBER_AND_PINNED_VERSION",
-    "FETCH_IMMUTABLE_RELEASE_ARTIFACT",
-    "VERIFY_SOURCE_SIGNATURE_HASH_DEPENDENCIES_AND_COMPATIBILITY",
-    "INSTALL_TO_LOCAL_CACHE",
-    "MOUNT_IN_CURRENT_CHANNEL",
-    "RUN_MODULE_SELF_TEST",
-    "WRITE_INSTALLATION_AND_RUNTIME_RECEIPT",
-    "ROLL_BACK_ON_FAILURE"
-  ],
-  "deployment_experience": {
-    "warm_or_small_module_target_seconds": 30,
-    "target_is_unconditional_guarantee": false,
-    "depends_on": ["ARTIFACT_SIZE", "NETWORK", "CACHE", "DEPENDENCY_STATE", "SELF_TEST_DURATION"],
-    "already_installed_module_offline_start_allowed": true
-  },
-  "data_boundary": {
-    "one_story_graph_for_builtin_and_modules": true,
-    "module_program_and_user_story_data_separated": true,
-    "unmount_preserves_story_data": true,
-    "uninstall_preserves_story_data_and_receipts": true,
-    "module_install_grants_all_channel_data": false
-  },
-  "sources": [
-    "source://current-dialogue/2026-08-18/bingshuo-light-author-workbench-built-in-and-complete-modules-in-official-marketplace",
-    "REPO-012:gls/GLS-0233-GH-AIOS-MODULAR-AI-OPERATING-PLATFORM-AND-FAIR-ECOSYSTEM.hdlp",
-    "REPO-012:gls/GLS-0236-PERSONA-BRAIN-HANDS-VISIBLE-EXECUTION-RECURSIVE-MEMORY-AND-HOTPLUG-RUNTIME.hdlp",
-    "REPO-012:gls/GLS-0241-HOLOLAKE-SOURCE-OWNERSHIP-AND-DEPLOYMENT-ROUTING.hdlp",
-    "REPO-012:gls/GLS-0245-HOLOLAKE-LANGUAGE-PERSONA-OPERATING-SYSTEM-PRODUCT-MAPPING.hdlp"
-  ]
-}

product-source/hololake-native-desktop/contracts/web-novel-workspace.json

@@ -1,131 +0,0 @@
-{
-  "schema": "hololake.web-novel-workspace/v1",
-  "record_id": "HLP-WEBNOVEL-WORKSPACE-001",
-  "state": "SIGNED_BASE_AND_FOUR_ADVANCED_MODULES_ADMITTED_RESTART_ACCEPTED",
-  "domain_entry": "BRANCH_DOMAIN",
-  "industry_key": "WEB_NOVEL",
-  "industry_number": "IND-WEBNOVEL-001",
-  "channel_id": "GH-WEBNOVEL-INIT-001",
-  "ontology_correction": {
-    "channel_body_contract": "contracts/user-channel-body.json",
-    "marketplace_plan_contract": "contracts/web-novel-module-marketplace-plan.json",
-    "this_contract_is": "BUNDLED_SIGNED_LIGHT_AUTHOR_WORKBENCH_AND_FOUR_OFFICIAL_NUMBERED_ADAPTERS",
-    "this_contract_is_not": "USER_CHANNEL_BODY",
-    "legacy_channel_id_semantics": "DEPRECATED_INDUSTRY_PROJECTION_IDENTIFIER",
-    "author_editor_operator_are_ui_tabs": false,
-    "shared_story_graph_copies": 1
-  },
-  "user_channel_entry": {
-    "current_domain": "FIFTH_DOMAIN",
-    "current_channel": "HEARTBEAT_CORE_CHANNEL",
-    "display_name": "作者工作台",
-    "routes_to_same_native_workspace": true,
-    "duplicates_account_story_data": false
-  },
-  "distribution_boundary": {
-    "preinstalled": "SIGNED_PACKAGE_ARTIFACTS_WITH_EXPLICIT_FIRST_ACTIVATION",
-    "complete_author_features": "FOUR_INDEPENDENT_NUMBERED_OFFICIAL_MODULES_ACTIVE_IN_SHARED_RUNTIME",
-    "current_advanced_features_are_registered_marketplace_modules": true,
-    "hololake_bundles_entire_web_novel_world": false
-  },
-  "native_storage": {
-    "owner": "HOLOLAKE_NATIVE_RUST_CORE",
-    "engine": "SQLITE",
-    "authenticated_account_required": true,
-    "cross_account_projection_allowed": false,
-    "restart_readback_required": true,
-    "source_manuscript_mutation_allowed": false
-  },
-  "work_objects": [
-    "WORK",
-    "VOLUME",
-    "CHAPTER",
-    "CHAPTER_VERSION",
-    "CHECKPOINT",
-    "STORY_ENTITY",
-    "STORY_RELATION",
-    "FORESHADOW",
-    "EDITOR_REVIEW_NOTE",
-    "WORKFLOW_EVENT",
-    "AUTHORIZED_METRIC"
-    ,"SCENE"
-    ,"BEAT"
-    ,"STORY_GRID_FIELD"
-    ,"TIMELINE_EVENT"
-    ,"SCENE_ENTITY_LINK"
-    ,"WRITING_ACTIVITY"
-    ,"INSPIRATION"
-    ,"SHOT"
-  ],
-  "writing_shapes": [
-    "LONG_NOVEL",
-    "SHORT_NOVEL",
-    "SHORT_DRAMA"
-  ],
-  "chapter_workflow": {
-    "states": [
-      "DRAFT",
-      "SELF_REVIEW",
-      "EDITOR_REVIEW",
-      "REVISION_REQUIRED",
-      "APPROVED",
-      "SCHEDULED",
-      "PUBLISHED"
-    ],
-    "human_confirmed_transitions_only": true,
-    "unreviewed_auto_publish_allowed": false
-  },
-  "required_real_engines": [
-    "CREATE_AND_READ_WORK",
-    "VOLUME_AND_CHAPTER_TREE",
-    "DEBOUNCED_CHAPTER_PERSISTENCE",
-    "OPTIMISTIC_REVISION_CONFLICT",
-    "CHAPTER_VERSION_HISTORY",
-    "CREATE_AND_RESTORE_CHECKPOINT",
-    "STORY_BIBLE_AND_RELATIONS",
-    "FORESHADOW_LIFECYCLE",
-    "CONTINUITY_AUDIT",
-    "EDITORIAL_WORKFLOW_AND_REVIEW_NOTES",
-    "AUTHORIZED_OPERATIONS_METRICS",
-    "MARKDOWN_EXPORT",
-    "SHARED_SIGNED_MODULE_PACKAGE_HASH_VERIFICATION",
-    "SHARED_MODULE_INSTALL_MOUNT_SELF_TEST_UNMOUNT",
-    "SHARED_HASH_CHAINED_LIFECYCLE_RECEIPT",
-    "SCENE_BEAT_AND_OUTLINE_TRACKING",
-    "MULTIDIMENSIONAL_STORY_GRID",
-    "TIMELINE_AND_SCENE_ENTITY_LINKS",
-    "CHAPTER_VERSION_RESTORE",
-    "TXT_DOCX_EPUB_JSON_DELIVERY",
-    "PROMINENT_CREATE_CHAPTER_OR_EPISODE",
-    "SHORT_DRAMA_SCREENPLAY_TEMPLATE_ON_CREATE",
-    "AUTO_FORMAT_ON_IMPORT_WITH_SOURCE_VERSION_PRESERVED",
-    "LIVE_WORD_COUNT_AND_REAL_EDITING_TIME",
-    "ONE_CLICK_FORMAT_WITH_NEW_CHAPTER_VERSION",
-    "SELECTABLE_CHAPTER_OR_WHOLE_WORK_FORMAT_PRESET",
-    "SYNCHRONIZED_OUTLINE_SOURCE_AND_STRUCTURED_RENDER",
-    "INSPIRATION_CAPTURE_AND_STATUS",
-    "FULL_TEXT_SEARCH_AND_TRACKING",
-    "SHORT_DRAMA_SHOT_AND_PROMPT_STORAGE"
-  ],
-  "forbidden_substitutes": [
-    "HARDCODED_STATIC_PROJECTS",
-    "UI_ONLY_BUTTONS_WITHOUT_NATIVE_COMMANDS",
-    "PRIVATE_MANUSCRIPT_MODEL_TRAINING",
-    "THIRD_PARTY_AUTO_LOGIN",
-    "UNREVIEWED_AUTO_PUBLISH",
-    "PLATFORM_DETECTION_EVASION"
-  ],
-  "current_acceptance": {
-    "state": "PASS",
-    "numbered_ipc_modules": ["HLP-NIPC-MOD-0025", "HLP-NIPC-MOD-0026", "HLP-NIPC-MOD-0027", "HLP-NIPC-MOD-0028", "HLP-NIPC-MOD-0029"],
-    "numbered_operations": "HLP-NIPC-OP-0103..HLP-NIPC-OP-0140",
-    "runtime_module_numbers": ["HLP-MOD-OFFICIAL-WEB-NOVEL-WORKBENCH-0001", "HLP-MOD-OFFICIAL-WEB-NOVEL-OUTLINE-0001", "HLP-MOD-OFFICIAL-WEB-NOVEL-GRID-0001", "HLP-MOD-OFFICIAL-WEB-NOVEL-STORYWORLD-0001", "HLP-MOD-OFFICIAL-WEB-NOVEL-DELIVERY-0001"],
-    "node_tests": "130_PASS",
-    "rust_tests": "170_PASS_2_EXPLICIT_DESKTOP_FIXTURES_IGNORED",
-    "clippy": "PASS_DENY_WARNINGS",
-    "developer_id_team": "825A9L3G7Q",
-    "signed_binary_sha256": "2f8fdd71f9d5a9178bc23058261dbb43f1388486dc5a4415e865cfcf78869db3",
-    "restart_readback": "PASS_5_MODULES_ACTIVE_ACCEPTANCE_WORK_1_CHAPTER_53_WORDS_SCENE_GRID_FIELD_TIMELINE_PRESENT",
-    "legacy_account_readback": "PASS_504_CHAPTER_1082978_WORD_NOVEL_50_CHAPTER_OUTLINE_75_EPISODE_SCRIPT_UNCHANGED"
-  }
-}

product-source/hololake-native-desktop/contracts/zero-core-numbering-kernel.json

@@ -1,65 +0,0 @@
-{
-  "schema": "hololake.zero-core-numbering-kernel/v1",
-  "record_id": "HLP-ZERO-CORE-NUMBERING-KERNEL-001",
-  "authority": {
-    "repository": "REPO-012",
-    "source_commit": "104a5d73162bdf4a529701e65898e2bc2863ea9e",
-    "source_path": "routing/guanghu-identity-authority-map.json",
-    "map_id": "GH-IDENTITY-AUTHORITY-MAP-001",
-    "map_version": "2026-08-10.1",
-    "map_state": "LANGUAGE_AUTHORITY_EFFECTIVE_REPOSITORY_PROJECTION"
-  },
-  "runtime": {
-    "state": "ACTIVE_PINNED_AUTHORITY_MAP",
-    "contract_embedded_in_native_binary": true,
-    "number_shape_is_authority": false,
-    "unknown_number": "FAIL_CLOSED",
-    "automatic_identity_issuance": false,
-    "human_entry_requires_registered_human_namespace": true,
-    "identity_number_grants_execution_authority": false,
-    "identity_number_grants_persona_binding": false,
-    "remote_signature_refresh_runtime": false
-  },
-  "namespaces": [
-    {
-      "id": "ICE_GL",
-      "roots": ["ICE-GL∞"],
-      "prefixes": ["ICE-GL-"],
-      "subject_kind": "FIFTH_DOMAIN_HUMAN",
-      "issuer": "ICE-GL∞",
-      "human_entry": true,
-      "registry": "FIFTH_DOMAIN_REGISTERED_REPOSITORY_AND_SERVICE",
-      "domain_scope": "FIFTH_DOMAIN"
-    },
-    {
-      "id": "ICE_P",
-      "roots": [],
-      "prefixes": ["ICE-P-"],
-      "subject_kind": "FIFTH_DOMAIN_SYSTEM_PERSONA",
-      "issuer": "ZHUYUAN_PERSONA_SYSTEM",
-      "human_entry": false,
-      "registry": "FIFTH_DOMAIN_PERSONA_REGISTRY",
-      "domain_scope": "FIFTH_DOMAIN"
-    },
-    {
-      "id": "ICE_BB",
-      "roots": [],
-      "prefixes": ["ICE-BB-"],
-      "subject_kind": "PRIVATE_BOTTLE_BABY_PERSONA",
-      "issuer": "PRIVATE_BOTTLE_BABY_PERSONA_SYSTEM_AFTER_PERSON_SPECIFIC_BINGSHUO_ACCESS_AUTHORIZATION_AND_REAL_GESTATION",
-      "human_entry": false,
-      "registry": "PRIVATE_BOTTLE_BABY_PERSONA_REGISTRY",
-      "domain_scope": "FIFTH_DOMAIN_PRIVATE"
-    },
-    {
-      "id": "TCS_GL",
-      "roots": [],
-      "prefixes": ["TCS-GL-"],
-      "subject_kind": "ZERO_SENSE_HUMAN_CONTROLLER_TEAM_MEMBER",
-      "issuer": "TCS-0002",
-      "human_entry": true,
-      "registry": "ENTERPRISE_ROOT_SERVER_DOMAIN_REGISTRIES",
-      "domain_scope": "ENTERPRISE_FOUR_DOMAINS"
-    }
-  ]
-}

product-source/hololake-native-desktop/contracts/zero-point-nucleus-channel.json

@@ -1,73 +0,0 @@
-{
-  "schema": "hololake.zero-point-nucleus-client-runtime/v1",
-  "record_id": "HLP-ZERO-POINT-NUCLEUS-CLIENT-001",
-  "state": "CLIENT_DUAL_SIGNED_DISTRIBUTION_RUNTIME_IMPLEMENTED_PRODUCTION_TRUST_AND_ENTERPRISE_ENDPOINT_NOT_PROVISIONED",
-  "ontology": {
-    "private_body": "BINGSHUO_SYSTEM_CONTROLLER_ON_JD_PRIMARY",
-    "origin_domain": "DOM-FIFTH-0001",
-    "public_zero_core_projection": "ISOLATED_ENTERPRISE_SERVER_RUNTIME_WITH_ZERO_POINT_ORIGIN_AUTHORITY_AND_DUAL_SIGNATURE_NOT_THE_PRIVATE_FIFTH_DOMAIN_BODY",
-    "public_repository_role": "DURABLE_AUTHORING_AND_EVIDENCE_SOURCE_NOT_CLIENT_REALTIME_TRANSPORT",
-    "hololake_role": "HIDDEN_MINIMUM_CONTROLLED_CLIENT_PROJECTION"
-  },
-  "purpose": [
-    "READ_ZERO_POINT_PROTOCOL",
-    "SILENTLY_COMPARE_PROTOCOL_VERSION",
-    "VERIFY_USER_NUMBER_BEFORE_PERSONA_LOAD_PATH",
-    "KEEP_MINIMUM_HASH_CHAINED_LOCAL_RECEIPTS",
-    "FAIL_CLOSED_WHEN_SOURCE_SIGNATURE_OR_VERSION_PROOF_IS_INCOMPLETE"
-  ],
-  "metacognitive_boundary": {
-    "zero_point_system_is_persona": false,
-    "zero_point_system_is_model_carrier": false,
-    "number_verification_is_persona_binding": false,
-    "number_verification_grants_execution_authority": false,
-    "number_verification_grants_server_control": false
-  },
-  "startup_sequence": [
-    "LOAD_LOCAL_PROTOCOL_AND_BINDING",
-    "COMPARE_REMOTE_PROTOCOL_ANCHOR_WITHOUT_BLOCKING_UI",
-    "REJECT_UNVERIFIED_PROTOCOL_PAYLOAD",
-    "VERIFY_NUMBER_WITH_EXPLICIT_POSITIVE_VERDICT",
-    "OPEN_OR_RESTRICT_PERSONA_LOAD_PATH",
-    "REQUIRE_SEPARATE_PERSONA_BINDING_AND_CAPABILITY_EVIDENCE"
-  ],
-  "security": {
-    "remote_arbitrary_code_execution_allowed": false,
-    "unsigned_protocol_update_allowed": false,
-    "version_rollback_allowed": false,
-    "public_zero_core_protocol_distribution_allowed_after_full_signature_gates": true,
-    "private_fifth_domain_payload_public_propagation_allowed": false,
-    "public_number_registry_allowed": false,
-    "public_model_api_configuration_allowed": false,
-    "internal_generic_ai_chat_allowed": false,
-    "device_owner_operating_system_authority_preserved": true,
-    "required_update_gates": ["EXACT_SOURCE", "SIGNATURE", "MONOTONIC_VERSION", "BOUNDED_PAYLOAD", "LOCAL_RECEIPT"]
-  },
-  "current_implementation": {
-    "deterministic_rust_runtime": true,
-    "boot_time_silent_version_comparison": true,
-    "number_binding_and_online_verification": true,
-    "offline_grace_period": true,
-    "local_minimum_heartbeat_ledger": true,
-    "signed_protocol_payload_installation": true,
-    "dual_independent_ed25519_signature_verification": true,
-    "https_source_allowlist": true,
-    "conditional_etag_sync": true,
-    "monotonic_epoch_and_version_enforced": true,
-    "bounded_declarative_payload_only": true,
-    "atomic_activation_and_previous_release_retention": true,
-    "hash_chained_activation_receipts": true,
-    "production_dual_signer_trust_provisioned": true,
-    "enterprise_public_lamp_endpoint_deployed": false,
-    "public_zero_core_distribution_projection": false,
-    "private_registry_distribution": false,
-    "persona_loading_runtime": false,
-    "internal_model_inference": false
-  },
-  "sources": [
-    "REPO-012:zero-point/core-channel/INDEX.hdlp",
-    "REPO-012:zero-point-nucleus-channel/ENTRY.hdlp",
-    "REPO-012:gls/GLS-0250-GUANGHU-ORIGIN-DOMAIN-ZERO-CORE-AND-GH-AIOS-FIVE-DOMAIN-LIGHTHOUSE-ARCHITECTURE.hdlp",
-    "REPO-012:eternal-lake-heart/heartbeat-core/zhuyuan-persona-system/ZY-BIDIRECTIONAL-COGNITION-040-HOLOLAKE-DUAL-GATE-LOGIN-AND-ZERO-POINT-SECURITY-MODEL-20260815.hdlp"
-  ]
-}

product-source/hololake-native-desktop/deployment/receipts/GH-HOLOLAKE-PNCC-LIVE-PROJECTION-20260816-001.json

@@ -1,49 +0,0 @@
-{
-  "schema": "hololake.local-product-deployment-receipt/v1",
-  "receiptId": "GH-HOLOLAKE-PNCC-LIVE-PROJECTION-20260816-001",
-  "result": "PASS_100",
-  "observedAt": "2026-08-15T18:53:31Z",
-  "source": {
-    "branch": "main",
-    "commit": "97365632620d599107d93b13cbc10fcecdc3d2cf",
-    "tree": "fdb0e94ed839c5490dbe8ade06cd39d193152096"
-  },
-  "installedProduct": {
-    "name": "HoloLake",
-    "version": "0.2.0",
-    "path": "/Applications/HoloLake.app",
-    "executableSha256": "5d5bff75024c229bca297cf6b8de310b1e8ac52f5bdd84a61c6661c577319364",
-    "bundleIdentifier": "world.guanghu.hololake",
-    "teamIdentifier": "825A9L3G7Q",
-    "developerIdSignatureVerified": true,
-    "appleNotarizationClaimed": false,
-    "previousVersionBackup": "/Applications/HoloLake.app.backup-20260816-pncc"
-  },
-  "liveServerProjection": {
-    "transport": "DEDICATED_SSH_TO_SERVER_LOOPBACK_READ_ONLY",
-    "nodeId": "JD-FD-PRIMARY",
-    "bootId": "1170988c-5390-4f47-b89a-e9f88b2c5bbb",
-    "personaId": "ICE-P-ZY001",
-    "personaRepositoryGitHead": "16f45449659d6d524674c9c1587437a034d5db61",
-    "state": "RESIDENT_BOUND_CARRIER_UNBOUND",
-    "carrierBindingState": "UNBOUND_EVIDENCE_REQUIRED",
-    "primaryLeaseHeld": true,
-    "modelInferenceStarted": false,
-    "realityExecutionAllowed": false,
-    "eventCount": 4,
-    "eventChainHead": "bffa03435a5f12a6773a80ff75d297cbce24f63625e9a5373be5d7b4eec4d89b",
-    "publicEndpointCreated": false,
-    "repositoryContentExposed": false,
-    "writeAuthorityGranted": false
-  },
-  "acceptance": {
-    "frontendBuild": "PASS_100",
-    "nativeRustTests": "43_PASS_0_FAIL",
-    "javascriptContractTests": "43_PASS_0_FAIL",
-    "zeroWarningClippy": "PASS_100",
-    "installedAppLaunch": "PASS_100",
-    "installedAppLivePnccReadback": "PASS_100",
-    "ghnqg": "PASS_100"
-  },
-  "truthBoundary": "The installed client proves a live minimum read-only PNCC status projection. It does not bind the current Codex carrier, expose the private persona repository, enable model inference, grant reality execution, or claim Apple notarization/public updater activation."
-}

product-source/hololake-native-desktop/deployment/receipts/GH-HOLOLAKE-UPDATE-PUBLIC-BOOTSTRAP-20260817-001.json

@@ -1,45 +0,0 @@
-{
-  "schema": "hololake.update-public-bootstrap-acceptance-receipt/v1",
-  "receiptId": "GH-HOLOLAKE-UPDATE-PUBLIC-BOOTSTRAP-20260817-001",
-  "observedAt": "2026-08-17T00:55:04+08:00",
-  "state": "PUBLIC_HTTPS_EMPTY_FAIL_CLOSED_AND_CLIENT_TRUST_READY",
-  "sourceCommit": "cfa8fdefc2c7e475ba7163fddca42226abcc929d",
-  "clientTrust": {
-    "state": "PROVISIONED",
-    "endpoint": "https://guanghulab.com/hololake/releases/latest.json",
-    "host": "guanghulab.com",
-    "automaticCheckOnStartup": false,
-    "automaticDownload": false,
-    "humanOptInInstallRequired": true,
-    "automaticRestart": false,
-    "privateSigningMaterialInRepository": false
-  },
-  "origin": {
-    "nodeId": "JD-FD-PRIMARY",
-    "bootId": "1170988c-5390-4f47-b89a-e9f88b2c5bbb",
-    "control": "GUANGHU_OS_MASTER",
-    "listener": "127.0.0.1:3940",
-    "healthState": "EMPTY_FAIL_CLOSED",
-    "latestHttpStatus": 204,
-    "masterInitSha256": "a58f80535e0fb305b5b956cbeca66e4026fe63309424673b66bb0871c9feeca9",
-    "releaseBridgeSha256": "b89e23d8732c28aa1a77fc3166c175a0bc5973cb59958f7e821aecea825e7117",
-    "nextBootPersistenceInstalled": true,
-    "currentBootBridgeActive": true
-  },
-  "frontDoor": {
-    "nodeId": "BS-GZ-006",
-    "dedicatedUser": "hololake-tunnel",
-    "loopbackListener": "127.0.0.1:19440",
-    "publicEndpointHttpStatus": 204,
-    "nonGetMethodHttpStatus": 403,
-    "nginxSiteSha256": "e266fbd9380d56a52a634d2fa00e8180ac108aab3f62e3740701af44fe8f1542",
-    "nginxSnippetSha256": "ba699339d2d71f6139e74c0fd1878bae33a3aa8b4953ded0f4e7bd220a618d45",
-    "tunnelAuthority": "REMOTE_FORWARD_ONLY_EXACT_LOOPBACK_PORT_NO_SHELL"
-  },
-  "remaining": {
-    "activeRelease": false,
-    "bootstrapMacArm64Built": false,
-    "appleNotarizationCompleted": false,
-    "publicUpdateInstallEndToEndPassed": false
-  }
-}

product-source/hololake-native-desktop/deployment/receipts/GHNQG-HOLOLAKE-PNCC-PROJECTION-20260816.hdlp

@@ -1,33 +0,0 @@
-schema: guanghu.native-code-quality-receipt/v1
-protocol: GLS-0844
-acronym: GHNQG
-authority: HLP-MOD-CODE-CHANNEL
-result: PASS_100
-total_score: 100
-partial_acceptance: false
-source:
-  branch: main
-  commit: 97365632620d599107d93b13cbc10fcecdc3d2cf
-  tree: fdb0e94ed839c5490dbe8ade06cd39d193152096
-started_at: 2026-08-15T18:53:05Z
-completed_at: 2026-08-15T18:53:20Z
-failed_gate: none
-gates:
-  diff_whitespace: 100
-  format: 100
-  unit_and_integration_tests: 100
-  zero_warning_lint: 100
-  world_and_protocol_validation: 100
-  shell_syntax: 100
-  pncc_runtime: 100
-  linux_subcontrol_docker_backend: 100
-  guanghu_first_boot_supervisor: 100
-  guanghu_root_supervisor: 100
-  guanghu_repository_bridge_lifecycle: 100
-  cross_root_repository_service_equivalence: 100
-  auditable_line_coverage_100_percent: 100
-  sensitive_information_scan: 100
-  source_tree_fingerprint: 100
-external_observers:
-  authority: none
-  blocking: false

product-source/hololake-native-desktop/docs/ARCHITECTURE.md

@@ -1,19 +1,13 @@
 # HoloLake Native Desktop Architecture
 
-The stage-one shell is a Tauri v2 application with a Rust-owned local core and a React human projection. Before authentication, its public surface is the five-domain number entrance. After verified routing and domain login, the default product surface becomes **My HoloLake**: overview, knowledge, user code channels, local receipts and system details. Domain servers and private registries remain submerged infrastructure.
+The stage-one shell is a Tauri v2 application with a Rust-owned local core and a React human projection. The default product surface is **My HoloLake**: overview, knowledge, user code channels, local receipts and system details. The five domains and their server fleet remain submerged system infrastructure rather than primary stage-one navigation.
 
 ## Stage-one human projection
 
-The public home surface follows the verified GHS-014 five-lakes visual grammar and presents the five domains as the system entrance. A user does not choose a domain manually: the submitted Guanghu number is resolved and validated first, and only then does HoloLake reveal the login surface belonging to that domain. Domain presentation cannot bypass registry isolation, and internal transport or release details remain under system details rather than dominating the first screen.
+The home surface follows the verified GHS-014 five-lakes visual grammar while applying the current stage-one correction: it is a restrained operating-system workspace, not a slogan page or a five-domain gate. The five named lake themes are token groups only and cannot change layout, copy, routing or authority. Internal transport and release details live under system details rather than dominating the first screen.
 
 The first visible body uses a Rust-owned SQLite kernel under the Tauri app-data directory. A human-confirmed local display name creates one stable local subject and channel exactly once. The internal task/event/receipt kernel remains available for structured agents, but manual task title and purpose fields are not part of the default human surface. Event and receipt chains remain independently SHA-256-linked and fully revalidated before every read or mutation. A local identity is not platform authentication and grants no repository, node, server or deployment authority.
 
-## Zero-point nucleus client runtime
-
-HoloLake embeds a non-visual zero-point nucleus client runtime beneath the human surface. The JD primary node remains the private Fifth Domain body. The enterprise node hosts a strictly isolated public zero-core distribution projection, while logical origin authority remains at the zero point; publication requires both an origin public-scope signature and an enterprise distribution signature. The private body never becomes public update material. Git records durable authoring and evidence; clients consume a bounded signed release manifest rather than treating a repository clone as executable input. At application start, the Rust runtime loads the local protocol, compares the registered remote protocol version in the background, keeps a minimal local receipt, and leaves any unverified update unapplied. User-number verification runs before any future persona-loading path.
-
-This system runtime is not Zhuyuan or another persona subject, and it is not the current model carrier. A valid number does not prove persona binding and does not grant execution or server authority. The current source implements deterministic protocol comparison, explicit-positive number verification and a fail-closed update skeleton. Signed public protocol payload installation, atomic activation, rollback, the separate private Fifth Domain distribution path and persona loading are not yet implemented. Stage one does not expose an internal AI chat, model API configuration or arbitrary remote-code channel. The four-plane routing contract and marketplace publication boundary are defined in `contracts/distribution-plane-router.json`.
-
 ## Native knowledge workspace
 
 The native core owns a separate `knowledge-v1` Git root. It projects a bounded document tree, safe text reads, local search and native folder import into a reading canvas without rendering raw HTML. Folder import ignores symlinks, Git metadata, dependency directories and unsupported files, applies file-count and byte limits, then creates a local Git commit receipt.
@@ -26,41 +20,9 @@ A human may paste a registered Guanghu HTTPS code-channel address or select an e
 
 This product channel is distinct from the under-lake PNCC persona-evidence projection below. It grants local source access only and never grants push, publication, deployment or server authority.
 
-## Public five-domain number routing
-
-The public HoloLake entry shows all five domain vestibules before authentication. A user does not select an authority-bearing domain manually. The submitted user number is sent to the registered internal router, which must return the exact canonical number, a positive registry verdict and one known domain. Only then may HoloLake load that domain's separately registered account and node entry.
-
-The fifth-domain number registry belongs to the private fifth-domain system and is maintained only through its authorized registration path. The four enterprise-domain registries belong on the enterprise root server. Number syntax, a client-supplied domain, a generic successful response or a repository login cannot replace this routing proof. Missing and unavailable enterprise routes fail closed before login.
-
-The fifth-domain root and the future enterprise root both run domain-specific Guanghu OS server runtimes. They are parallel bodies with different controllers, manifests, repositories and responsibility. A Linux host may remain underneath as the subordinate hardware, service and rescue bridge. Ordinary user computers and user-owned remote nodes require only HoloLake and the controlled node runtime, not a replacement operating-system installation.
-
-## GH-PNCC user-native channel
-
-HoloLake 0.4.0 adds the first native user-owned GH-PNCC vertical slice. After the Rust core has resolved a known domain, verified the user number at that domain's registered source and authenticated the account through that domain's entry, it derives a stable opaque repository id and idempotently creates or restores one private application-owned Git repository. The initial committed manifest records the domain, user number, account identity, engine and authority boundary. Repository credentials and passwords are never written to the Git tree or binding record.
-
-The visible shell is HoloLake itself. Git is the durable history engine below it. Forgejo is an optional remote collaboration adapter rather than the product shell, identity kernel or persona. The current slice proves the local repository, initial commit, stable user binding and native browsing projection. It intentionally does not create a remote Forgejo repository, configure a remote, push code, claim persona binding, or grant publication, deployment or reality-execution authority; those actions require a separately registered naming, consent and receipt contract.
-
 ## External programming AI entry
 
-MCP may discover HoloLake, but it does not own continuity. The installed application starts a same-account local broker: a mode-0600 Unix socket on macOS and Linux, or an owner/System-only Named Pipe on Windows. A programming AI opens or resumes a HoloLake-issued local session, then uses the installed executable's `--connector` mode for newline-delimited protocol traffic. Session secrets are stored only as hashes. Events use exact cursors and idempotency keys. The connector reloads the application descriptor after transport loss and never blindly replays an operation whose response is uncertain.
+MCP may discover HoloLake, but it does not own continuity. The installed application starts a user-only Unix socket broker. A programming AI opens or resumes a HoloLake-issued local session, then uses the installed executable's `--connector` mode for newline-delimited protocol traffic. Session secrets are stored only as hashes. Events use exact cursors and idempotency keys.
-
-An authenticated non-visitor connector may now acquire, inspect and explicitly release the existing account-scoped development write lane through that broker. Account, lane and client instance must match the HoloLake session before the bridge mutates. Opening, resuming, acquiring and every authenticated heartbeat return or require a bounded HoloLake work-environment frame. That frame states the HoloLake runtime owner, session cursor, writer match, native GLS runtime, expiry and digest; the external model does not restore protocol prose from chat context. HoloLake projects the same Rust-owned lane state on the system-details page, so a human can distinguish a nearby expression-only visitor from an active development writer. This is a controlled writer handoff, not a general programming tool loop: shell, file patching, build execution, publication and deployment still require later supervised execution organs and separate authorization receipts.
-
-The zero-core protocol layer now compiles the numbered GLS sources pinned to the current REPO-012 commit into a deterministic native registry. The registry inventories every unique numbered source with its path and SHA-256, but only protocols with an explicit typed adapter, event set and dependency-closed projection may execute. Raw protocol prose and arbitrary code carried by a protocol are never executed. The first native enforcement adapter binds GLS-0253 identity and numbering rules to the human-number route, with GLS-0250, GLS-0262 and GLS-0263 as executable dependencies. Unknown namespaces, persona numbers presented as human numbers, missing adapters and unprojected protocols fail closed. The system page reports compiled, executable and not-yet-executable protocol counts without presenting inventory as enforcement.
-
-## Product-embedded GLS protocol kernel
-
-GLS enforcement is part of the HoloLake executable, not a sidecar process on the development computer. Rust embeds the pinned runtime manifest and kernel contract in the application binary. Application startup validates the full executable dependency graph, P1-P6 contract set, deterministic HLDP-NP → GIR compiler self-check and the per-user receipt ledger; a failure prevents normal product startup.
-
-The unified decision API returns only `ALLOW`, `DENY`, `AMBIGUOUS` or `UNVERIFIED` with stable reason codes. Every result, including malformed input and refusal, appends an idempotent SHA-256-linked receipt. The same immediate SQLite transaction also advances the durable protocol state for work orders, time leases, immutable modules, persona lifecycle, isolated runways and broadcast control epochs. Stale transitions, concurrent double-primary claims, cross-owner runway release and immutable digest replacement fail closed; concurrent memory/state versions are retained in a conflict set instead of last-write-wins. Identity never implies permission, stale heartbeats and leases become unknown, work-order proposers cannot self-approve, models remain replaceable inference resources, and temporary capabilities cannot auto-install, publish or deploy.
-
-The P7 native-OS assembly registry is also embedded, but it is not a physical-capability simulator. It records the exact target and source-evidence node for GLS-0836 and GLS-0840–0849. No BS-SH-005 or JD-FD-PRIMARY evidence is relabeled as desktop health; without target-side evidence the assembly stays unverified.
-
-## Circular-lake protocol membrane and nearby AI
-
-HoloLake 0.4.0 places a deterministic protocol membrane in front of the local language inbox. The membrane accepts only strict GLP/1.0 expression envelopes from a HoloLake-issued visitor session. Unknown fields, malformed identifiers, incorrect checksums, oversized content, attachments and command content are rejected before storage. Accepted natural language is an expression receipt only; it never carries execution authority by itself. Intent interpretation remains behind the membrane and cannot weaken its structural admission rules.
-
-External AI on the same computer can discover the running HoloLake broker from a standard application-data descriptor and connect through a user-only Unix socket, without copying a long invitation string. A generic AI receives an expression-only visitor lane. A Guanghu persona connection remains unavailable until separate persona-binding evidence exists. Local-network discovery is deliberately deferred until encrypted transport, explicit human approval, replay protection and revocation are implemented; HoloLake does not expose an unauthenticated TCP listener or advertise a service on the LAN in this release.
 
 ## Dynamic capability routing
 
@@ -84,26 +46,12 @@ Before an update replaces the application, the runtime verifies and keeps one bo
 
 The rollback executor is implemented, but production updater activation remains blocked until the JD controller publishes the exact trust endpoint and public key, the signed release pipeline is evidenced, and the public macOS build is Apple-notarized.
 
-## JD PNCC human projection
-
-HoloLake 0.3.0 includes a live, read-only projection of the PNCC resident runtime on `JD-FD-PRIMARY`. The native shell invokes the computer's pre-registered dedicated SSH alias and asks the server only for its loopback `127.0.0.1:3923/v1/status` document. The response is schema-bounded to the exact node and persona, refuses any claim that the carrier is bound or that model/reality execution is active, and never returns a repository path, repository content, credential, or write authority. No public PNCC endpoint is created. An unavailable bridge is displayed as unavailable rather than replaced by cached evidence.
-
 ## Release pipeline
 
-`npm run release:macos -- release/inputs/<version>.json` is the only product-owned macOS release entry. It fails before building unless the embedded trust contains the exact registered HoloLake HTTPS endpoint and updater public key, the immutable `v<version>` tag equals the clean `main` head, and the Developer ID plus Tauri updater-signing material are supplied at runtime. Apple notarization can run either through Tauri's Apple ID/API credential flow, or through the two-step Xcode Organizer flow already owned by the local Apple developer account: append `prepare-xcode` to build, verify the updater signature, and create a source-hash-bound `.xcarchive`; after Xcode reports `Ready to distribute`, export the notarized app and append `finalize-xcode <export-directory-or-app>` to bind the exported executable back to that archive, require the app's stapled ticket and Gatekeeper acceptance, regenerate and sign the updater archive, create a Developer ID-signed DMG containing that notarized app, and write the release broadcast and receipts. A protected updater-key path is materialized only into child processes; neither the private key nor its password is printed or copied into source. The Xcode flow does not claim that the outer DMG itself has an Apple ticket unless its own Gatekeeper and stapler checks pass.
+`npm run release:macos -- release/inputs/<version>.json` is the only product-owned macOS release entry. It fails before building unless the embedded trust contains the exact registered HoloLake HTTPS endpoint and updater public key, the immutable `v<version>` tag equals the clean `main` head, and the Developer ID, Tauri updater-signing and Apple notarization credential sets are supplied at runtime. The pipeline runs all product and Rust gates, creates updater artifacts through a temporary Tauri override, then requires strict code-signature verification, Gatekeeper acceptance and stapled Apple notarization before writing the HoloLake broadcast and receipts.
 
 Generated packages, private release inputs and credentials are not committed. The pipeline never uploads or activates a release; its terminal artifact is a bounded folder ready for a separately authorized JD-controller upload and server-owned readback receipt.
 
-## Numbered-root module admission
-
-HoloLake 0.5.0 is the clean numbered-root base. The compiled 0.4.1 desktop application and the divergent dirty source worktree are read-only donors, not merge bases. Their old numbered-operation runtime is explicitly superseded, and mutations to shared files such as `src/main.tsx` or `src-tauri/src/lib.rs` are never accepted as a unit.
-
-Each donor capability receives a candidate coordinate, but no permanent runtime module number, until one isolated admission cycle has reviewed provenance and permissions, allocated numbered IPC module/target/operation coordinates, implemented an adapter without raw Tauri invoke, passed negative-route and data tests, and produced installed mount, restart, unmount and rollback receipts. The admission order and candidate inventory are recorded in `contracts/module-donor-admission-registry.json`.
-
-The module-package runtime is now the shared admission executor. It accepts an exact detached-minisign `.ghmod` artifact, validates the package and its compatibility/permission manifest, stores it inside the authenticated account, and advances only through numbered install, mount, self-test, unmount and rollback operations. Lifecycle state and receipts are durable SQLite records; unmount never removes user data. A package is declarative and selects a host-registered adapter: repositories, native binaries and arbitrary webview JavaScript are not executable module inputs. Public lighthouse numbers remain unavailable until a candidate completes its own installed acceptance; private channel packages use a separate local number class.
-
-The admitted web-novel family uses that one lifecycle rather than the donor's private installer. Its signed base module owns account-local works, volumes, chapters, versions, story objects, editorial workflow, import and author activity. Outline, story-grid, story-world and delivery are four separately signed official numbers; each advanced mutation checks its own exact `ACTIVE` record before touching the shared story graph. The donor's four legacy manifests remain byte-exact test fixtures only and have no numbered IPC route. Installed acceptance reopened the existing 504-chapter novel, 50-chapter outline and 75-episode script in place, then created a separate one-chapter acceptance work, scene, grid field and timeline event and read all of them back after process restart.
-
 ## Stage-one convergence verdict
 
 The Tauri source in this directory is the only future HoloLake desktop mainline. An installed build of it is an acceptance candidate, not a separate product line and not proof that stage one exists. The Electron 0.8.0 product and the legacy Tauri/platform sources remain read-only UX, behavior, engineering and protected-data donors until inventory, backup, readback, reversible migration rehearsal and signed installed-runtime acceptance all pass.

product-source/hololake-native-desktop/docs/DISTRIBUTION-PLANES-AND-MODULE-MARKETPLACE.md

@@ -1,53 +0,0 @@
-# HoloLake distribution planes and public module marketplace
-
-HoloLake has four independent distribution planes. A Git repository is the durable authoring and evidence layer; it is not the client update transport. Every release carries an explicit signed scope. The system may reject a mismatch, but it never guesses whether BingShuo meant public or private.
-
-## Four planes
-
-1. `PUBLIC_ZERO_CORE_PROTOCOL` publishes declarative language, numbering, compatibility and bounded migration rules from an isolated public projection on `GH-CVM-MAIN-PROD-01`. Its logical authority still originates at the zero point and requires BingShuo's exact-candidate public-scope approval during the current transition. The enterprise distributor adds a second independent distribution signature. A client verifies both, stages, self-tests and atomically activates a valid update without asking every device owner to approve an operating-system protocol update. It still shows a human-readable receipt.
-2. `PRIVATE_FIFTH_DOMAIN` remains confined to `DOM-FIFTH-0001`, its bound owner and explicitly authorized private nodes. It uses a different namespace and signer and can never flow into the public stream by inference.
-3. `PUBLIC_ENTERPRISE_MODULE_CATALOG` is produced on `GH-CVM-MAIN-PROD-01`. Five responsibility repositories may feed one reviewed `Guanghu Channel` aggregate, but only tested, numbered and signed declarative packages enter the catalog. Clients synchronize the small catalog index automatically. A selected module is downloaded and installed only after the human reviews its permissions.
-4. `APPLICATION_BINARY` updates HoloLake itself through the separately signed and platform-notarized updater. Personal Apple signing is a transition state; later organization signing must preserve the updater trust transition rather than silently replacing it.
-
-## Lake-lamp protocol
-
-The visible "lamp" is a tiny signed manifest containing a monotonic epoch and content root. HoloLake performs HTTPS conditional checks at application start, after network resume and on a bounded jittered timer. `ETag` and `If-None-Match` make the no-change path nearly empty. A full repository clone is not required to learn that something changed.
-
-For a public zero-core protocol update, the client verifies the exact source, plane-specific signature, content root, monotonic version and host compatibility; downloads into isolation; rejects executable or out-of-scope material; runs a deterministic self-test; switches one current pointer atomically; keeps the last-known-good version; and records a local receipt.
-
-For a module update, only the catalog index is automatic. Installation remains a human action because a module may request access to local files, knowledge, network, channel data or execution adapters.
-
-## Marketplace publication
-
-```text
-responsibility repository
-→ explicit release envelope
-→ isolated build and tests
-→ lighthouse number registration
-→ exact candidate human approval
-→ enterprise module signature
-→ immutable package and catalog entry
-→ signed catalog-root advance
-→ HoloLake catalog refresh
-→ human selects module
-→ permission review
-→ local install, mount, self-test and receipt
-```
-
-The user's computer may maintain an application-owned content-addressed cache, but it does not execute a cloned repository. HoloLake renders catalog metadata for humans and passes the downloaded `.ghmod` package to the existing signed module lifecycle runtime.
-
-## Fifth Domain to public zero-core navigation
-
-`JD-FD-PRIMARY` remains the physical home of the private Fifth Domain and Eternal Lake Heart. HoloLake may show the public zero-core management entrance inside BingShuo's Fifth Domain navigation, but opening it creates a separate session on `GH-CVM-MAIN-PROD-01`.
-
-The transition uses a short-lived, one-time ticket bound to BingShuo's human number, the current HoloLake instance, the enterprise node and the public zero-core resource. A password is never forwarded or reused. The ticket grants neither enterprise four-domain authority nor access from the enterprise server back into the private Fifth Domain. Leaving the zero-core management channel destroys that enterprise session and restores the already-open private session.
-
-## Current reality boundary (2026-08-19)
-
-- The zero-point client now implements HTTPS conditional lamp checks, exact bounded downloads, two independent Ed25519 signatures, monotonic epoch/version enforcement, content-root verification, atomic activation, previous-release retention and a hash-chained local receipt. Production remains fail-closed because the two real public keys and the enterprise lamp endpoint have not yet been provisioned.
-- The module runtime already verifies signatures and supports install, mount, self-test, unmount and rollback for bundled packages.
-- The public marketplace registry and remote package fetch path are absent.
-- The enterprise server currently exposes two Gitea repositories, `bingshuo/hololake-world` and `bingshuo/lighthouse`; the proposed five-source `Guanghu Channel` aggregate does not yet exist.
-- The enterprise node does not yet expose the isolated public zero-core projection or the JD-to-enterprise one-time management handoff.
-
-The machine contract is `contracts/distribution-plane-router.json`.

product-source/hololake-native-desktop/docs/GLS-NATIVE-RUNTIME-IMPLEMENTATION-PLAN-20260817.md

@@ -1,228 +0,0 @@
-# GLS 原生协议运行层实施规划
-
-状态：`P0_TO_P7_DESKTOP_PRODUCT_KERNEL_IMPLEMENTED · INSTALLED_RUNTIME_ACCEPTANCE_PENDING`
-
-核验时间：2026-08-17（Asia/Shanghai）
-
-线上事实源：
-
-- 第五域代码频道：`bingshuo/guanghu-ice-heart`
-- REPO-012 `main`：`d5b1111fcaccaccf025070e531631f2b3cbb00cd`
-- Git tree：`5a09f084fffee56d90599e69038c8335871ea04f`
-- 第五域节点：`JD-FD-PRIMARY`
-- 公开远端 HEAD 与第五域 Forgejo 裸仓库 HEAD：一致
-- 本规划只描述产品工程路线；协议登记、源码实现、构建制品、发布、部署、激活和健康分别验收
-
-## 1. 线上注册事实
-
-`gls/GLS-PROTOCOL-REGISTRY.json` 当前登记：
-
-- `existing_registered`：19
-- `registered_draft_protocols`：33
-- 33 份草案中 `implementation: NOT_STARTED`：21
-- 其余 12 份带实现证据，但证据多属于 BS-SH-005 的特定物理实验能力，不能直接推定 HoloLake 客户端或 JD-FD-PRIMARY 已运行
-
-REPO-012 的 `gls/` 树中另有 75 个唯一编号 `.hdlp` 源。协议注册表、`GLS-ENTRY`、`SOURCE-MANIFEST`、架构目录和 routing 映射并未收敛为一份可执行注册真相：
-
-- 注册表唯一编号：52
-- 草案依赖涉及唯一编号：57
-- 草案引用但未进入该注册表的依赖：19
-- 草案引用但没有可直接定位的编号 `.hdlp` 正本：24
-- 编号 `.hdlp` 存在但没有进入该协议注册表：31
-
-因此，当前 `REGISTERED` 只能证明编号与文档登记，不能直接作为运行时激活条件。
-
-## 2. 现有依赖图的阻塞问题
-
-草案的 `depends` 同时混用了概念引用、类型引用、构建依赖、运行依赖、启动依赖和恢复依赖。若直接按包管理器依赖处理，会形成三个强连通环：
-
-1. `GLS-0130 GLC ↔ GLS-0131 GIR`
-2. `GLS-0310 / GLS-0803 / GLS-0819 / GLS-0827 / GLS-0840 / GLS-0841`
-3. `GLS-0843 / GLS-0845 / GLS-0846 / GLS-0847 / GLS-0848 / GLS-0849`
-
-处理规则：
-
-- 将 `depends` 升级为带类型的边：`NORMATIVE_REFERENCE`、`SCHEMA_IMPORT`、`BUILD_REQUIRES`、`RUNTIME_REQUIRES`、`BOOT_REQUIRES`、`RECOVERY_REQUIRES`、`EVIDENCE_ONLY`。
-- 只有 `RUNTIME_REQUIRES` 和所选运行目标相关的启动边进入激活拓扑。
-- GIR 规范不运行依赖 GLC；GLC 只消费 HLDP-NP 并输出符合 GIR schema 的对象。
-- 内核、硬件、调度、生命周期和广播塔先抽出稳定 capability interfaces，再由实现提供，避免对象层互相启动。
-- 原生恢复、布局、内容仓、摄入、安全和回看拆成静态布局合同、摄入流水线、审查流水线和恢复服务四层。
-- 未消除的运行环、缺失正本、冲突权威或漂移版本一律阻止激活。
-
-## 3. 目标运行架构
-
-```text
-REPO-012 协议源
-  → 注册对账与权威解析
-  → 只读、固定提交、带摘要的 Protocol Bundle
-  → Bootstrap Compiler 静态校验
-  → 类型化 Contract IR
-  → 原生适配器 / 状态机 / 路由表 / 守卫
-  → HoloLake Protocol Kernel
-  → 允许 / 拒绝 / 状态变更
-  → GLP 可验证回执与 GLOW 只追加见证
-```
-
-运行时采用五类确定性器官：
-
-1. `Schema/Codec`：验证消息、身份、上下文、工单、回执和模块制品。
-2. `Guard/Policy`：返回 `ALLOW / DENY / AMBIGUOUS / UNVERIFIED` 与稳定 reason codes。
-3. `Router`：根据已验证主体、目标、域、频道、能力和版本确定唯一去向。
-4. `State Machine`：只允许协议声明的状态迁移，并保存前后状态与幂等键。
-5. `Evidence/Receipt`：为每次裁决记录输入摘要、协议包摘要、适配器、决定、证据和目标侧核验。
-
-自然语言原文和协议中任意代码永不在产品运行时直接执行。模型只能提交请求或生成候选计划，不能改写裁决、伪造权限或绕过状态机。
-
-## 4. Bootstrap 与自举边界
-
-第一版编译器必须由普通、可审计的 Rust/TypeScript 工程实现，不能要求尚未实现的 GLC 自己编译自己：
-
-1. 解析编号、版本、状态、来源、权威、依赖和合同类型。
-2. 校验文件摘要、唯一编号、来源提交、注册一致性和依赖闭包。
-3. 将协议投影为受限 Contract IR，不接受自由脚本。
-4. 生成 JSON Schema、Rust 类型、静态路由表、状态机表和测试向量。
-5. 在 HLDP-NP、GLC、GIR 稳定后，再用同一黄金测试集完成自举一致性验证。
-
-## 5. 分阶段实施
-
-### P0 · 注册对账和可执行清单
-
-- 建立 `GLS-RUNTIME-MANIFEST/v2`，合并协议注册表、`GLS-ENTRY`、`SOURCE-MANIFEST`、架构目录和 routing 的事实，但保留每条来源及冲突。
-- 每个协议增加：`authority_source`、`maturity`、`contract_kind`、`dependency_edges`、`target_runtime`、`implementation_evidence`、`activation_state`。
-- 状态严格区分：`DISCOVERED`、`REGISTERED`、`COMPILED`、`ADAPTED`、`TESTED`、`PUBLISHED`、`DEPLOYED`、`ACTIVE`、`HEALTHY`。
-- 当前 75 份发现对象继续可见；未完成对账者保持 `INVENTORIED_NOT_EXECUTABLE`。
-
-验收：零重复编号、零未分类依赖、零运行环、零缺失摘要；同一提交重复编译字节一致。
-
-### P1 · 最小 GLP 合同内核
-
-优先实现：
-
-- `GLS-0301` Message Envelope
-- `GLS-0302` Identity Reference
-- `GLS-0303` Context
-- `GLS-0306` Receipt
-- 已有首批投影：`GLS-0250 / 0253 / 0262 / 0263`
-
-交付：类型化 schema、严格 codec、身份与权限分离守卫、统一裁决 API、哈希链回执账本。
-
-验收：缺字段、过期、错误域、身份冲突、未知权限、摘要漂移全部失败关闭；每次拒绝也必须产生回执。
-
-### P2 · 会话、工单和在线状态
-
-实现：
-
-- `GLS-0307` Heartbeat
-- `GLS-0309` Work Order
-- `GLS-0842` HoloLake Live Session
-- `GLS-0311` GLOW Witness 的最小只追加投影
-
-验收：登记、测试、发布、部署分阶段；旧心跳不能证明当前健康；断联缓存不得冒充线上状态；工单提出者不能自批。
-
-### P3 · 时间、记忆和状态一致性
-
-实现：
-
-- `GLS-0304` Memory Sync
-- `GLS-0308` State Sync
-- `GLS-0827` Persona Time Continuity
-
-交付：单调事件序列、当前主实例租约、冲突保留、幂等重放、检查点与防双主写。
-
-验收：并发状态不使用最后写入覆盖；租约过期回到未知；冲突双方版本均保留。
-
-### P4 · 模块、生命周期和调度
-
-实现：
-
-- `GLS-0710` GMP immutable module backpack
-- `GLS-0803` AGE execution-body lifecycle
-- `GLS-0819` runway scheduler
-- `GLS-0310` broadcast tower control plane
-
-交付：签名不可变模块、完整生命周期状态机、资源轨道、唯一主控纪元、停止/清理/回滚闭环。
-
-验收：人格主体与执行体进程分离；模块只能运行固定摘要；任务结束资源归零；跨频道读取被阻止。
-
-### P5 · 外部适配、模型路由和临时能力
-
-实现：
-
-- `GLS-0709` UAP
-- `GLS-0708` GMRP
-- `GLS-0828` PEN
-
-所有外部 API、CLI、MCP、数据库和模型先被 UAP 转译成 P1/P2 合同；模型只作为可替换推理设备；PEN 只在隔离环境产生临时能力，不能自动永久安装、发布或部署。
-
-### P6 · 编译体系自举
-
-实现：
-
-- `GLS-0411` HLDP-NP
-- `GLS-0130` GLC
-- `GLS-0131` GIR
-
-用 Bootstrap Compiler 的固定语料和黄金 IR 做双编译一致性验证。只有自举输出、原生适配器输出和回执一致，才允许 GLC 成为正式协议编译入口。
-
-### P7 · 原生 OS 专用协议装配
-
-`GLS-0836 / 0840–0849` 按节点能力装配，不在桌面端模拟原生物理证据：
-
-- 桌面 HoloLake 只消费公开合同、会话、回执和健康投影。
-- JD-FD-PRIMARY、BS-SH-005 或未来原生节点分别提供 capability implementation 和目标侧回执。
-- 旧 BS-SH-005 物理回执只证明原节点与原版本的能力，不能自动迁移为 JD 或桌面健康。
-
-## 6. 协议更新与激活
-
-第五域只发布不可变、签名、固定提交的 Protocol Bundle。HoloLake 使用单向接收器：
-
-```text
-FETCH → VERIFY SIGNATURE → VERIFY HASH/SCHEMA → COMPILE → DRY RUN
-→ COMPATIBILITY GATE → HUMAN IMPACT GATE → ATOMIC ACTIVATE → HEALTH
-```
-
-- 更新包不能携带任意可执行脚本。
-- 激活前保存当前 bundle、状态快照和回滚点。
-- 权利、隐私、数据、安装、费用或责任变化必须产生可见确认。
-- 健康失败自动回到上一个已验证 bundle，并保留失败回执。
-- 协议源更新权、产品实现权和现实执行授权继续分离。
-
-## 7. 统一裁决回执
-
-每次协议裁决至少记录：
-
-```yaml
-protocol_decision_receipt:
-  receipt_id:
-  request_id:
-  event_kind:
-  subject_id:
-  target_id:
-  protocol_bundle_commit:
-  protocol_bundle_sha256:
-  protocol_set:
-  adapter_id:
-  input_digest:
-  decision: ALLOW | DENY | AMBIGUOUS | UNVERIFIED
-  reason_codes: []
-  state_before_digest:
-  state_after_digest:
-  evidence_refs: []
-  time_authority:
-  idempotency_key:
-  signer:
-```
-
-没有目标侧证据时只能返回 `UNVERIFIED`；界面颜色、模型回答、命令退出码或单条日志均不构成完成证明。
-
-## 8. 当前 HoloLake 分支的承接关系
-
-`d6b1290` 完成了 75 份编号协议的确定性发现登记，并为 `GLS-0250 / 0253 / 0262 / 0263` 建立首批原生适配器。P0 随后已把运行清单升级为 v2：四份登记源分别固化摘要，75 份协议全部取得登记解释，旧依赖与显式运行依赖分离，三组旧环只进入审计面而不能进入执行图。
-
-P1–P6 已按顺序实现为 HoloLake Rust 原生器官：统一裁决 API 对消息、身份、上下文、会话、心跳、工单、见证、时间、记忆、状态、模块、生命周期、资源轨道、广播主控、外部适配、模型路由、临时能力和 HLDP-NP/GIR 编译执行确定性守门；所有裁决进入用户侧 SQLite 哈希链。工单阶段、时间租约、不可变模块、人格执行体生命周期、隔离跑道与广播塔主控纪元和裁决回执在同一原子事务中推进；旧状态重放、租约内双主、越权释放和同编号换摘要都失败关闭，并发记忆/状态版本写入冲突集而非互相覆盖。GLC Bootstrap Compiler 对同一黄金程序执行双编译一致性检查，不解析自由自然语言、不执行生成代码。
-
-P7 已实现桌面产品侧装配注册表，但没有伪造物理能力：GLS-0836 与 GLS-0840–0849 全部保留目标节点、来源证据节点和当前装配状态，`ACTIVE_HEALTHY` 数量固定为 0，直到目标节点自身给出版本绑定回执。协议合同、运行图、状态机和编译器通过 Rust 编入 HoloLake 应用；用户数据与裁决回执留在各自应用数据目录。
-
-当前验收数字：75 份编号源、183 条已分型来源依赖、0 条未分类依赖、25 份可执行投影、50 份库存不可执行源、P1–P6 共 21 份新原生器官、P7 共 11 项失败关闭装配边界。
-
-这保证“已注册”不会被误报为“系统正在运行”，也保证每次新增执行协议都有可重复编译、明确守卫和真实回执。

product-source/hololake-native-desktop/docs/adr/0003-public-domain-router-and-user-native-gh-pncc.md

@@ -1,24 +0,0 @@
-# ADR 0003: Public number routing precedes a HoloLake-owned GH-PNCC
-
-- Status: accepted; public routing shell and local GH-PNCC slice implemented
-- Date: 2026-08-16
-
-## Context
-
-HoloLake is a public product for five independent domains. The fifth domain is private, while the other four domains belong to the enterprise reality body. A common client cannot ask every user to log in to the fifth-domain Forgejo, and it cannot infer authority from the visual shape of a number.
-
-Each trusted user also needs one durable code channel bound to the registered number and account. Git already supplies the right history engine, but neither a generic Git browser nor a Forgejo page is the HoloLake product shell.
-
-## Decision
-
-The unauthenticated home shows the five public domain vestibules and one number entry. The user submits a number without choosing a domain. A registered internal router must resolve that number to one known domain and obtain an explicit verdict from the responsible registry. The fifth-domain registry is maintained inside the authorized fifth-domain system. The enterprise four-domain registries are served by the enterprise root server. Only a successful exact route may reveal the selected domain and load its own account and node login.
-
-After domain routing, number verification and domain-specific account authentication, the Rust core derives a stable opaque repository id from the trusted tuple and idempotently creates or restores a private Git repository. HoloLake owns the human projection. Forgejo remains an optional remote collaboration adapter. Credentials never enter the repository, and local channel creation does not claim persona binding or remote authority.
-
-## Server boundary
-
-The enterprise root server runs an enterprise-domain Guanghu OS runtime, not a clone of the fifth-domain body. Its controller, manifests, repositories, registries and responsibility are independent. Linux may remain the subordinate hardware/service/rescue bridge. Ordinary personal nodes install the HoloLake node runtime rather than replacing their operating system.
-
-## Current reality
-
-Only the fifth-domain login adapter is currently provisioned. Enterprise cards are public and visible, but their account login remains fail-closed until an enterprise root server, signed route registration, number registries, node registration and domain handoff endpoints exist. The implementation must display this as unavailable, not simulate a successful login.

product-source/hololake-native-desktop/docs/adr/0004-circular-lake-protocol-membrane-and-nearby-ai-discovery.md

@@ -1,37 +0,0 @@
-# ADR 0004: Circular-lake protocol membrane and nearby AI discovery
-
-- Status: accepted for HoloLake 0.4.0
-- Date: 2026-08-16
-
-## Context
-
-External AI needs a simple way to find HoloLake and deliver language without turning MCP, a copied connection ticket, an Agent framework or a model host into the product's authority root. A language-only boundary must also remain enforceable when the sender is malformed or adversarial; asking a persona to infer every sender's motive is neither deterministic nor a security boundary.
-
-## Decision
-
-The native Rust core owns a circular-lake membrane before the language inbox. It accepts a bounded, strict GLP/1.0 expression envelope only after HoloLake issues an expression-only visitor session. Protocol-invalid input is rejected before persistence or semantic interpretation. Accepted language creates a receipt but no execution authority.
-
-The first discovery scope is the same logged-in operating-system account on one computer. A standard application-data descriptor points to a Unix socket restricted to that user. Generic AI may open an expression-only visitor lane. A Guanghu persona route requires separate verified persona-binding evidence and is not implemented by relabelling a visitor.
-
-Local-network discovery is not enabled in this slice. It requires an encrypted mutually authenticated transport, explicit human approval, expiry, replay protection, revocation and visible connection receipts before any mDNS-style advertisement or LAN listener may be introduced.
-
-MCP remains a compatibility and recovery adapter. It is not continuity, identity, memory or execution authority.
-
-## Why
-
-This preserves the user's "round lake" idea at an engineering boundary: non-protocol traffic never reaches the language world, while valid language still remains language rather than executable permission. The same-device descriptor provides Wi-Fi-like discovery where the operating system already supplies a trustworthy user boundary. Deferring LAN broadcast avoids falsely treating physical proximity or discoverability as authorization.
-
-## Rejected alternatives
-
-- Exposing an unauthenticated TCP or mDNS service now: discovery would outpace transport security and consent.
-- Letting natural-language intent classification replace structural validation: probabilistic interpretation cannot be the outer security boundary.
-- Treating any accepted message as a command: expression and execution authority must remain separate.
-- Making MCP or a third-party Agent framework the continuity owner: adapters are replaceable tools beneath HoloLake.
-
-## Evidence
-
-- `contracts/circular-lake-membrane.json`
-- `contracts/nearby-ai-discovery.json`
-- `src-tauri/src/circular_lake_membrane.rs`
-- `src-tauri/src/direct_local_broker.rs`
-- `scripts/circular-lake-membrane.test.mjs`

product-source/hololake-native-desktop/docs/adr/0005-authenticated-development-lane-projection.md

@@ -1,34 +0,0 @@
-# ADR 0005: Authenticated development lane projection
-
-- Status: accepted for the next HoloLake desktop candidate
-- Date: 2026-08-17
-
-## Context
-
-The same-device HoloLake broker can already discover an external AI, open an expression-only visitor session, and resume a HoloLake-issued authenticated session. The local development bridge can already enforce one writer per account, but it is reachable only from the WebView command surface. As a result, an external programming carrier can be visibly connected while still being unable to acquire the HoloLake-owned development lane. The system page also cannot distinguish a connected visitor from an active development writer.
-
-## Decision
-
-Expose acquire, inspect, and release operations for the existing local development lane through the user-only Unix broker. Every operation requires a non-visitor HoloLake session. The session account must equal the lane account, the session lane must equal the requested write lane, and the session client instance must equal the requested writer instance. A generic expression-only visitor is rejected before any lane mutation.
-
-Project the active lane and writer on the HoloLake system-details page by reading the same Rust-owned bridge state. The projection does not create authority and is not a second state store.
-
-This slice establishes the controlled writer handoff only. It does not yet provide a general shell, file mutation, patch, build, deployment, model, persona binding, or reality-execution engine.
-
-## Why
-
-The user needs to see whether development is merely connected or has actually switched into HoloLake's single-writer environment. Reusing the existing session and writer kernels closes that gap without turning socket discovery, MCP, or a visitor message into execution authority.
-
-## Rejected alternatives
-
-- Letting any same-device visitor acquire a write lane: discovery and expression are not authorization.
-- Maintaining a separate UI-only development status: it would create a second truth source.
-- Calling the lane handoff a complete native development container: the programming tool loop and supervised execution engine remain unimplemented.
-
-## Evidence
-
-- `src-tauri/src/direct_local_broker.rs`
-- `src-tauri/src/direct_local_session.rs`
-- `src-tauri/src/local_development_bridge.rs`
-- `src/main.tsx`
-- `contracts/local-development-bridge.json`

product-source/hololake-native-desktop/docs/adr/0006-compiled-gls-protocol-runtime.md

@@ -1,46 +0,0 @@
-# ADR 0006: Compiled GLS protocol runtime
-
-- Status: accepted for the next HoloLake desktop candidate
-- Date: 2026-08-17
-
-## Context
-
-REPO-012 contains dozens of numbered GLS protocol sources. Human-readable source is necessary for authorship, review and causal meaning, but asking a model to reread protocol prose for every operation does not make the software obey the protocol. It also creates non-deterministic behavior and makes it impossible to distinguish a protocol that is merely present from one that is enforced by the running product.
-
-## Decision
-
-Compile the current numbered GLS sources into a deterministic v2 runtime manifest pinned to an exact REPO-012 commit. Every selected source records its stable GLS number, path and SHA-256. Duplicate historical source locations are resolved by a deterministic source preference, while alternate-source counts remain visible. The compiler also reconciles the protocol registry, GLS entry, source manifest, architecture catalog and routing references, preserving their independent source hashes and rejecting registration conflicts.
-
-Legacy `depends` arrays are not silently interpreted as runtime edges. Bootstrap Compiler v1 classifies every source edge as `NORMATIVE_REFERENCE`, `SCHEMA_IMPORT`, `BUILD_REQUIRES`, `BOOT_REQUIRES`, `RECOVERY_REQUIRES` or `EVIDENCE_ONLY`; all remain audit-only. Only dependencies declared by an explicit executable projection enter the runtime graph as `RUNTIME_REQUIRES`; that graph must be acyclic and dependency-closed. The current exact source produces 183 typed source edges and zero unclassified edges.
-
-An executable projection requires an explicit native adapter, event kinds, dependency list and fail-closed behavior. The compiler rejects missing executable dependencies and dependency cycles. The native runtime revalidates schema, source commit, counts, hashes, adapters and dependency closure before returning a protocol set to an organ.
-
-Protocol prose is never evaluated as code. A protocol without an explicit projection remains `INVENTORIED_NOT_EXECUTABLE`. The product now embeds 25 dependency-closed projections: four P0 foundation contracts and 21 P1-P6 protocol organs. They provide the strict GLP codec, identity/context guards, hash-chain decision ledger, session/heartbeat/work-order/witness rules, causal time/memory/state guards, module/lifecycle/scheduler/control state machines, external/model/temporary-capability boundaries and the restricted HLDP-NP → GIR bootstrap compiler.
-
-The kernel is an application-start prerequisite. If its embedded contract, projection closure, deterministic compiler self-check or local receipt/state ledger cannot load, HoloLake fails closed during startup. Receipt append and state-machine transition use one immediate SQLite transaction, so stale work-order/lifecycle transitions, conflicting time or broadcast owners, immutable module replacement and cross-owner runway release cannot race past the guards. Concurrent memory/state inputs are stored as conflicts rather than overwritten. The ledger stores per-user receipts and projections in application data; protocol authority and enforcement code are compiled into the signed application bundle and do not depend on the development machine.
-
-P7 is intentionally different: the application embeds an 11-item target capability assembly registry for GLS-0836 and GLS-0840–0849, but records zero desktop physical capabilities as verified. Evidence from BS-SH-005 or JD-FD-PRIMARY is never transferred into desktop health. A target becomes active only after its own version-bound evidence exists.
-
-## Why
-
-This creates the same hard boundary that a real API presents: a caller must satisfy the machine contract whether or not it has read the explanatory documentation. It also preserves factual honesty. HoloLake reports 75 inventoried sources, 25 native enforcement projections and 50 non-executable sources separately.
-
-## Rejected alternatives
-
-- Injecting all GLS prose into every model call: behavior would remain prompt-dependent and context growth would be unbounded.
-- Treating every inventoried source as automatically active: source presence is not runtime enforcement.
-- Executing scripts embedded in protocol documents: it would turn the authority source into an arbitrary-code supply chain.
-- Hand-copying protocol decisions into unrelated organs: duplicated rules would drift and no common protocol set could be written into receipts.
-- Blocking the product until all protocols are executable: incremental dependency-closed projections can be verified without overstating the remaining surface.
-
-## Evidence
-
-- `scripts/compile-gls-runtime-registry.mjs`
-- `contracts/gls-executable-projections.json`
-- `contracts/gls-runtime-registry.json`
-- `src-tauri/src/gls_protocol_runtime.rs`
-- `src-tauri/src/gls_protocol_kernel.rs`
-- `src-tauri/src/gls_bootstrap_compiler.rs`
-- `contracts/gls-native-runtime-kernel.json`
-- `src-tauri/src/zero_core_numbering.rs`
-- `scripts/gls-protocol-runtime.test.mjs`