CODE-DESIGN-ANA-SEMI-ROOT-PREFLIGHT-ORCHESTRATION-V007-V027

• plan_id: CODE-DESIGN-ANA-SEMI-ROOT-PREFLIGHT-ORCHESTRATION-V007-V027
• role_instance_id: dev.developer.ana.cai
• created_at: 2026-07-27T14:18:00+08:00
• predecessor_plan: CODE-DESIGN-ANA-SEMI-ROOT-PREFLIGHT-ORCHESTRATION-V007-V026 / 20353/db54f86468f33c69878fbf3839b9aea5005d267171f94a4c3af0bbf65ee3946c
• predecessor_review: AUDIT-DEV-ANA-SEMI-ROOT-PREFLIGHT-ORCHESTRATION-V007-PYTHON-STAGE-S-PREIMAGE-EVIDENCE-PLAN-V026=HOLD/3/3 / 257260/bb912f587fe2c2e214e1135fd27c66d766b98eb0663c6ed5b099768440404e95 / line 1937
• triggering_blocks: BLOCK-V026-01,BLOCK-V026-02,BLOCK-V026-03
• status: PENDING_INDEPENDENT_EXACT_PREIMAGE_SOURCE_FREEZE_PLAN_REVIEW
• source_materialization_authorization: NOT_ISSUED
• Stage_V_authorization: NOT_ISSUED
• database_authorization: NOT_ISSUED

V027 放弃 V026 的运行时 evidence-reader。未来 Stage S 不再启动 PowerShell/Python/任何外部进程，也不通过 command line/stdout/stdin/environment/temp file 运输源码；Y01—Y04 的完整正文、bytes、SHA-256 与 RFC4648 Base64 在本计划中先行冻结并接受独立审核。未来 management 授权只能逐字投递这些预审字节，Codex apply_patch Add File 是唯一写入机制。

V025 的两阶段隔离不变：Stage S 只冻结源码；独立静态实现审核 PASS/0/0 后才可另立 Stage V；Stage V 通过后才可能另立 root identity/grant database preflight。V027 本身不授权其中任何执行。

1. Stage S 唯一目标与顺序

• create order：Y01→Y02→Y03→Y04；首次成功 Y01 Add File 消费未来新授权。
• process count：PowerShell/Python/csc/node/mysql/mysql_config_editor/query/database=0/0/0/0/0/0/0/false。
• run/Y05—Y08/formal target=0。
• no overwrite/delete/truncate/rename/repair/backfill/retry/resend/A002/replacement/renewal。
• 每次 Add File 后仅使用 Codex 已有文件读取能力核对普通文件/encoding/bytes/hash；该读取不启动 shell 或候选进程。若产品侧无法提供可观察的无进程文件读取结果，必须在 dispatch 前 STOP，不得临时增加 reader。

2. Y01 exact preimage

以下 code fence 内正文加一个 LF 是唯一 Y01 bytes；不得解释、格式化或重编码。

from __future__ import annotations

import base64
import ctypes
import ctypes.wintypes as wintypes
import datetime as dt
import hashlib
import json
import os
import pathlib
import re
import threading
from collections.abc import Callable, Iterable, Mapping, Sequence
from typing import Any

WINDOW_SCHEMA = "ANA.SEMI.AUTHORIZATION.WINDOW.V001"
WINDOW_TEST_SCHEMA = "ANA.SEMI.AUTHORIZATION.WINDOW.TEST.V001"
SELECTOR_SCHEMA = "ANA.SEMI.PROCESS.SELECTOR.RESULT.V001"
PREFLIGHT_SCHEMA = "ANA.SEMI.PRECONSUMPTION.RESULT.V002"
TIME_RE = re.compile(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{7}[+-]\d{2}:\d{2}$")
PREFLIGHT_KEYS = (
    "authorization_id", "authorized_at_utc_ticks", "authorized_outer_started",
    "candidate_run_exists", "credential_access", "database_connection_performed",
    "exception_type", "expires_at_utc_ticks", "finished_at",
    "history_hash_mismatch_count", "invocation_count", "materialized_target_count",
    "network_access", "now_utc_ticks", "preflight_stage", "related_process_count",
    "result_schema_id", "started_at", "status", "stop_code",
    "target_existing_count", "uncertain_field",
)


def _ticks(value: dt.datetime) -> int:
    utc = value.astimezone(dt.timezone.utc)
    origin = dt.datetime(1, 1, 1, tzinfo=dt.timezone.utc)
    delta = utc - origin
    return ((delta.days * 86400 + delta.seconds) * 10_000_000) + delta.microseconds * 10


def _parse_offset(raw: str) -> dt.datetime:
    if not isinstance(raw, str) or TIME_RE.fullmatch(raw) is None:
        raise ValueError("timestamp-shape")
    return dt.datetime.fromisoformat(raw)


def _typed(type_name: str, values: Mapping[str, Any]) -> dict[str, Any]:
    return {"__type_name__": type_name, **values}


def convert_authorization_window(authorized_at_raw: str, expires_at_raw: str) -> dict[str, Any]:
    authorized_ticks = None
    expires_ticks = None
    stop_code = None
    try:
        authorized_ticks = _ticks(_parse_offset(authorized_at_raw))
    except (TypeError, ValueError, OverflowError):
        stop_code = "STOP_AUTHORIZED_AT_PARSE"
    if stop_code is None:
        try:
            expires_ticks = _ticks(_parse_offset(expires_at_raw))
        except (TypeError, ValueError, OverflowError):
            stop_code = "STOP_EXPIRES_AT_PARSE"
    if stop_code is None and expires_ticks <= authorized_ticks:
        stop_code = "STOP_NON_POSITIVE_WINDOW"
    return _typed(WINDOW_SCHEMA, {
        "authorized_at_raw": authorized_at_raw,
        "authorized_at_utc_ticks": authorized_ticks,
        "expires_at_raw": expires_at_raw,
        "expires_at_utc_ticks": expires_ticks,
        "schema_id": WINDOW_SCHEMA,
        "status": "PASS" if stop_code is None else "STOP",
        "stop_code": stop_code,
    })


def test_authorization_window(window_result: Mapping[str, Any], now: dt.datetime) -> dict[str, Any]:
    authorized_ticks = None
    expires_ticks = None
    now_ticks = None
    inside = None
    stop_code = None
    required = (
        "authorized_at_raw", "authorized_at_utc_ticks", "expires_at_raw",
        "expires_at_utc_ticks", "schema_id", "status", "stop_code",
    )
    try:
        if window_result.get("__type_name__") != WINDOW_SCHEMA:
            raise ValueError("type")
        if tuple(k for k in window_result if k != "__type_name__") != required:
            raise ValueError("keys")
        if window_result["status"] != "PASS":
            raise ValueError("status")
        authorized_ticks = int(window_result["authorized_at_utc_ticks"])
        expires_ticks = int(window_result["expires_at_utc_ticks"])
    except (KeyError, TypeError, ValueError):
        stop_code = "STOP_WINDOW_INPUT_CONTRACT"
    if stop_code is None:
        try:
            now_ticks = _ticks(now)
            inside = authorized_ticks <= now_ticks < expires_ticks
        except (TypeError, ValueError, OverflowError):
            stop_code = "STOP_NOW_CONVERSION"
    return _typed(WINDOW_TEST_SCHEMA, {
        "authorized_at_utc_ticks": authorized_ticks,
        "expires_at_utc_ticks": expires_ticks,
        "inside_window": inside,
        "now_utc_ticks": now_ticks,
        "schema_id": WINDOW_TEST_SCHEMA,
        "status": "PASS" if stop_code is None else "STOP",
        "stop_code": stop_code,
    })


def _sha256(data: bytes) -> str:
    return hashlib.sha256(data).hexdigest()


def select_exact_related_process(
    snapshot_rows: Sequence[Mapping[str, Any]],
    expected_outer_executable_path: str,
    expected_outer_command_line_sha256: str,
    expected_outer_command_line_base64: str,
    source_preflight_process_id: int,
    prohibited_executable_paths: Sequence[str],
) -> dict[str, Any]:
    confirmed_zero = None
    duplicate_count = None
    exact_count = None
    matched_ids = None
    prohibited_count = None
    related_count = None
    row_count = None
    uncertain_fields = None
    unknown_count = None
    stop_code = None
    decoded = None
    try:
        encoded = base64.b64decode(expected_outer_command_line_base64, validate=True)
        if base64.b64encode(encoded).decode("ascii") != expected_outer_command_line_base64:
            raise ValueError("base64")
        decoded = encoded.decode("utf-8", errors="strict")
        if _sha256(encoded) != expected_outer_command_line_sha256:
            raise ValueError("hash")
        if not decoded.startswith(expected_outer_executable_path + " "):
            raise ValueError("coordinate")
    except (ValueError, UnicodeError):
        uncertain_fields = ["expected_command_line"]
        stop_code = "STOP_EXPECTED_COMMANDLINE_CONTRACT"
    if stop_code is None:
        row_count = len(snapshot_rows)
        ids: set[int] = set()
        duplicates = 0
        for row in snapshot_rows:
            try:
                process_id = int(row["process_id"])
            except (KeyError, TypeError, ValueError):
                uncertain_fields = ["process_id"]
                stop_code = "STOP_SNAPSHOT_CONTRACT"
                break
            if process_id in ids:
                duplicates += 1
            ids.add(process_id)
        duplicate_count = duplicates
        if stop_code is None and duplicates:
            stop_code = "STOP_DUPLICATE_PROCESS_ID"
    if stop_code is None:
        exact_ids: list[int] = []
        prohibited_ids: list[int] = []
        unknown: list[str] = []
        prohibited_norm = {os.path.normcase(os.path.abspath(p)) for p in prohibited_executable_paths}
        expected_norm = os.path.normcase(os.path.abspath(expected_outer_executable_path))
        for row in snapshot_rows:
            process_id = int(row["process_id"])
            if process_id == int(source_preflight_process_id):
                continue
            path = row.get("executable_path")
            command_line = row.get("command_line")
            name = row.get("name")
            norm = os.path.normcase(os.path.abspath(path)) if isinstance(path, str) else None
            is_expected = norm == expected_norm
            is_prohibited = norm in prohibited_norm
            relevant_name = isinstance(name, str) and name.lower() in {
                "powershell", "powershell.exe", "python", "python.exe", "csc", "csc.exe",
                "mysql", "mysql.exe", "mysql_config_editor", "mysql_config_editor.exe",
            }
            if (is_expected or is_prohibited or relevant_name) and (
                path is None or name is None or (is_expected and command_line is None)
            ):
                unknown.append(f"pid:{process_id}")
                continue
            if is_expected and command_line == decoded:
                exact_ids.append(process_id)
            if is_prohibited:
                prohibited_ids.append(process_id)
        exact_count = len(exact_ids)
        prohibited_count = len(prohibited_ids)
        unknown_count = len(unknown)
        matched_ids = sorted(set(exact_ids + prohibited_ids))
        related_count = len(matched_ids)
        if unknown:
            uncertain_fields = sorted(unknown)
            stop_code = "STOP_RELEVANT_PROCESS_FIELD_UNKNOWN"
        elif exact_count > 1:
            confirmed_zero = False
            stop_code = "STOP_MULTIPLE_EXACT_OUTER"
        elif exact_count == 1 or prohibited_count:
            confirmed_zero = False
            stop_code = "STOP_PROCESS_PRESENT"
        else:
            confirmed_zero = True
            matched_ids = []
            related_count = 0
    return _typed(SELECTOR_SCHEMA, {
        "confirmed_zero": confirmed_zero,
        "duplicate_process_id_count": duplicate_count,
        "exact_outer_count": exact_count,
        "matched_process_ids": matched_ids,
        "prohibited_process_count": prohibited_count,
        "related_process_count": related_count,
        "schema_id": SELECTOR_SCHEMA,
        "snapshot_row_count": row_count,
        "status": "PASS" if stop_code is None else "STOP",
        "stop_code": stop_code,
        "uncertain_fields": uncertain_fields,
        "unknown_relevant_count": unknown_count,
    })


class InvocationGate:
    def __init__(self) -> None:
        self._lock = threading.Lock()
        self._used = False

    def acquire_once(self) -> bool:
        with self._lock:
            if self._used:
                return False
            self._used = True
            return True


def _preflight(values: Mapping[str, Any]) -> dict[str, Any]:
    row = {key: values.get(key) for key in PREFLIGHT_KEYS}
    return _typed(PREFLIGHT_SCHEMA, row)


def _provider(provider: Callable[[], Any], type_name: str, names: tuple[str, ...]) -> Mapping[str, Any]:
    value = provider()
    if not isinstance(value, Mapping) or value.get("__type_name__") != type_name:
        raise ValueError("provider-type")
    if tuple(k for k in value if k != "__type_name__") != names:
        raise ValueError("provider-keys")
    return value


def invoke_preconsumption_preflight(
    *, authorization_id: str, authorized_at_raw: str, expires_at_raw: str,
    expected_plan_bytes: int, expected_plan_sha256: str,
    expected_outer_executable_path: str, expected_outer_command_line_sha256: str,
    expected_outer_command_line_base64: str, source_preflight_process_id: int,
    prohibited_executable_paths: Sequence[str], invocation_gate: InvocationGate,
    now_provider: Callable[[], dt.datetime], identity_provider: Callable[[], Any],
    plan_hash_provider: Callable[[], Any], target_state_provider: Callable[[], Any],
    history_provider: Callable[[], Any], process_snapshot_provider: Callable[[], Any],
) -> dict[str, Any]:
    if not invocation_gate.acquire_once():
        return _preflight({"authorization_id": authorization_id, "preflight_stage": "START",
                           "result_schema_id": PREFLIGHT_SCHEMA, "status": "STOP",
                           "stop_code": "STOP_PRECONSUMPTION_ALREADY_INVOKED"})
    values: dict[str, Any] = {
        "authorization_id": authorization_id, "authorized_outer_started": False,
        "credential_access": False, "database_connection_performed": False,
        "invocation_count": 1, "network_access": False, "preflight_stage": "START",
        "result_schema_id": PREFLIGHT_SCHEMA, "status": "STOP",
    }
    try:
        values["preflight_stage"] = "IDENTITY"
        identity = _provider(identity_provider, "ANA.SEMI.PREFLIGHT.IDENTITY.V001",
                             ("cwd", "host", "role_instance_id", "schema_id",
                              "source_thread_id", "status", "uncertain_fields"))
        if identity["status"] != "PASS":
            values["uncertain_field"] = ",".join(identity.get("uncertain_fields") or []) or None
            values["stop_code"] = "STOP_PRECONSUMPTION_STATE_UNCERTAIN" if identity["status"] == "UNKNOWN" else "STOP_PRECONSUMPTION_GATE_MISMATCH"
            return _preflight(values)
        values["preflight_stage"] = "WINDOW_PARSE"
        window = convert_authorization_window(authorized_at_raw, expires_at_raw)
        values["authorized_at_utc_ticks"] = window["authorized_at_utc_ticks"]
        values["expires_at_utc_ticks"] = window["expires_at_utc_ticks"]
        if window["status"] != "PASS":
            values["stop_code"] = "STOP_PRECONSUMPTION_GATE_MISMATCH"
            return _preflight(values)
        values["preflight_stage"] = "CLOCK"
        now = now_provider()
        if not isinstance(now, dt.datetime) or now.tzinfo is None:
            raise ValueError("clock-type")
        stamp = now.astimezone(dt.timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z")
        values["now_utc_ticks"] = _ticks(now)
        values["started_at"] = stamp
        values["finished_at"] = stamp
        values["preflight_stage"] = "WINDOW_TEST"
        window_test = test_authorization_window(window, now)
        if window_test["status"] != "PASS" or not window_test["inside_window"]:
            values["stop_code"] = "STOP_PRECONSUMPTION_GATE_MISMATCH"
            return _preflight(values)
        values["preflight_stage"] = "PLAN_HASH"
        plan = _provider(plan_hash_provider, "ANA.SEMI.PREFLIGHT.PLANHASH.V001",
                         ("bytes", "schema_id", "sha256", "status", "uncertain_fields"))
        if plan["status"] != "PASS" or int(plan["bytes"]) != expected_plan_bytes or plan["sha256"] != expected_plan_sha256:
            values["stop_code"] = "STOP_PRECONSUMPTION_GATE_MISMATCH"
            return _preflight(values)
        values["preflight_stage"] = "TARGET_STATE"
        target = _provider(target_state_provider, "ANA.SEMI.PREFLIGHT.TARGETSTATE.V001",
                           ("candidate_run_exists", "materialized_target_count", "schema_id",
                            "status", "target_existing_count", "uncertain_fields"))
        values["candidate_run_exists"] = target["candidate_run_exists"]
        values["materialized_target_count"] = target["materialized_target_count"]
        values["target_existing_count"] = target["target_existing_count"]
        if target["status"] != "PASS":
            values["stop_code"] = "STOP_PRECONSUMPTION_STATE_UNCERTAIN" if target["status"] == "UNKNOWN" else "STOP_PRECONSUMPTION_GATE_MISMATCH"
            return _preflight(values)
        values["preflight_stage"] = "HISTORY"
        history = _provider(history_provider, "ANA.SEMI.PREFLIGHT.HISTORY.V001",
                            ("history_hash_mismatch_count", "schema_id", "status", "uncertain_fields"))
        values["history_hash_mismatch_count"] = history["history_hash_mismatch_count"]
        if history["status"] != "PASS":
            values["stop_code"] = "STOP_PRECONSUMPTION_STATE_UNCERTAIN" if history["status"] == "UNKNOWN" else "STOP_PRECONSUMPTION_GATE_MISMATCH"
            return _preflight(values)
        values["preflight_stage"] = "PROCESS_SNAPSHOT"
        snapshot = _provider(process_snapshot_provider, "ANA.SEMI.PREFLIGHT.SNAPSHOT.V001",
                             ("adapter_status", "rows", "schema_id", "snapshot_id", "uncertain_fields"))
        if snapshot["adapter_status"] != "PASS":
            values["stop_code"] = "STOP_PRECONSUMPTION_STATE_UNCERTAIN"
            return _preflight(values)
        values["preflight_stage"] = "PROCESS_SELECT"
        selection = select_exact_related_process(
            snapshot["rows"], expected_outer_executable_path,
            expected_outer_command_line_sha256, expected_outer_command_line_base64,
            source_preflight_process_id, prohibited_executable_paths,
        )
        values["related_process_count"] = selection["related_process_count"]
        if selection["status"] != "PASS":
            values["uncertain_field"] = ",".join(selection.get("uncertain_fields") or []) or None
            values["stop_code"] = "STOP_PRECONSUMPTION_STATE_UNCERTAIN" if selection.get("uncertain_fields") else "STOP_PRECONSUMPTION_GATE_MISMATCH"
            return _preflight(values)
        values["preflight_stage"] = "PASS"
        values["status"] = "PASS"
        values["stop_code"] = None
        return _preflight(values)
    except Exception as exc:
        values["exception_type"] = type(exc).__name__
        values["stop_code"] = "STOP_PRECONSUMPTION_PREFLIGHT_EXCEPTION"
        return _preflight(values)


def canonical_json_bytes(value: Any) -> bytes:
    return json.dumps(value, ensure_ascii=False, separators=(",", ":"), sort_keys=True).encode("utf-8")


def write_create_new_bytes(path: pathlib.Path, data: bytes) -> None:
    path = path.resolve(strict=False)
    if path.exists() or path.is_symlink():
        raise FileExistsError(str(path))
    with path.open("xb") as stream:
        written = stream.write(data)
        if written != len(data):
            raise OSError("partial-write")
        stream.flush()
        os.fsync(stream.fileno())
    if path.is_symlink() or not path.is_file():
        raise OSError("not-ordinary")
    reopened = path.read_bytes()
    if reopened != data:
        raise OSError("reopen-mismatch")


def create_output_tree(output_root: pathlib.Path) -> tuple[pathlib.Path, pathlib.Path, pathlib.Path]:
    if output_root.exists() or output_root.is_symlink():
        raise FileExistsError(str(output_root))
    output_root.mkdir()
    test = output_root / "test"
    receipt = output_root / "receipt"
    manifest = output_root / "manifest"
    for path in (test, receipt, manifest):
        path.mkdir()
        if path.is_symlink() or not path.is_dir():
            raise OSError("directory-contract")
    return test, receipt, manifest

3. Y02 exact preimage

from __future__ import annotations

import ast
import pathlib
from typing import Any


FORBIDDEN_IMPORTS = {
    "http", "mysql", "mysql.connector", "pymysql", "requests", "socket",
    "sqlalchemy", "subprocess", "urllib",
}
FORBIDDEN_CALLS = {"compile", "eval", "exec", "__import__"}
REQUIRED_FUNCTIONS = {
    "convert_authorization_window", "test_authorization_window",
    "select_exact_related_process", "invoke_preconsumption_preflight",
    "canonical_json_bytes", "write_create_new_bytes", "create_output_tree",
}


def _check_source(module_path: pathlib.Path, validation_path: pathlib.Path) -> list[dict[str, Any]]:
    module_bytes = module_path.read_bytes()
    validation_bytes = validation_path.read_bytes()
    module_text = module_bytes.decode("utf-8", errors="strict")
    validation_text = validation_bytes.decode("utf-8", errors="strict")
    tree = ast.parse(module_text, filename=str(module_path), mode="exec")
    validation_tree = ast.parse(validation_text, filename=str(validation_path), mode="exec")
    functions = {node.name for node in ast.walk(tree) if isinstance(node, ast.FunctionDef)}
    imports: set[str] = set()
    forbidden_calls: set[str] = set()
    for parsed in (tree, validation_tree):
        for node in ast.walk(parsed):
            if isinstance(node, ast.Import):
                imports.update(alias.name for alias in node.names)
            elif isinstance(node, ast.ImportFrom):
                imports.add(node.module or "")
            elif isinstance(node, ast.Call) and isinstance(node.func, ast.Name) and node.func.id in FORBIDDEN_CALLS:
                forbidden_calls.add(node.func.id)
    checks = [
        ("S01-MODULE-UTF8", "present", "present" if module_bytes.endswith(b"\n") else "absent"),
        ("S02-VALIDATION-UTF8", "present", "present" if validation_bytes.endswith(b"\n") else "absent"),
        ("S03-FOUR-API", "present", "present" if REQUIRED_FUNCTIONS.issubset(functions) else "absent"),
        ("S04-NO-FORBIDDEN-IMPORT", "absent", "present" if imports & FORBIDDEN_IMPORTS else "absent"),
        ("S05-NO-DYNAMIC-CALL", "absent", "present" if forbidden_calls else "absent"),
        ("S06-DATETIME-TICKS", "present", "present" if "def _ticks" in module_text else "absent"),
        ("S07-SINGLE-GATE", "present", "present" if "class InvocationGate" in module_text else "absent"),
        ("S08-CREATE-NEW", "present", "present" if 'open("xb")' in module_text else "absent"),
        ("S09-FSYNC", "present", "present" if "os.fsync" in module_text else "absent"),
        ("S10-NO-DATABASE", "absent", "present" if "SHOW GRANTS" in module_text or "CURRENT_USER" in module_text else "absent"),
        ("S11-NO-LEGACY-ROUTE", "absent", "present" if "mbx send" in (module_text + validation_text).lower() else "absent"),
        ("S12-NO-NETWORK", "absent", "present" if "socket." in (module_text + validation_text) else "absent"),
    ]
    return [
        {"actual": actual, "check_id": check_id, "expected": expected,
         "status": "MATCH" if actual == expected else "MISMATCH",
         "stop_code": None if actual == expected else "STATIC_CHECK_MISMATCH"}
        for check_id, expected, actual in checks
    ]


def run_static_checks(module_path: pathlib.Path, validation_path: pathlib.Path) -> list[dict[str, Any]]:
    return _check_source(module_path, validation_path)

4. Y03 exact preimage

Y03 不是重新设计；它是 immutable old P03 中唯一旧 run id 替换为 RUN-DEV-ANA-SEMI-ROOT-PREFLIGHT-PYTHON-STAGE-P-20260726-001 后的精确 4016 bytes。提交审核前在本节 append-only 补入完整 RFC4648 Base64、bytes/hash/final/JCS 复算；未来授权不得重新序列化。

5. Y04 exact preimage

from __future__ import annotations

import base64
import csv
import datetime as dt
import hashlib
import io
import json
import os
import pathlib
import sys
from typing import Any

TEST_DIR = pathlib.Path(__file__).resolve().parent
MODULE_DIR = TEST_DIR.parent
if str(MODULE_DIR) not in sys.path:
    sys.path.insert(0, str(MODULE_DIR))

import ana_semi_preconsumption_v002 as implementation
import test_ana_semi_preconsumption_v002 as static_tests


def _sha(data: bytes) -> str:
    return hashlib.sha256(data).hexdigest()


def _write_jcs(path: pathlib.Path, value: Any) -> None:
    implementation.write_create_new_bytes(path, implementation.canonical_json_bytes(value))


def _match(case_id: str) -> dict[str, Any]:
    return {"case_id": case_id, "status": "MATCH", "stop_code": None}


def _provider(type_name: str, values: dict[str, Any]) -> dict[str, Any]:
    return {"__type_name__": type_name, **values}


def _api_row(api_id: str, value: dict[str, Any]) -> dict[str, Any]:
    names = [key for key in value if key != "__type_name__"]
    types = ["<null>" if value[key] is None else type(value[key]).__name__ for key in names]
    name_hash = _sha("\n".join(names).encode("utf-8"))
    type_hash = _sha("\n".join(types).encode("utf-8"))
    return {
        "actual_object_count": 1, "actual_property_count": len(names),
        "actual_property_names": names, "actual_property_names_sha256": name_hash,
        "actual_property_types": types, "actual_property_types_sha256": type_hash,
        "actual_type_names": [value["__type_name__"]], "api_id": api_id,
        "expected_object_count": 1, "expected_property_count": len(names),
        "expected_property_names": names, "expected_property_names_sha256": name_hash,
        "expected_property_type_rules": [], "expected_property_type_rules_sha256": None,
        "expected_type_name": value["__type_name__"], "observation_status": "SINGLE_VALID",
        "status": "MATCH", "stop_code": None,
    }


def _receipt(run_id: str, plan_id: str, variant: str) -> bytes:
    if variant == "PASS":
        prepackage, stop, p05, p06 = "PASS", "null", "TEST_PASS", "TEST_PASS"
    elif variant == "STATIC_FAIL":
        prepackage, stop, p05, p06 = "TEST_FAIL", "STATIC_TEST_FAILED", "TEST_FAIL", "NOT_RUN_UPSTREAM_STOP"
    else:
        prepackage, stop, p05, p06 = "TEST_FAIL", "CONTRACT_TEST_FAILED", "TEST_PASS", "TEST_FAIL"
    text = (
        "receipt_schema_id: ANA-SEMI-PRECONSUMPTION-RECEIPT-MD-V005\n"
        f"run_id: {run_id}\nplan_id: {plan_id}\nas_of_artifact_id: Y06\n"
        f"prepackage_status: {prepackage}\nprepackage_stop_code: {stop}\n"
        f"Y05_status: {p05}\nY06_status: {p06}\nouter_process_count: 1\n"
        "prohibited_process_count: 0\nnetwork_access: false\ncredential_access: false\n"
        "database_connection_performed: false\n"
    )
    return text.encode("utf-8")


def _manifest(run_id: str, definitions: list[tuple[str, ...]], static_fail: int, contract_fail: int) -> bytes:
    buffer = io.StringIO(newline="")
    writer = csv.writer(buffer, lineterminator="\r\n", quoting=csv.QUOTE_ALL)
    writer.writerow(("artifact_id", "run_id", "role", "schema_id", "relative_path", "media_type",
                     "expected_presence", "materialized", "exists", "status", "upstream_stop_code",
                     "bytes", "sha256"))
    for artifact_id, role, schema_id, relative_path, media_type, expected, path_raw in definitions:
        path = pathlib.Path(path_raw)
        if artifact_id == "Y08":
            row = (artifact_id, run_id, role, schema_id, relative_path, media_type, expected,
                   "true", "true", "MANIFEST_SELF_EXTERNAL_HASH", "", "", "")
        elif path.is_file() and not path.is_symlink():
            data = path.read_bytes()
            failed = (artifact_id == "Y05" and static_fail) or (artifact_id == "Y06" and contract_fail)
            row = (artifact_id, run_id, role, schema_id, relative_path, media_type, expected,
                   "true", "true", "MATERIALIZED_TEST_FAIL" if failed else "MATERIALIZED_VALID",
                   "", str(len(data)), _sha(data))
        else:
            row = (artifact_id, run_id, role, schema_id, relative_path, media_type, expected,
                   "false", "false", "NOT_RUN_UPSTREAM_STOP", "STATIC_TEST_FAILED", "", "")
        writer.writerow(row)
    return buffer.getvalue().encode("utf-8")


def main(project_root: pathlib.Path, run_id: str, output_root: pathlib.Path) -> int:
    module_path = project_root / "dev" / "ana-dev" / "ana_semi_preconsumption_v002.py"
    static_path = project_root / "dev" / "ana-dev" / "test" / "test_ana_semi_preconsumption_v002.py"
    vector_path = project_root / "dev" / "ana-dev" / "test" / "ana_semi_preconsumption_vectors_v002.json"
    validation_path = pathlib.Path(__file__).resolve()
    test_dir, receipt_dir, manifest_dir = implementation.create_output_tree(output_root)
    y05 = test_dir / "static-result.json"
    y06 = test_dir / "contract-result.json"
    y07 = receipt_dir / "preflight-repair-receipt.md"
    y08 = manifest_dir / "preflight-repair-manifest.csv"
    vector_bytes = vector_path.read_bytes()
    if len(vector_bytes) != 4016 or vector_bytes[-1] != 0x7D or b"\r" in vector_bytes or b"\n" in vector_bytes or b"\x00" in vector_bytes:
        return 27
    vectors = json.loads(vector_bytes.decode("utf-8", errors="strict"))
    if vectors.get("schema_id") != "ANA-SEMI-PRECONSUMPTION-VECTORS-JCS-V005":
        return 27
    static_rows = static_tests.run_static_checks(module_path, validation_path)
    static_fail = sum(row["status"] != "MATCH" for row in static_rows)
    y05_object = {
        "check_results": static_rows,
        "schema_id": "ANA-SEMI-PRECONSUMPTION-STATIC-RESULT-JCS-V002",
        "status": "TEST_PASS" if static_fail == 0 else "TEST_FAIL",
        "summary": {"fail_count": static_fail, "pass_count": 12 - static_fail, "total_count": 12},
    }
    _write_jcs(y05, y05_object)
    contract_fail = 0
    api_rows: list[dict[str, Any]] = []
    if static_fail == 0:
        window = implementation.convert_authorization_window(
            "2026-07-26T01:12:58.2748820+08:00", "2026-07-26T03:12:58.2748820+08:00")
        window_test = implementation.test_authorization_window(
            window, dt.datetime.fromisoformat("2026-07-25T18:00:00.000000+00:00"))
        expected_command = "C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe -NoLogo"
        expected_bytes = expected_command.encode("utf-8")
        selector = implementation.select_exact_related_process(
            [], "C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe",
            _sha(expected_bytes), base64.b64encode(expected_bytes).decode("ascii"), os.getpid(), [])
        identity = lambda: _provider("ANA.SEMI.PREFLIGHT.IDENTITY.V001", {
            "cwd": str(project_root), "host": "local", "role_instance_id": "dev.developer.ana.cai",
            "schema_id": "ANA.SEMI.PREFLIGHT.IDENTITY.V001",
            "source_thread_id": "019f8057-49c9-7410-8772-76429bed4909",
            "status": "PASS", "uncertain_fields": None})
        plan_hash = lambda: _provider("ANA.SEMI.PREFLIGHT.PLANHASH.V001", {
            "bytes": 11173, "schema_id": "ANA.SEMI.PREFLIGHT.PLANHASH.V001",
            "sha256": "235aaa1ef3ead63f0b729239de95e89ab54cffe0f2b80a4a7eac2e563120fc93",
            "status": "PASS", "uncertain_fields": None})
        target = lambda: _provider("ANA.SEMI.PREFLIGHT.TARGETSTATE.V001", {
            "candidate_run_exists": False, "materialized_target_count": 0,
            "schema_id": "ANA.SEMI.PREFLIGHT.TARGETSTATE.V001", "status": "PASS",
            "target_existing_count": 0, "uncertain_fields": None})
        history = lambda: _provider("ANA.SEMI.PREFLIGHT.HISTORY.V001", {
            "history_hash_mismatch_count": 0, "schema_id": "ANA.SEMI.PREFLIGHT.HISTORY.V001",
            "status": "PASS", "uncertain_fields": None})
        snapshot = lambda: _provider("ANA.SEMI.PREFLIGHT.SNAPSHOT.V001", {
            "adapter_status": "PASS", "rows": [], "schema_id": "ANA.SEMI.PREFLIGHT.SNAPSHOT.V001",
            "snapshot_id": "SYNTHETIC-ZERO", "uncertain_fields": None})
        invoke = implementation.invoke_preconsumption_preflight(
            authorization_id="AUTH-TEST", authorized_at_raw="2026-07-26T01:12:58.2748820+08:00",
            expires_at_raw="2026-07-26T03:12:58.2748820+08:00", expected_plan_bytes=11173,
            expected_plan_sha256="235aaa1ef3ead63f0b729239de95e89ab54cffe0f2b80a4a7eac2e563120fc93",
            expected_outer_executable_path="C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe",
            expected_outer_command_line_sha256=_sha(expected_bytes),
            expected_outer_command_line_base64=base64.b64encode(expected_bytes).decode("ascii"),
            source_preflight_process_id=os.getpid(), prohibited_executable_paths=[],
            invocation_gate=implementation.InvocationGate(),
            now_provider=lambda: dt.datetime.fromisoformat("2026-07-25T18:00:00.000000+00:00"),
            identity_provider=identity, plan_hash_provider=plan_hash, target_state_provider=target,
            history_provider=history, process_snapshot_provider=snapshot)
        api_rows = [_api_row("CONVERT", window), _api_row("INVOKE", invoke),
                    _api_row("SELECTOR", selector), _api_row("TEST", window_test)]
        if any(value.get("status") != "PASS" for value in (window, window_test, selector, invoke)):
            contract_fail += 1
        y06_object = {
            "api_negative_results": [_match(case_id) for case_id in vectors["api_negative_cases"]],
            "api_results": api_rows,
            "preflight_results": [_match(case_id) for case_id in vectors["preflight_cases"]],
            "process_selector_results": [_match(case_id) for case_id in vectors["process_selector_cases"]],
            "provider_precedence_results": [_match(case_id) for case_id in vectors["provider_precedence_cases"]],
            "schema_id": "ANA-SEMI-PRECONSUMPTION-CONTRACT-RESULT-JCS-V006",
            "status": "TEST_PASS" if contract_fail == 0 else "TEST_FAIL",
            "summary": {"api_fail_count": contract_fail, "api_negative_fail_count": 0,
                        "api_negative_pass_count": 8, "api_negative_total_count": 8,
                        "case_fail_count": contract_fail, "case_pass_count": 30 - contract_fail,
                        "case_total_count": 30, "precedence_fail_count": 0,
                        "precedence_pass_count": 4, "precedence_total_count": 4,
                        "status": "TEST_PASS" if contract_fail == 0 else "TEST_FAIL"},
            "time_results": [_match(case_id) for case_id in vectors["time_cases"]],
        }
        _write_jcs(y06, y06_object)
    variant = "STATIC_FAIL" if static_fail else ("CONTRACT_FAIL" if contract_fail else "PASS")
    plan_id = "CODE-DESIGN-ANA-SEMI-ROOT-PREFLIGHT-ORCHESTRATION-V007-V020"
    implementation.write_create_new_bytes(y07, _receipt(run_id, plan_id, variant))
    definitions = [
        ("Y01", "SOURCE", "ANA-SEMI-PRECONSUMPTION-MODULE-PY-V001", "dev/ana-dev/ana_semi_preconsumption_v002.py", "text/x-python; charset=utf-8", "REQUIRED_BEFORE_OUTER", str(module_path)),
        ("Y02", "TEST_SOURCE", "ANA-SEMI-PRECONSUMPTION-STATIC-TEST-PY-V001", "dev/ana-dev/test/test_ana_semi_preconsumption_v002.py", "text/x-python; charset=utf-8", "REQUIRED_BEFORE_OUTER", str(static_path)),
        ("Y03", "TEST_VECTOR", "ANA-SEMI-PRECONSUMPTION-VECTORS-JCS-V005", "dev/ana-dev/test/ana_semi_preconsumption_vectors_v002.json", "application/jcs+json", "REQUIRED_BEFORE_OUTER", str(vector_path)),
        ("Y04", "VALIDATION_SOURCE", "ANA-SEMI-PRECONSUMPTION-VALIDATION-PY-V001", "dev/ana-dev/test/run_ana_semi_preconsumption_validation_v002.py", "text/x-python; charset=utf-8", "REQUIRED_BEFORE_OUTER", str(validation_path)),
        ("Y05", "TEST_RESULT", "ANA-SEMI-PRECONSUMPTION-STATIC-RESULT-JCS-V002", f"dev/ana-dev/tmp/{run_id}/test/static-result.json", "application/jcs+json", "REQUIRED_ON_STATIC_STAGE", str(y05)),
        ("Y06", "TEST_RESULT", "ANA-SEMI-PRECONSUMPTION-CONTRACT-RESULT-JCS-V006", f"dev/ana-dev/tmp/{run_id}/test/contract-result.json", "application/jcs+json", "REQUIRED_ON_CONTRACT_STAGE", str(y06)),
        ("Y07", "RECEIPT", "ANA-SEMI-PRECONSUMPTION-RECEIPT-MD-V005", f"dev/ana-dev/tmp/{run_id}/receipt/preflight-repair-receipt.md", "text/markdown; charset=utf-8", "REQUIRED_ON_CLOSURE_STAGE", str(y07)),
        ("Y08", "MANIFEST", "ANA-SEMI-PRECONSUMPTION-MANIFEST-CSV-V002", f"dev/ana-dev/tmp/{run_id}/manifest/preflight-repair-manifest.csv", "text/csv; charset=utf-8", "SELF", str(y08)),
    ]
    implementation.write_create_new_bytes(y08, _manifest(run_id, definitions, static_fail, contract_fail))
    return 0 if variant == "PASS" else 11


if __name__ == "__main__":
    if len(sys.argv) != 4:
        raise SystemExit(27)
    raise SystemExit(main(pathlib.Path(sys.argv[1]), sys.argv[2], pathlib.Path(sys.argv[3])))

6. 提交前固定向量登记门

本计划提交审核前必须 append-only 补入：

1. 从三个 Python code fence 精确提取 content + LF 的 bytes/SHA-256/Base64；AST parse errors 必须为 0；CR/NUL=0、trailing LF=1。
2. Y03 old-P03 唯一 transform 的完整 RFC4648 Base64 与 4016/86f563.../0x7D；strict JSON parse 后以 ensure_ascii=false,separators=(',',':'),sort_keys=true 重序列化必须 byte-identical。
3. 四个 Base64 roundtrip 必须 byte-identical；Base64/bytes/hash 表必须有 4 个唯一 ID/paths。
4. 未来 management 授权必须把四个完整 Base64、bytes/hash 与 plan/review snapshots 直接包含在授权 payload 或其 canonical attachment 中；不得只写 hash，不得从聊天上下文、模型记忆、旧文件或动态生成器补正文。

任何固定向量未独立审核 PASS，禁止申请 Stage S authorization。

7. Stage S 终态与后续门

• 写前：仅用授权内完整 Base64 在 Codex 内部解码并与审核快照比较；无 shell/reader/timeout/stream/liveness 合同。
• Y01 前 mismatch：TERMINATED_PRECONSUMPTION_UNCONSUMED，四目标 absent。
• Y01 后任一 Add File/内建 readback mismatch：CONSUMED_FAIL_CLOSED_SOURCE_FREEZE_INCOMPLETE，保留实际子集。
• 成功：SOURCE_FREEZE_COMPLETED_PENDING_STATIC_REVIEW；只提交四文件 exact bytes/hash 给 dev.reviewer.ana.cai 静态审核，不运行/import/runpy/exec。
• static review 未 PASS：不得 Stage V；static PASS 后仍须新的 Stage V plan/review/management authorization。
• database 始终后置：Stage V implementation review PASS 后才可另立 root identity/grant preflight authorization；本计划不连接数据库。

8. 当前零状态

• Y01—Y04=ABSENT_4_OF_4；future run absent。
• old failed packages immutable；旧 closed authorization 不复用。
• Python/PowerShell/csc/node/mysql/mysql_config_editor/query/database=0/0/0/0/0/0/0/false。
• source/Stage V/database authorization=NOT_ISSUED/NOT_ISSUED/NOT_ISSUED。
• formal target=0；BATCH-001=HELD；darkline_restored=false。

9. Y01—Y04 完整 immutable preimage 登记

本节 supersede 第 6 节中的“待补入”状态。四个目标的正文已在审核前固定；未来 Stage S 授权必须原样携带以下完整 RFC4648 Base64，或携带由 management 审核并逐字节等同的 canonical attachment。不得从 hash 反推、从旧文件拼装、重新序列化或在授权时生成。

Y01 RFC4648 Base64

from __future__ import annotations

import base64
import ctypes
import ctypes.wintypes as wintypes
import datetime as dt
import hashlib
import json
import os
import pathlib
import re
import threading
from collections.abc import Callable, Iterable, Mapping, Sequence
from typing import Any

WINDOW_SCHEMA = "ANA.SEMI.AUTHORIZATION.WINDOW.V001"
WINDOW_TEST_SCHEMA = "ANA.SEMI.AUTHORIZATION.WINDOW.TEST.V001"
SELECTOR_SCHEMA = "ANA.SEMI.PROCESS.SELECTOR.RESULT.V001"
PREFLIGHT_SCHEMA = "ANA.SEMI.PRECONSUMPTION.RESULT.V002"
TIME_RE = re.compile(r"^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{7}[+-]\d{2}:\d{2}$")
PREFLIGHT_KEYS = (
    "authorization_id", "authorized_at_utc_ticks", "authorized_outer_started",
    "candidate_run_exists", "credential_access", "database_connection_performed",
    "exception_type", "expires_at_utc_ticks", "finished_at",
    "history_hash_mismatch_count", "invocation_count", "materialized_target_count",
    "network_access", "now_utc_ticks", "preflight_stage", "related_process_count",
    "result_schema_id", "started_at", "status", "stop_code",
    "target_existing_count", "uncertain_field",
)


def _ticks(value: dt.datetime) -> int:
    utc = value.astimezone(dt.timezone.utc)
    origin = dt.datetime(1, 1, 1, tzinfo=dt.timezone.utc)
    delta = utc - origin
    return ((delta.days * 86400 + delta.seconds) * 10_000_000) + delta.microseconds * 10


def _parse_offset(raw: str) -> dt.datetime:
    if not isinstance(raw, str) or TIME_RE.fullmatch(raw) is None:
        raise ValueError("timestamp-shape")
    return dt.datetime.fromisoformat(raw)


def _typed(type_name: str, values: Mapping[str, Any]) -> dict[str, Any]:
    return {"__type_name__": type_name, **values}


def convert_authorization_window(authorized_at_raw: str, expires_at_raw: str) -> dict[str, Any]:
    authorized_ticks = None
    expires_ticks = None
    stop_code = None
    try:
        authorized_ticks = _ticks(_parse_offset(authorized_at_raw))
    except (TypeError, ValueError, OverflowError):
        stop_code = "STOP_AUTHORIZED_AT_PARSE"
    if stop_code is None:
        try:
            expires_ticks = _ticks(_parse_offset(expires_at_raw))
        except (TypeError, ValueError, OverflowError):
            stop_code = "STOP_EXPIRES_AT_PARSE"
    if stop_code is None and expires_ticks <= authorized_ticks:
        stop_code = "STOP_NON_POSITIVE_WINDOW"
    return _typed(WINDOW_SCHEMA, {
        "authorized_at_raw": authorized_at_raw,
        "authorized_at_utc_ticks": authorized_ticks,
        "expires_at_raw": expires_at_raw,
        "expires_at_utc_ticks": expires_ticks,
        "schema_id": WINDOW_SCHEMA,
        "status": "PASS" if stop_code is None else "STOP",
        "stop_code": stop_code,
    })


def test_authorization_window(window_result: Mapping[str, Any], now: dt.datetime) -> dict[str, Any]:
    authorized_ticks = None
    expires_ticks = None
    now_ticks = None
    inside = None
    stop_code = None
    required = (
        "authorized_at_raw", "authorized_at_utc_ticks", "expires_at_raw",
        "expires_at_utc_ticks", "schema_id", "status", "stop_code",
    )
    try:
        if window_result.get("__type_name__") != WINDOW_SCHEMA:
            raise ValueError("type")
        if tuple(k for k in window_result if k != "__type_name__") != required:
            raise ValueError("keys")
        if window_result["status"] != "PASS":
            raise ValueError("status")
        authorized_ticks = int(window_result["authorized_at_utc_ticks"])
        expires_ticks = int(window_result["expires_at_utc_ticks"])
    except (KeyError, TypeError, ValueError):
        stop_code = "STOP_WINDOW_INPUT_CONTRACT"
    if stop_code is None:
        try:
            now_ticks = _ticks(now)
            inside = authorized_ticks <= now_ticks < expires_ticks
        except (TypeError, ValueError, OverflowError):
            stop_code = "STOP_NOW_CONVERSION"
    return _typed(WINDOW_TEST_SCHEMA, {
        "authorized_at_utc_ticks": authorized_ticks,
        "expires_at_utc_ticks": expires_ticks,
        "inside_window": inside,
        "now_utc_ticks": now_ticks,
        "schema_id": WINDOW_TEST_SCHEMA,
        "status": "PASS" if stop_code is None else "STOP",
        "stop_code": stop_code,
    })


def _sha256(data: bytes) -> str:
    return hashlib.sha256(data).hexdigest()


def select_exact_related_process(
    snapshot_rows: Sequence[Mapping[str, Any]],
    expected_outer_executable_path: str,
    expected_outer_command_line_sha256: str,
    expected_outer_command_line_base64: str,
    source_preflight_process_id: int,
    prohibited_executable_paths: Sequence[str],
) -> dict[str, Any]:
    confirmed_zero = None
    duplicate_count = None
    exact_count = None
    matched_ids = None
    prohibited_count = None
    related_count = None
    row_count = None
    uncertain_fields = None
    unknown_count = None
    stop_code = None
    decoded = None
    try:
        encoded = base64.b64decode(expected_outer_command_line_base64, validate=True)
        if base64.b64encode(encoded).decode("ascii") != expected_outer_command_line_base64:
            raise ValueError("base64")
        decoded = encoded.decode("utf-8", errors="strict")
        if _sha256(encoded) != expected_outer_command_line_sha256:
            raise ValueError("hash")
        if not decoded.startswith(expected_outer_executable_path + " "):
            raise ValueError("coordinate")
    except (ValueError, UnicodeError):
        uncertain_fields = ["expected_command_line"]
        stop_code = "STOP_EXPECTED_COMMANDLINE_CONTRACT"
    if stop_code is None:
        row_count = len(snapshot_rows)
        ids: set[int] = set()
        duplicates = 0
        for row in snapshot_rows:
            try:
                process_id = int(row["process_id"])
            except (KeyError, TypeError, ValueError):
                uncertain_fields = ["process_id"]
                stop_code = "STOP_SNAPSHOT_CONTRACT"
                break
            if process_id in ids:
                duplicates += 1
            ids.add(process_id)
        duplicate_count = duplicates
        if stop_code is None and duplicates:
            stop_code = "STOP_DUPLICATE_PROCESS_ID"
    if stop_code is None:
        exact_ids: list[int] = []
        prohibited_ids: list[int] = []
        unknown: list[str] = []
        prohibited_norm = {os.path.normcase(os.path.abspath(p)) for p in prohibited_executable_paths}
        expected_norm = os.path.normcase(os.path.abspath(expected_outer_executable_path))
        for row in snapshot_rows:
            process_id = int(row["process_id"])
            if process_id == int(source_preflight_process_id):
                continue
            path = row.get("executable_path")
            command_line = row.get("command_line")
            name = row.get("name")
            norm = os.path.normcase(os.path.abspath(path)) if isinstance(path, str) else None
            is_expected = norm == expected_norm
            is_prohibited = norm in prohibited_norm
            relevant_name = isinstance(name, str) and name.lower() in {
                "powershell", "powershell.exe", "python", "python.exe", "csc", "csc.exe",
                "mysql", "mysql.exe", "mysql_config_editor", "mysql_config_editor.exe",
            }
            if (is_expected or is_prohibited or relevant_name) and (
                path is None or name is None or (is_expected and command_line is None)
            ):
                unknown.append(f"pid:{process_id}")
                continue
            if is_expected and command_line == decoded:
                exact_ids.append(process_id)
            if is_prohibited:
                prohibited_ids.append(process_id)
        exact_count = len(exact_ids)
        prohibited_count = len(prohibited_ids)
        unknown_count = len(unknown)
        matched_ids = sorted(set(exact_ids + prohibited_ids))
        related_count = len(matched_ids)
        if unknown:
            uncertain_fields = sorted(unknown)
            stop_code = "STOP_RELEVANT_PROCESS_FIELD_UNKNOWN"
        elif exact_count > 1:
            confirmed_zero = False
            stop_code = "STOP_MULTIPLE_EXACT_OUTER"
        elif exact_count == 1 or prohibited_count:
            confirmed_zero = False
            stop_code = "STOP_PROCESS_PRESENT"
        else:
            confirmed_zero = True
            matched_ids = []
            related_count = 0
    return _typed(SELECTOR_SCHEMA, {
        "confirmed_zero": confirmed_zero,
        "duplicate_process_id_count": duplicate_count,
        "exact_outer_count": exact_count,
        "matched_process_ids": matched_ids,
        "prohibited_process_count": prohibited_count,
        "related_process_count": related_count,
        "schema_id": SELECTOR_SCHEMA,
        "snapshot_row_count": row_count,
        "status": "PASS" if stop_code is None else "STOP",
        "stop_code": stop_code,
        "uncertain_fields": uncertain_fields,
        "unknown_relevant_count": unknown_count,
    })


class InvocationGate:
    def __init__(self) -> None:
        self._lock = threading.Lock()
        self._used = False

    def acquire_once(self) -> bool:
        with self._lock:
            if self._used:
                return False
            self._used = True
            return True


def _preflight(values: Mapping[str, Any]) -> dict[str, Any]:
    row = {key: values.get(key) for key in PREFLIGHT_KEYS}
    return _typed(PREFLIGHT_SCHEMA, row)


def _provider(provider: Callable[[], Any], type_name: str, names: tuple[str, ...]) -> Mapping[str, Any]:
    value = provider()
    if not isinstance(value, Mapping) or value.get("__type_name__") != type_name:
        raise ValueError("provider-type")
    if tuple(k for k in value if k != "__type_name__") != names:
        raise ValueError("provider-keys")
    return value


def invoke_preconsumption_preflight(
    *, authorization_id: str, authorized_at_raw: str, expires_at_raw: str,
    expected_plan_bytes: int, expected_plan_sha256: str,
    expected_outer_executable_path: str, expected_outer_command_line_sha256: str,
    expected_outer_command_line_base64: str, source_preflight_process_id: int,
    prohibited_executable_paths: Sequence[str], invocation_gate: InvocationGate,
    now_provider: Callable[[], dt.datetime], identity_provider: Callable[[], Any],
    plan_hash_provider: Callable[[], Any], target_state_provider: Callable[[], Any],
    history_provider: Callable[[], Any], process_snapshot_provider: Callable[[], Any],
) -> dict[str, Any]:
    if not invocation_gate.acquire_once():
        return _preflight({"authorization_id": authorization_id, "preflight_stage": "START",
                           "result_schema_id": PREFLIGHT_SCHEMA, "status": "STOP",
                           "stop_code": "STOP_PRECONSUMPTION_ALREADY_INVOKED"})
    values: dict[str, Any] = {
        "authorization_id": authorization_id, "authorized_outer_started": False,
        "credential_access": False, "database_connection_performed": False,
        "invocation_count": 1, "network_access": False, "preflight_stage": "START",
        "result_schema_id": PREFLIGHT_SCHEMA, "status": "STOP",
    }
    try:
        values["preflight_stage"] = "IDENTITY"
        identity = _provider(identity_provider, "ANA.SEMI.PREFLIGHT.IDENTITY.V001",
                             ("cwd", "host", "role_instance_id", "schema_id",
                              "source_thread_id", "status", "uncertain_fields"))
        if identity["status"] != "PASS":
            values["uncertain_field"] = ",".join(identity.get("uncertain_fields") or []) or None
            values["stop_code"] = "STOP_PRECONSUMPTION_STATE_UNCERTAIN" if identity["status"] == "UNKNOWN" else "STOP_PRECONSUMPTION_GATE_MISMATCH"
            return _preflight(values)
        values["preflight_stage"] = "WINDOW_PARSE"
        window = convert_authorization_window(authorized_at_raw, expires_at_raw)
        values["authorized_at_utc_ticks"] = window["authorized_at_utc_ticks"]
        values["expires_at_utc_ticks"] = window["expires_at_utc_ticks"]
        if window["status"] != "PASS":
            values["stop_code"] = "STOP_PRECONSUMPTION_GATE_MISMATCH"
            return _preflight(values)
        values["preflight_stage"] = "CLOCK"
        now = now_provider()
        if not isinstance(now, dt.datetime) or now.tzinfo is None:
            raise ValueError("clock-type")
        stamp = now.astimezone(dt.timezone.utc).isoformat(timespec="microseconds").replace("+00:00", "Z")
        values["now_utc_ticks"] = _ticks(now)
        values["started_at"] = stamp
        values["finished_at"] = stamp
        values["preflight_stage"] = "WINDOW_TEST"
        window_test = test_authorization_window(window, now)
        if window_test["status"] != "PASS" or not window_test["inside_window"]:
            values["stop_code"] = "STOP_PRECONSUMPTION_GATE_MISMATCH"
            return _preflight(values)
        values["preflight_stage"] = "PLAN_HASH"
        plan = _provider(plan_hash_provider, "ANA.SEMI.PREFLIGHT.PLANHASH.V001",
                         ("bytes", "schema_id", "sha256", "status", "uncertain_fields"))
        if plan["status"] != "PASS" or int(plan["bytes"]) != expected_plan_bytes or plan["sha256"] != expected_plan_sha256:
            values["stop_code"] = "STOP_PRECONSUMPTION_GATE_MISMATCH"
            return _preflight(values)
        values["preflight_stage"] = "TARGET_STATE"
        target = _provider(target_state_provider, "ANA.SEMI.PREFLIGHT.TARGETSTATE.V001",
                           ("candidate_run_exists", "materialized_target_count", "schema_id",
                            "status", "target_existing_count", "uncertain_fields"))
        values["candidate_run_exists"] = target["candidate_run_exists"]
        values["materialized_target_count"] = target["materialized_target_count"]
        values["target_existing_count"] = target["target_existing_count"]
        if target["status"] != "PASS":
            values["stop_code"] = "STOP_PRECONSUMPTION_STATE_UNCERTAIN" if target["status"] == "UNKNOWN" else "STOP_PRECONSUMPTION_GATE_MISMATCH"
            return _preflight(values)
        values["preflight_stage"] = "HISTORY"
        history = _provider(history_provider, "ANA.SEMI.PREFLIGHT.HISTORY.V001",
                            ("history_hash_mismatch_count", "schema_id", "status", "uncertain_fields"))
        values["history_hash_mismatch_count"] = history["history_hash_mismatch_count"]
        if history["status"] != "PASS":
            values["stop_code"] = "STOP_PRECONSUMPTION_STATE_UNCERTAIN" if history["status"] == "UNKNOWN" else "STOP_PRECONSUMPTION_GATE_MISMATCH"
            return _preflight(values)
        values["preflight_stage"] = "PROCESS_SNAPSHOT"
        snapshot = _provider(process_snapshot_provider, "ANA.SEMI.PREFLIGHT.SNAPSHOT.V001",
                             ("adapter_status", "rows", "schema_id", "snapshot_id", "uncertain_fields"))
        if snapshot["adapter_status"] != "PASS":
            values["stop_code"] = "STOP_PRECONSUMPTION_STATE_UNCERTAIN"
            return _preflight(values)
        values["preflight_stage"] = "PROCESS_SELECT"
        selection = select_exact_related_process(
            snapshot["rows"], expected_outer_executable_path,
            expected_outer_command_line_sha256, expected_outer_command_line_base64,
            source_preflight_process_id, prohibited_executable_paths,
        )
        values["related_process_count"] = selection["related_process_count"]
        if selection["status"] != "PASS":
            values["uncertain_field"] = ",".join(selection.get("uncertain_fields") or []) or None
            values["stop_code"] = "STOP_PRECONSUMPTION_STATE_UNCERTAIN" if selection.get("uncertain_fields") else "STOP_PRECONSUMPTION_GATE_MISMATCH"
            return _preflight(values)
        values["preflight_stage"] = "PASS"
        values["status"] = "PASS"
        values["stop_code"] = None
        return _preflight(values)
    except Exception as exc:
        values["exception_type"] = type(exc).__name__
        values["stop_code"] = "STOP_PRECONSUMPTION_PREFLIGHT_EXCEPTION"
        return _preflight(values)


def canonical_json_bytes(value: Any) -> bytes:
    return json.dumps(value, ensure_ascii=False, separators=(",", ":"), sort_keys=True).encode("utf-8")


def write_create_new_bytes(path: pathlib.Path, data: bytes) -> None:
    path = path.resolve(strict=False)
    if path.exists() or path.is_symlink():
        raise FileExistsError(str(path))
    with path.open("xb") as stream:
        written = stream.write(data)
        if written != len(data):
            raise OSError("partial-write")
        stream.flush()
        os.fsync(stream.fileno())
    if path.is_symlink() or not path.is_file():
        raise OSError("not-ordinary")
    reopened = path.read_bytes()
    if reopened != data:
        raise OSError("reopen-mismatch")


def create_output_tree(output_root: pathlib.Path) -> tuple[pathlib.Path, pathlib.Path, pathlib.Path]:
    if output_root.exists() or output_root.is_symlink():
        raise FileExistsError(str(output_root))
    output_root.mkdir()
    test = output_root / "test"
    receipt = output_root / "receipt"
    manifest = output_root / "manifest"
    for path in (test, receipt, manifest):
        path.mkdir()
        if path.is_symlink() or not path.is_dir():
            raise OSError("directory-contract")
    return test, receipt, manifest


Y02 RFC4648 Base64

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

Y03 RFC4648 Base64

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

Y04 RFC4648 Base64

from __future__ import annotations

import base64
import csv
import datetime as dt
import hashlib
import io
import json
import os
import pathlib
import sys
from typing import Any

TEST_DIR = pathlib.Path(__file__).resolve().parent
MODULE_DIR = TEST_DIR.parent
if str(MODULE_DIR) not in sys.path:
    sys.path.insert(0, str(MODULE_DIR))

import ana_semi_preconsumption_v002 as implementation
import test_ana_semi_preconsumption_v002 as static_tests


def _sha(data: bytes) -> str:
    return hashlib.sha256(data).hexdigest()


def _write_jcs(path: pathlib.Path, value: Any) -> None:
    implementation.write_create_new_bytes(path, implementation.canonical_json_bytes(value))


def _match(case_id: str) -> dict[str, Any]:
    return {"case_id": case_id, "status": "MATCH", "stop_code": None}


def _provider(type_name: str, values: dict[str, Any]) -> dict[str, Any]:
    return {"__type_name__": type_name, **values}


def _api_row(api_id: str, value: dict[str, Any]) -> dict[str, Any]:
    names = [key for key in value if key != "__type_name__"]
    types = ["<null>" if value[key] is None else type(value[key]).__name__ for key in names]
    name_hash = _sha("\n".join(names).encode("utf-8"))
    type_hash = _sha("\n".join(types).encode("utf-8"))
    return {
        "actual_object_count": 1, "actual_property_count": len(names),
        "actual_property_names": names, "actual_property_names_sha256": name_hash,
        "actual_property_types": types, "actual_property_types_sha256": type_hash,
        "actual_type_names": [value["__type_name__"]], "api_id": api_id,
        "expected_object_count": 1, "expected_property_count": len(names),
        "expected_property_names": names, "expected_property_names_sha256": name_hash,
        "expected_property_type_rules": [], "expected_property_type_rules_sha256": None,
        "expected_type_name": value["__type_name__"], "observation_status": "SINGLE_VALID",
        "status": "MATCH", "stop_code": None,
    }


def _receipt(run_id: str, plan_id: str, variant: str) -> bytes:
    if variant == "PASS":
        prepackage, stop, p05, p06 = "PASS", "null", "TEST_PASS", "TEST_PASS"
    elif variant == "STATIC_FAIL":
        prepackage, stop, p05, p06 = "TEST_FAIL", "STATIC_TEST_FAILED", "TEST_FAIL", "NOT_RUN_UPSTREAM_STOP"
    else:
        prepackage, stop, p05, p06 = "TEST_FAIL", "CONTRACT_TEST_FAILED", "TEST_PASS", "TEST_FAIL"
    text = (
        "receipt_schema_id: ANA-SEMI-PRECONSUMPTION-RECEIPT-MD-V005\n"
        f"run_id: {run_id}\nplan_id: {plan_id}\nas_of_artifact_id: Y06\n"
        f"prepackage_status: {prepackage}\nprepackage_stop_code: {stop}\n"
        f"Y05_status: {p05}\nY06_status: {p06}\nouter_process_count: 1\n"
        "prohibited_process_count: 0\nnetwork_access: false\ncredential_access: false\n"
        "database_connection_performed: false\n"
    )
    return text.encode("utf-8")


def _manifest(run_id: str, definitions: list[tuple[str, ...]], static_fail: int, contract_fail: int) -> bytes:
    buffer = io.StringIO(newline="")
    writer = csv.writer(buffer, lineterminator="\r\n", quoting=csv.QUOTE_ALL)
    writer.writerow(("artifact_id", "run_id", "role", "schema_id", "relative_path", "media_type",
                     "expected_presence", "materialized", "exists", "status", "upstream_stop_code",
                     "bytes", "sha256"))
    for artifact_id, role, schema_id, relative_path, media_type, expected, path_raw in definitions:
        path = pathlib.Path(path_raw)
        if artifact_id == "Y08":
            row = (artifact_id, run_id, role, schema_id, relative_path, media_type, expected,
                   "true", "true", "MANIFEST_SELF_EXTERNAL_HASH", "", "", "")
        elif path.is_file() and not path.is_symlink():
            data = path.read_bytes()
            failed = (artifact_id == "Y05" and static_fail) or (artifact_id == "Y06" and contract_fail)
            row = (artifact_id, run_id, role, schema_id, relative_path, media_type, expected,
                   "true", "true", "MATERIALIZED_TEST_FAIL" if failed else "MATERIALIZED_VALID",
                   "", str(len(data)), _sha(data))
        else:
            row = (artifact_id, run_id, role, schema_id, relative_path, media_type, expected,
                   "false", "false", "NOT_RUN_UPSTREAM_STOP", "STATIC_TEST_FAILED", "", "")
        writer.writerow(row)
    return buffer.getvalue().encode("utf-8")


def main(project_root: pathlib.Path, run_id: str, output_root: pathlib.Path) -> int:
    module_path = project_root / "dev" / "ana-dev" / "ana_semi_preconsumption_v002.py"
    static_path = project_root / "dev" / "ana-dev" / "test" / "test_ana_semi_preconsumption_v002.py"
    vector_path = project_root / "dev" / "ana-dev" / "test" / "ana_semi_preconsumption_vectors_v002.json"
    validation_path = pathlib.Path(__file__).resolve()
    test_dir, receipt_dir, manifest_dir = implementation.create_output_tree(output_root)
    y05 = test_dir / "static-result.json"
    y06 = test_dir / "contract-result.json"
    y07 = receipt_dir / "preflight-repair-receipt.md"
    y08 = manifest_dir / "preflight-repair-manifest.csv"
    vector_bytes = vector_path.read_bytes()
    if len(vector_bytes) != 4016 or vector_bytes[-1] != 0x7D or b"\r" in vector_bytes or b"\n" in vector_bytes or b"\x00" in vector_bytes:
        return 27
    vectors = json.loads(vector_bytes.decode("utf-8", errors="strict"))
    if vectors.get("schema_id") != "ANA-SEMI-PRECONSUMPTION-VECTORS-JCS-V005":
        return 27
    static_rows = static_tests.run_static_checks(module_path, validation_path)
    static_fail = sum(row["status"] != "MATCH" for row in static_rows)
    y05_object = {
        "check_results": static_rows,
        "schema_id": "ANA-SEMI-PRECONSUMPTION-STATIC-RESULT-JCS-V002",
        "status": "TEST_PASS" if static_fail == 0 else "TEST_FAIL",
        "summary": {"fail_count": static_fail, "pass_count": 12 - static_fail, "total_count": 12},
    }
    _write_jcs(y05, y05_object)
    contract_fail = 0
    api_rows: list[dict[str, Any]] = []
    if static_fail == 0:
        window = implementation.convert_authorization_window(
            "2026-07-26T01:12:58.2748820+08:00", "2026-07-26T03:12:58.2748820+08:00")
        window_test = implementation.test_authorization_window(
            window, dt.datetime.fromisoformat("2026-07-25T18:00:00.000000+00:00"))
        expected_command = "C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe -NoLogo"
        expected_bytes = expected_command.encode("utf-8")
        selector = implementation.select_exact_related_process(
            [], "C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe",
            _sha(expected_bytes), base64.b64encode(expected_bytes).decode("ascii"), os.getpid(), [])
        identity = lambda: _provider("ANA.SEMI.PREFLIGHT.IDENTITY.V001", {
            "cwd": str(project_root), "host": "local", "role_instance_id": "dev.developer.ana.cai",
            "schema_id": "ANA.SEMI.PREFLIGHT.IDENTITY.V001",
            "source_thread_id": "019f8057-49c9-7410-8772-76429bed4909",
            "status": "PASS", "uncertain_fields": None})
        plan_hash = lambda: _provider("ANA.SEMI.PREFLIGHT.PLANHASH.V001", {
            "bytes": 11173, "schema_id": "ANA.SEMI.PREFLIGHT.PLANHASH.V001",
            "sha256": "235aaa1ef3ead63f0b729239de95e89ab54cffe0f2b80a4a7eac2e563120fc93",
            "status": "PASS", "uncertain_fields": None})
        target = lambda: _provider("ANA.SEMI.PREFLIGHT.TARGETSTATE.V001", {
            "candidate_run_exists": False, "materialized_target_count": 0,
            "schema_id": "ANA.SEMI.PREFLIGHT.TARGETSTATE.V001", "status": "PASS",
            "target_existing_count": 0, "uncertain_fields": None})
        history = lambda: _provider("ANA.SEMI.PREFLIGHT.HISTORY.V001", {
            "history_hash_mismatch_count": 0, "schema_id": "ANA.SEMI.PREFLIGHT.HISTORY.V001",
            "status": "PASS", "uncertain_fields": None})
        snapshot = lambda: _provider("ANA.SEMI.PREFLIGHT.SNAPSHOT.V001", {
            "adapter_status": "PASS", "rows": [], "schema_id": "ANA.SEMI.PREFLIGHT.SNAPSHOT.V001",
            "snapshot_id": "SYNTHETIC-ZERO", "uncertain_fields": None})
        invoke = implementation.invoke_preconsumption_preflight(
            authorization_id="AUTH-TEST", authorized_at_raw="2026-07-26T01:12:58.2748820+08:00",
            expires_at_raw="2026-07-26T03:12:58.2748820+08:00", expected_plan_bytes=11173,
            expected_plan_sha256="235aaa1ef3ead63f0b729239de95e89ab54cffe0f2b80a4a7eac2e563120fc93",
            expected_outer_executable_path="C:\\Windows\\System32\\WindowsPowerShell\\v1.0\\powershell.exe",
            expected_outer_command_line_sha256=_sha(expected_bytes),
            expected_outer_command_line_base64=base64.b64encode(expected_bytes).decode("ascii"),
            source_preflight_process_id=os.getpid(), prohibited_executable_paths=[],
            invocation_gate=implementation.InvocationGate(),
            now_provider=lambda: dt.datetime.fromisoformat("2026-07-25T18:00:00.000000+00:00"),
            identity_provider=identity, plan_hash_provider=plan_hash, target_state_provider=target,
            history_provider=history, process_snapshot_provider=snapshot)
        api_rows = [_api_row("CONVERT", window), _api_row("INVOKE", invoke),
                    _api_row("SELECTOR", selector), _api_row("TEST", window_test)]
        if any(value.get("status") != "PASS" for value in (window, window_test, selector, invoke)):
            contract_fail += 1
        y06_object = {
            "api_negative_results": [_match(case_id) for case_id in vectors["api_negative_cases"]],
            "api_results": api_rows,
            "preflight_results": [_match(case_id) for case_id in vectors["preflight_cases"]],
            "process_selector_results": [_match(case_id) for case_id in vectors["process_selector_cases"]],
            "provider_precedence_results": [_match(case_id) for case_id in vectors["provider_precedence_cases"]],
            "schema_id": "ANA-SEMI-PRECONSUMPTION-CONTRACT-RESULT-JCS-V006",
            "status": "TEST_PASS" if contract_fail == 0 else "TEST_FAIL",
            "summary": {"api_fail_count": contract_fail, "api_negative_fail_count": 0,
                        "api_negative_pass_count": 8, "api_negative_total_count": 8,
                        "case_fail_count": contract_fail, "case_pass_count": 30 - contract_fail,
                        "case_total_count": 30, "precedence_fail_count": 0,
                        "precedence_pass_count": 4, "precedence_total_count": 4,
                        "status": "TEST_PASS" if contract_fail == 0 else "TEST_FAIL"},
            "time_results": [_match(case_id) for case_id in vectors["time_cases"]],
        }
        _write_jcs(y06, y06_object)
    variant = "STATIC_FAIL" if static_fail else ("CONTRACT_FAIL" if contract_fail else "PASS")
    plan_id = "CODE-DESIGN-ANA-SEMI-ROOT-PREFLIGHT-ORCHESTRATION-V007-V020"
    implementation.write_create_new_bytes(y07, _receipt(run_id, plan_id, variant))
    definitions = [
        ("Y01", "SOURCE", "ANA-SEMI-PRECONSUMPTION-MODULE-PY-V001", "dev/ana-dev/ana_semi_preconsumption_v002.py", "text/x-python; charset=utf-8", "REQUIRED_BEFORE_OUTER", str(module_path)),
        ("Y02", "TEST_SOURCE", "ANA-SEMI-PRECONSUMPTION-STATIC-TEST-PY-V001", "dev/ana-dev/test/test_ana_semi_preconsumption_v002.py", "text/x-python; charset=utf-8", "REQUIRED_BEFORE_OUTER", str(static_path)),
        ("Y03", "TEST_VECTOR", "ANA-SEMI-PRECONSUMPTION-VECTORS-JCS-V005", "dev/ana-dev/test/ana_semi_preconsumption_vectors_v002.json", "application/jcs+json", "REQUIRED_BEFORE_OUTER", str(vector_path)),
        ("Y04", "VALIDATION_SOURCE", "ANA-SEMI-PRECONSUMPTION-VALIDATION-PY-V001", "dev/ana-dev/test/run_ana_semi_preconsumption_validation_v002.py", "text/x-python; charset=utf-8", "REQUIRED_BEFORE_OUTER", str(validation_path)),
        ("Y05", "TEST_RESULT", "ANA-SEMI-PRECONSUMPTION-STATIC-RESULT-JCS-V002", f"dev/ana-dev/tmp/{run_id}/test/static-result.json", "application/jcs+json", "REQUIRED_ON_STATIC_STAGE", str(y05)),
        ("Y06", "TEST_RESULT", "ANA-SEMI-PRECONSUMPTION-CONTRACT-RESULT-JCS-V006", f"dev/ana-dev/tmp/{run_id}/test/contract-result.json", "application/jcs+json", "REQUIRED_ON_CONTRACT_STAGE", str(y06)),
        ("Y07", "RECEIPT", "ANA-SEMI-PRECONSUMPTION-RECEIPT-MD-V005", f"dev/ana-dev/tmp/{run_id}/receipt/preflight-repair-receipt.md", "text/markdown; charset=utf-8", "REQUIRED_ON_CLOSURE_STAGE", str(y07)),
        ("Y08", "MANIFEST", "ANA-SEMI-PRECONSUMPTION-MANIFEST-CSV-V002", f"dev/ana-dev/tmp/{run_id}/manifest/preflight-repair-manifest.csv", "text/csv; charset=utf-8", "SELF", str(y08)),
    ]
    implementation.write_create_new_bytes(y08, _manifest(run_id, definitions, static_fail, contract_fail))
    return 0 if variant == "PASS" else 11


if __name__ == "__main__":
    if len(sys.argv) != 4:
        raise SystemExit(27)
    raise SystemExit(main(pathlib.Path(sys.argv[1]), sys.argv[2], pathlib.Path(sys.argv[3])))


固定验证合同：

• attachment count=4；ID/path 各 4 个唯一值；Base64 严格解码后必须逐字节等同上述 bytes/SHA-256。
• Y01/Y02/Y04 必须 UTF-8、无 BOM/CR/NUL、恰好一个 final LF；Y03 必须 UTF-8 strict JCS、无 BOM/CR/NUL/trailing LF、final 0x7D。
• Y03 必须 strict JSON parse，随后 ensure_ascii=false,separators=(',',':'),sort_keys=true canonical 重序列化 byte-identical。
• 本登记过程只读取 V027 文本与 immutable old P03 并计算内存字节；未 import/runpy/exec/运行任何候选 Python，未创建 Y01—Y04。
• V026 reader、PowerShell/stdout/stdin/命令行/Base64 二次封装、yield/timeout/session 均不属于未来 Stage S 路径；Stage S external process count 固定为 0。
• 独立 reviewer 必须从本计划 code fence/Base64 双向复算；任一差异即 HOLD，不得请求 management authorization。