Blame for code/export_evidence.py

"""Whitelist-only export of the Coder390/Fable MLX and deployment study.

Reads private raw evidence under the lab and writes finite, path-free JSON.
Never copies prompts, tool output, repository source, transcripts, credentials
or local absolute paths into the public artifact.
"""
from __future__ import annotations

import hashlib
import json
import math
import re
import sys
from pathlib import Path

ROOT = Path(__file__).resolve().parents[3]  # real-agent-lab
LOCAL = ROOT / "coder390" / "mlx-native" / "raw"
FABLE = ROOT / "fable" / "deployment" / "raw"
GUARD = ROOT / "fable" / "memory-guard-fix" / "raw"

RUN_ID = re.compile(r"^[A-Za-z0-9_\-.]{1,120}$")
DENY = ("/Users/", "/Volumes/", "hf_", "sk-", "Bearer ", "api-key", "api_key", "token=", "@")
PRIVATE_BLOB_MARKERS = ("/Users/", "/Volumes/", "sk-", "hf_", "Bearer ", "api-key", "api_key")


def assert_public(blob):
    """Refuse any serialized artifact carrying a private marker."""
    for bad in PRIVATE_BLOB_MARKERS:
        if bad in blob:
            raise ValueError(f"refusing to export private marker: {bad}")
    return blob


def finite(value, label):
    if value is None:
        return None
    if type(value) is bool:
        raise ValueError(f"{label}: boolean where number expected")
    if type(value) not in (int, float) or not math.isfinite(value):
        raise ValueError(f"{label}: non-finite numeric metric")
    return value


def flag(value, label):
    if value is None:
        return None
    if type(value) is not bool:
        raise ValueError(f"{label}: non-boolean flag")
    return value


def text(value, label, limit=200):
    if value is None:
        return None
    if not isinstance(value, str):
        raise ValueError(f"{label}: not a string")
    if any(bad in value for bad in DENY):
        raise ValueError(f"{label}: contains a private marker")
    return value[:limit]


def read(rel, base=LOCAL):
    path = base / rel if not str(rel).startswith("/") else Path(rel)
    if not path.is_file():
        raise FileNotFoundError(str(rel))
    return path, path.read_bytes()


def load(rel, base=LOCAL):
    _, raw = read(rel, base)
    return json.loads(raw)


def digest(rel, base=LOCAL):
    _, raw = read(rel, base)
    return hashlib.sha256(raw).hexdigest()


def windows(base, prefix):
    """Summarize owned inference-window receipts without local paths."""
    out = []
    for path in sorted(base.glob(prefix + "*/window.json")):
        row = json.loads(path.read_text())
        name = path.parent.name
        if not RUN_ID.match(name):
            raise ValueError("unsafe window name")
        out.append({
            "window": name,
            "restored": flag(row.get("restored"), "window.restored"),
            "worker_returncode": finite(row.get("worker_returncode"), "window.returncode"),
            "timed_out": flag(row.get("timed_out"), "window.timed_out"),
            "blocked_before_unload": row.get("phase") == "blocked_before_unload",
        })
    return out


def trial_rows(record):
    rows = []
    for trial in record.get("trials", []):
        if not isinstance(trial, dict):
            continue
        label = text(trial.get("label") or trial.get("arm") or "trial", "trial.label", 80)
        spec = trial.get("spec_message") or trial.get("speculative_stats") or ""
        rows.append({
            "label": label,
            "prompt_tokens": finite(trial.get("prompt_tokens"), "trial.prompt_tokens"),
            "generated_tokens": finite(
                trial.get("generation_tokens_including_reasoning_and_tool")
                or trial.get("num_tokens"), "trial.generated_tokens"),
            "client_ttft_s": finite(trial.get("client_ttft_s") or trial.get("first_text_ttft_s"), "trial.ttft"),
            "whole_request_s": finite(trial.get("whole_request_s") or trial.get("measured_whole_request_s"), "trial.wall"),
            "decode_tps": finite(trial.get("decode_tps") or trial.get("reported_generation_tps"), "trial.decode"),
            "prompt_tps": finite(trial.get("reported_prompt_tps"), "trial.prompt_tps"),
            "prefill_s": finite(trial.get("prefill_seconds"), "trial.prefill"),
            "finish_reason": text(trial.get("finish_reason"), "trial.finish", 24),
            "mean_accept_len": finite(trial.get("mean_accept_len") or trial.get("mean_accept"), "trial.accept"),
            "speculative": bool(spec) if spec is not None else None,
            "peak_memory_gb": finite(trial.get("peak_memory_gb_decimal") or trial.get("peak_memory_gb"), "trial.peak"),
        })
    return rows


def build():
    summary = load("continued-acceleration-reviewed.json")
    mlx = load("mlx-trial-reviewed-summary.json")
    conversion = load("output-verification.json")
    parity = load("real-tensor-parity.json")
    layout = load("strict-module-layout.json")
    tokproof = load("tokenizer-processor-proof.json")
    mtp = load("mtp-verification.json")
    source_layout = load("source-layout-audit.json")
    cpu = load("cpu-arithmetic-proof.json")
    audit = load("final-trial-service-audit.json")
    contention = load("contention-timing.json")

    cutover = load("cutover-receipt.json", FABLE)
    final_cutover = load("final-cutover-audit.json", FABLE)
    cleanup = load("retired-abliterated-cleanup-receipt.json", FABLE)
    image_handoff = load("image-handoff-proof.json", FABLE)
    switch = load("normal-and-fable-switch-proof.json", FABLE)
    live_api = load("live-api-proof.json", FABLE)
    live_svc = load("live-service-proof.json", FABLE)
    mem_policy = load("memory-policy-before.json", FABLE)
    mem_refusal = load("pi-prefill128-proof.json", FABLE)
    final_audit = load("final-cutover-audit.json", FABLE)

    guard_state = load("final-state.json", GUARD)
    guard_protocol = load("protocol-proof.json", GUARD)
    guard_stream = load("stream-protocol-proof.json", GUARD)
    guard_pi = load("pi-full-route-proof.json", GUARD)

    # Per-condition synthetic 8k comparisons, in declared arm order.
    conditions = []
    for name, note in [
        ("vlm-bf16-8k-mtp-r2", "official mlx-vlm, source MTP depth 3"),
        ("dspark-dflash-8k-cpuoff-r3", "mlx-dspark 0.19.0 DFlash2, cpu co-prefill off"),
        ("dspark0203-dflash-8k-r5", "mlx-dspark 0.20.3 DFlash2, newer kernels"),
        ("dspark019-dflash-8k-prefill2048-r6", "mlx-dspark 0.19.0 DFlash2, 2048-row prefill"),
    ]:
        rec = load(f"{name}/results.json")
        conditions.append({
            "condition": name,
            "note": note,
            "engine": text(rec.get("engine") or rec.get("runtime"), "engine", 120),
            "input_tokens": finite(rec.get("actual_input_tokens") or
                                   (rec.get("trials") or [{}])[0].get("prompt_tokens"), "input_tokens"),
            "prefill_chunk": finite(rec.get("prefill_chunk"), "prefill_chunk"),
            "draft_cap": finite(rec.get("derived_draft_cap"), "draft_cap"),
            "greedy_token_parity": flag(rec.get("greedy_token_parity"), "parity"),
            "trials": trial_rows(rec),
        })

    # Actual agent repairs with speculation (private clones, sanitized scalars).
    repairs = []
    for name in ("mtp-bf16-real-repair-r3", "dflash-bf16-real-repair-r4"):
        rec = load(f"{name}/repair.summary.json")
        turns = rec.get("turns") or []
        repairs.append({
            "run": name,
            "speculation": text(rec.get("speculation"), "speculation", 24),
            "trained_mtp": flag(rec.get("trained_mtp"), "trained_mtp"),
            "completed": flag(rec.get("completed"), "completed"),
            "elapsed_s": finite(rec.get("elapsed_s"), "elapsed_s"),
            "timed_out": flag(rec.get("timed_out"), "timed_out"),
            "tool_calls": finite(rec.get("tool_calls"), "tool_calls"),
            "tool_errors": finite(rec.get("tool_errors"), "tool_errors"),
            "independent_gate_pass": flag(rec.get("independent_gate_pass"), "gate"),
            "full_suite_pass": flag(rec.get("full_suite_pass"), "suite"),
            "source_restored": flag(rec.get("source_restored"), "restored"),
            "context_capacity_configured": finite(rec.get("context_capacity_configured"), "context"),
            "actual256k_qualified": flag(rec.get("actual256k_qualified"), "actual256k"),
            "initial_input_tokens": finite(turns[0]["usage"]["input"], "first_input") if turns else None,
            "initial_ttft_s": finite(turns[0].get("ttft_s"), "first_ttft") if turns else None,
            "turn_decode_tps": [finite(t.get("decode_tps"), "turn decode") for t in turns],
        })

    artifact = {
        "schema_version": 1,
        "title": "Fable MLX migration and native memory-policy study (sanitized evidence)",
        "authors": ["Chengyi Xu", "Nexora"],
        "brand": "Nexora Research",
        "scope": (
            "Descriptive deployment engineering on one Apple M4 Max 64 GiB host. "
            "Whitelisted finite scalars only; no prompts, tool output, repository "
            "source, transcripts, credentials or local absolute paths."
        ),
        "qualification": {
            "minimum_20_tps_met": False,
            "actual_near_limit_context_met": False,
            "peer_review_claimed": False,
            "ranked_intelligence_claimed": False,
        },
        "checkpoint": {
            "conversion": conversion,
            "nonquantized_tensor_parity": parity.get("raw_tensor_full_element_parity"),
            "quantized_rows_verified": parity.get("quantized_linears_sampled"),
            "module_layout": {k: layout.get(k) for k in
                              ("module_parameters", "checkpoint_tensors", "missing", "extra")},
            "tokenizer": {k: tokproof.get(k) for k in
                          ("tokenizer_parity_cases", "chat_template_parity", "vocab_size")},
            "mtp_tensors": len(mtp.get("files", {})),
            "source_tensor_categories": source_layout.get("categories_source_bytes"),
            "cpu_arithmetic": {
                "probes": cpu.get("probes"),
                "full_model_loaded": cpu.get("full_model_loaded"),
            },
        },
        "synthetic_conditions": conditions,
        "speculative_repairs": repairs,
        "reviewed_summary": {
            "smoke_plain_tps": mlx["smoke"]["plain_generation_tps"],
            "smoke_mtp_tps": mlx["smoke"]["mtp_generation_tps"],
            "smoke_greedy_parity": mlx["smoke"]["greedy_token_parity"],
            "short_input_tokens": 74,
            "repair_backend_metrics": mlx.get("actual_repair_backend_metrics"),
            "all_windows_restored": mlx.get("all_executed_windows_restored"),
        },
        "memory_policy": {
            "observed": {
                "kernel_free_target_bytes": mem_policy["kernel_free_target_bytes"],
                "floors": mem_policy["floors"],
                "compressor_bytes": mem_policy["live_reading"]["compressor_bytes"],
                "available_bytes": mem_policy["live_reading"]["available_bytes"],
                "free_bytes": mem_policy["live_reading"]["free_bytes"],
            },
            "refusal_before_switch": {
                "completed": mem_refusal.get("completed"),
                "prefill_chunk": mem_refusal.get("prefill_chunk"),
                "error_class": "runtime prefill system-memory guard",
            },
            "after_supported_switch_off": {
                "same_input_tokens": guard_pi["messages"][0]["usage"]["input"] if guard_pi.get("messages") else None,
                "completed": guard_pi.get("completed"),
                "elapsed_s": guard_pi.get("elapsed_s"),
                "exact_marker": guard_pi["messages"][0]["text"] if guard_pi.get("messages") else None,
                "prompt_reduced": False,
            },
            "effective_child_setting": guard_state["native_child_env"],
        },
        "protocol_matrix": {
            "non_streaming": [{"endpoint": r["endpoint"], "protocol": r["protocol"],
                               "status": r["status"], "passed": r["passed"]}
                              for r in guard_protocol["results"]],
            "streaming": [{"endpoint": r["endpoint"], "protocol": r["protocol"],
                           "status": r["status"], "terminal_received": r["terminal_received"],
                           "passed": r["passed"]} for r in guard_stream],
        },
        "deployment": {
            "cutover_ready": cutover.get("fable_ready"),
            "unrelated_providers_identical": cutover.get("unrelated_provider_records_identical"),
            "context_window": final_cutover.get("context_window"),
            "mtp_depth": final_cutover.get("mtp_depth"),
            "runtime_profile": final_cutover.get("runtime_profile"),
            "prefill_chunk": final_cutover.get("prefill_chunk"),
            "live_backend_reply_ok": bool(live_api.get("backend_answer")),
            "live_gateway_reply_ok": bool(live_api.get("magpie_answer")),
            "service_idle_verified": live_svc.get("idle_verified"),
            "image_handoff_restored": image_handoff.get("restored"),
            "normal_switch_verified": switch.get("normal_start_verified"),
            "retired_logical_bytes": cleanup.get("logical_bytes"),
            "retired_entry_count": len(cleanup.get("deleted", [])),
        },
        "windows_restored": {
            "coder390_mlx": windows(LOCAL, ""),
            "fable_deployment": windows(FABLE, ""),
        },
        "contention": {
            "external_start_estimated_during_window": contention.get(
                "external_start_estimated_during_window"),
            "exclusive_execution_proven": contention.get("exclusive_execution_proven"),
        },
        "final_state": {
            "fable_promoted": audit.get("candidate_promoted"),
            "near_limit_qualified": final_audit.get("near_limit_context_qualified"),
            "trial_ports_closed": final_audit.get("experiment_ports_closed") or
                                 audit.get("lab_ports_closed"),
        },
    }

    # Every string is already vetted by text(); assert no absolute path escaped.
    blob = json.dumps(artifact, indent=2, sort_keys=False)
    return assert_public(blob), artifact


def main():
    dest = Path(sys.argv[1])
    try:
        blob, _artifact = build()
    except ValueError as error:
        raise SystemExit(str(error)) from None
    dest.parent.mkdir(parents=True, exist_ok=True)
    dest.write_text(blob + "\n")
    print(f"wrote {dest}")


if __name__ == "__main__":
    main()