"""G4 FL2VA conditioning determinism Gate (evidence-only, no Sampling).""" from __future__ import annotations import argparse import hashlib import json from pathlib import Path import sys from typing import Any, Mapping import uuid TOOLS_ROOT = Path(__file__).resolve().parent if str(TOOLS_ROOT) not in sys.path: sys.path.insert(0, str(TOOLS_ROOT)) from p32_api_runner import submit_and_wait CHECKPOINTS = ("P0", "P1", "P2", "P3", "P4", "P5", "P6", "P7") FIRST_IMAGE = "20260830030614-Anima-Luc_v2_00008_-1635935150-ER SDE.webp" VIDEO_VAE = "minimax_h3_video_vae_fp16.safetensors" CLIP = "qwen3vl_32b_minimax_h3_nvfp4_awq.safetensors" PROMPT = ( "A continuous cinematic shot begins from the supplied First Image. " "The subject moves naturally while identity, clothing, lighting, camera " "direction, footsteps, and ambience remain coherent." ) class GateFailure(RuntimeError): pass def _write(path: Path, value: Any) -> None: path.parent.mkdir(parents=True, exist_ok=True) path.write_text(json.dumps(value, indent=2, ensure_ascii=False), encoding="utf-8") def _sha256_file(path: Path) -> str: digest = hashlib.sha256() with path.open("rb") as stream: for block in iter(lambda: stream.read(1024 * 1024), b""): digest.update(block) return digest.hexdigest() def _prompt(*, context: str, focus_mode: str, nonce: int) -> dict[str, Any]: return { "1": { "class_type": "LoadImage", "inputs": {"image": FIRST_IMAGE}, "_meta": {"title": "LoadImage"}, }, "2": { "class_type": "VAELoader", "inputs": {"vae_name": VIDEO_VAE}, "_meta": {"title": "Video VAE"}, }, "3": { "class_type": "CLIPLoader", "inputs": {"clip_name": CLIP, "type": "minimax", "device": "default"}, "_meta": {"title": "MiniMax H3 Text Encoder"}, }, "4": { "class_type": "H3G4ConditioningDeterminismDiagnostic", "inputs": { "video_vae": ["2", 0], "clip": ["3", 0], "first_image": ["1", 0], "prompt": PROMPT, "width": 544, "height": 544, "frame_count": 124, "execution_context": context, "focus_mode": focus_mode, "diagnostic_nonce": int(nonce), }, "_meta": {"title": "G4 Conditioning Determinism Collector"}, }, } def _extract(history: Mapping[str, Any], prompt_id: str) -> dict[str, Any]: record = history.get(prompt_id) if not isinstance(record, Mapping): raise GateFailure(f"history record missing for {prompt_id}") outputs = record.get("outputs") if not isinstance(outputs, Mapping): raise GateFailure("history outputs are missing") node = outputs.get("4") if not isinstance(node, Mapping): raise GateFailure("diagnostic node output is missing") text = node.get("text") if not isinstance(text, list) or len(text) != 1: raise GateFailure(f"unexpected diagnostic text output: {text!r}") result = json.loads(str(text[0])) if result.get("format") != "h3-v38-g4-conditioning-determinism-v1": raise GateFailure("unexpected diagnostic output format") missing = [key for key in CHECKPOINTS if key not in result.get("checkpoints", {})] if missing: raise GateFailure(f"missing checkpoints: {missing}") return result def _run_case(args, *, name: str, context: str, focus_mode: str, nonce: int) -> dict[str, Any]: case_root = args.evidence_root / args.stage / name prompt = _prompt(context=context, focus_mode=focus_mode, nonce=nonce) _write(case_root / "prompt.json", prompt) print(f"G4 diagnostic start: {name}", flush=True) prompt_id, history, elapsed = submit_and_wait( server=args.server, prompt=prompt, client_id=f"g4diag-{uuid.uuid4().hex}", timeout_seconds=float(args.timeout_seconds), poll_seconds=float(args.poll_seconds), ) _write(case_root / "history.json", history) result = _extract(history, prompt_id) _write(case_root / "result.json", result) output = { "name": name, "prompt_id": prompt_id, "api_elapsed_seconds": elapsed, "prompt": str(case_root / "prompt.json"), "history": str(case_root / "history.json"), "result_path": str(case_root / "result.json"), "result": result, } print(f"G4 diagnostic end: {name}; {elapsed:.3f}s", flush=True) return output def _checkpoint_sha(run: Mapping[str, Any], checkpoint: str) -> str: return str(run["result"]["checkpoints"][checkpoint]["sha256"]) def _compare(left: Mapping[str, Any], right: Mapping[str, Any]) -> dict[str, Any]: rows = {} first = None for checkpoint in CHECKPOINTS: left_sha = _checkpoint_sha(left, checkpoint) right_sha = _checkpoint_sha(right, checkpoint) match = left_sha == right_sha rows[checkpoint] = { "left_sha256": left_sha, "right_sha256": right_sha, "match": match, } if first is None and not match: first = checkpoint return {"first_divergence": first, "checkpoints": rows, "all_match": first is None} def _focus_mode(*firsts: str | None) -> str: if "P2" in firsts: return "vae_repeat" if "P5" in firsts: return "qwen_repeat" return "standard" def _focus_checks(run: Mapping[str, Any]) -> dict[str, Any]: result = run["result"] mode = str(result["focus_mode"]) if mode == "vae_repeat": rows = result["focus"]["vae_repeat"] hashes = [str(row["sha256"]) for row in rows] return {"mode": mode, "hashes": hashes, "all_match": len(set(hashes)) == 1} if mode == "qwen_repeat": rows = result["focus"]["qwen_repeat"] token_hashes = [str(row["tokens"]["sha256"]) for row in rows] cond_hashes = [str(row["conditioning"]["sha256"]) for row in rows] return { "mode": mode, "token_hashes": token_hashes, "conditioning_hashes": cond_hashes, "tokens_all_match": len(set(token_hashes)) == 1, "conditioning_all_match": len(set(cond_hashes)) == 1, } return {"mode": "standard"} def _prepare(args) -> dict[str, Any]: cold = _run_case(args, name="cold_a", context="Cold A", focus_mode="standard", nonce=1) warm = _run_case(args, name="warm_b", context="Warm B", focus_mode="standard", nonce=2) full = _run_case(args, name="full_context", context="Full", focus_mode="standard", nonce=3) review = _run_case(args, name="review_context", context="Review", focus_mode="standard", nonce=4) cold_warm = _compare(cold, warm) full_review = _compare(full, review) mode = _focus_mode(cold_warm["first_divergence"], full_review["first_divergence"]) focus = None focus_checks = None if mode != "standard": focus = _run_case(args, name=mode, context="Warm B", focus_mode=mode, nonce=5) focus_checks = _focus_checks(focus) summary = { "format": "h3-v38-g4-conditioning-determinism-prepare-v1", "stage": "prepare", "server": args.server, "runner_sha256": _sha256_file(Path(__file__)), "runs": {"cold_a": cold, "warm_b": warm, "full": full, "review": review, "focus": focus}, "comparisons": {"cold_vs_warm": cold_warm, "full_vs_review": full_review}, "focus_mode": mode, "focus_checks": focus_checks, } _write(args.evidence_root / "prepare_summary.json", summary) return summary def _classify(prepare: Mapping[str, Any], restart_compare: Mapping[str, Any]) -> dict[str, Any]: cold_first = prepare["comparisons"]["cold_vs_warm"]["first_divergence"] context_first = prepare["comparisons"]["full_vs_review"]["first_divergence"] restart_first = restart_compare["first_divergence"] first = context_first or cold_first or restart_first standalone_first = cold_first or restart_first if standalone_first is None and context_first is not None: case = "CASE F" reason = "standalone repeats match; Full/Review context is the only divergence" elif first in ("P0", "P1"): case = "CASE A" reason = "resize/input path is the first divergence" elif first == "P2": case = "CASE B" reason = "Video VAE identity latent is the first divergence" elif first in ("P3", "P4", "P5", "P6"): case = "CASE C" reason = "Qwen/CLIP image-conditioning path is the first divergence" elif first == "P7": case = "CASE D" reason = "conditioning assembly/keyframe attachment is the first divergence" else: case = "CASE E" reason = "P0-P7 are bit-exact; the G4 hypothesis must move to Sampling or later runtime ordering" return {"case": case, "first_divergence": first, "reason": reason} def _short(value: str) -> str: return value[:12] def _report_markdown(summary: Mapping[str, Any]) -> str: prepare = summary["prepare"] restart = summary["restart_c"] full = prepare["runs"]["full"] review = prepare["runs"]["review"] repeat_cmp = prepare["comparisons"]["cold_vs_warm"] context_cmp = prepare["comparisons"]["full_vs_review"] restart_cmp = summary["comparisons"]["cold_vs_restart"] lines = [ "# G4-Diagnostic FL2VA Conditioning Determinism — STOP Report", "", f"Classification: **{summary['classification']['case']}** ", f"First divergence: **{summary['classification']['first_divergence'] or 'none through P7'}** ", f"Result: {summary['classification']['reason']}", "", "Production code was not changed. GPU Sampling was not executed.", "", "| Checkpoint | Full | Review | Full/Review | Repeat | Restart |", "|---|---:|---:|---|---|---|", ] for checkpoint in CHECKPOINTS: full_sha = _checkpoint_sha(full, checkpoint) review_sha = _checkpoint_sha(review, checkpoint) lines.append( f"| {checkpoint} | `{_short(full_sha)}` | `{_short(review_sha)}` | " f"{'PASS' if context_cmp['checkpoints'][checkpoint]['match'] else 'FAIL'} | " f"{'PASS' if repeat_cmp['checkpoints'][checkpoint]['match'] else 'FAIL'} | " f"{'PASS' if restart_cmp['checkpoints'][checkpoint]['match'] else 'FAIL'} |" ) lines.extend( [ "", "## Focused repeat", "", "```json", json.dumps(prepare.get("focus_checks"), indent=2, ensure_ascii=False), "```", "", "## Runtime state", "", "Cold, warm, Full-context, Review-context, and restart state snapshots are retained in the JSON evidence. Patch UUID creation differences across restart are recorded but are not treated as tensor divergence by themselves.", "", "## Next action", "", "STOP. Present the first divergence, impact, and a minimal branch-specific fix proposal for approval. Do not add caches, deterministic-mode forcing, model reloads, dtype/seed changes, or Run Storage contract changes in this Gate.", "", ] ) return "\n".join(lines) def _restart(args) -> dict[str, Any]: prepare_path = args.evidence_root / "prepare_summary.json" if not prepare_path.is_file(): raise GateFailure(f"prepare summary missing: {prepare_path}") prepare = json.loads(prepare_path.read_text(encoding="utf-8")) restart = _run_case(args, name="restart_c", context="Restart C", focus_mode="standard", nonce=101) cold_restart = _compare(prepare["runs"]["cold_a"], restart) classification = _classify(prepare, cold_restart) summary = { "format": "h3-v38-g4-conditioning-determinism-final-v1", "stage": "stopped", "prepare": prepare, "restart_c": restart, "comparisons": {"cold_vs_restart": cold_restart}, "classification": classification, } _write(args.evidence_root / "g4_conditioning_determinism_summary.json", summary) report = _report_markdown(summary) (args.evidence_root / "G4_CONDITIONING_DETERMINISM_STOP_REPORT.md").write_text( report, encoding="utf-8", ) return summary def parse_args(): parser = argparse.ArgumentParser() parser.add_argument("--stage", choices=("prepare", "restart"), required=True) parser.add_argument("--server", default="http://127.0.0.6:8190") parser.add_argument( "--evidence-root", type=Path, default=Path( r"D:\Codex\_test_results\ComfyUI-H3-Continuum" r"\v38-g4-conditioning-determinism-20260831_150837" ), ) parser.add_argument("--timeout-seconds", type=float, default=1800.0) parser.add_argument("--poll-seconds", type=float, default=1.0) return parser.parse_args() def main() -> int: args = parse_args() args.evidence_root.mkdir(parents=True, exist_ok=True) summary = _prepare(args) if args.stage == "prepare" else _restart(args) print(json.dumps(summary.get("classification", {"stage": args.stage}), ensure_ascii=False), flush=True) return 0 if __name__ == "__main__": raise SystemExit(main())