1661 lines
57 KiB
Python
1661 lines
57 KiB
Python
from __future__ import annotations
|
|
|
|
import hashlib
|
|
from types import SimpleNamespace
|
|
|
|
import pytest
|
|
import torch
|
|
|
|
from ComfyUI_H3_Continuum_Join.run_storage import (
|
|
REVIEW_CONTROL_VERSION,
|
|
RUN_STORAGE_SCHEMA_VERSION,
|
|
SAMPLING_CONTRACT_VERSION,
|
|
RunStorageController,
|
|
RunStorageError,
|
|
_apply_reroll_branch_contract,
|
|
_nonce_lineage_hash,
|
|
_review_contract_mismatches,
|
|
_storage_revision_identity,
|
|
revision_identity,
|
|
)
|
|
from ComfyUI_H3_Continuum_Join.branch_provenance import (
|
|
TAKE_ACTION_CONTINUE,
|
|
TAKE_ACTION_USE,
|
|
physical_groups,
|
|
)
|
|
from ComfyUI_H3_Continuum_Join.state import make_plan
|
|
from ComfyUI_H3_Continuum_Join.v2.seeds import derive_chunk_seed
|
|
from ComfyUI_H3_Continuum_Join.v2.session import make_chunk_entry, make_session
|
|
from ComfyUI_H3_Continuum_Join.v2 import session_io
|
|
from ComfyUI_H3_Continuum_Join.v2.sequence import _preserved_prefix
|
|
from ComfyUI_H3_Continuum_Join.reference import REFERENCE_SIZE_MATCH_OUTPUT
|
|
from ComfyUI_H3_Continuum_Join.v3.reference_routing import (
|
|
REFERENCE_SLOT_IDS, compile_reference_routing_schedule,
|
|
)
|
|
from ComfyUI_H3_Continuum_Join.v3.reference_runtime import (
|
|
ReferenceInputSet, ReferenceRoutingRuntime,
|
|
)
|
|
from ComfyUI_H3_Continuum_Join.v3.reference_storage_contract import (
|
|
build_reference_storage_plan, routed_session_identity, session_routing_settings,
|
|
)
|
|
from ComfyUI_H3_Continuum_Join.v3.nodes import (
|
|
H3ContinuumSamplerProduction,
|
|
H3ContinuumSamplerV3,
|
|
PROJECTION_CURRENT_REVIEW_UNIT,
|
|
PROJECTION_FULL_ACCEPTED_PREFIX,
|
|
_apply_review_decode_scope,
|
|
_review_decode_chunk_range,
|
|
resolve_projection_decision,
|
|
)
|
|
from ComfyUI_H3_Continuum_Join.v3.plan import prepare_physical_decode_entries
|
|
from ComfyUI_H3_Continuum_Join.v3.review_control import (
|
|
GENERATION_MODE_FULL_RUN,
|
|
GENERATION_MODE_REVIEW,
|
|
REVIEW_ACTION_CONTINUE,
|
|
REVIEW_ACTION_FINISH_REMAINING,
|
|
REVIEW_ACTION_REGENERATE_CURRENT,
|
|
REVISION_STATUS_COMPLETE,
|
|
REVISION_STATUS_IN_PROGRESS,
|
|
REVISION_STATUS_INTERRUPTED,
|
|
REVISION_STATUS_REVIEW_READY,
|
|
ReviewControlError,
|
|
)
|
|
|
|
|
|
class _Nested:
|
|
def __init__(self, parts):
|
|
self.parts = parts
|
|
|
|
def unbind(self):
|
|
return self.parts
|
|
|
|
|
|
def _prompt_hashes(chunks: int, tag: str = "base") -> list[str]:
|
|
return [
|
|
hashlib.sha256(f"{tag}-prompt-{index + 1}".encode("utf-8")).hexdigest()
|
|
for index in range(chunks)
|
|
]
|
|
|
|
|
|
def _contract(
|
|
*,
|
|
chunks: int = 6,
|
|
boundary: int = 0,
|
|
nonce: int = 0,
|
|
terminal: bool = False,
|
|
prompt_tag: str = "base",
|
|
reference_tag: str | None = None,
|
|
driving_tag: str | None = None,
|
|
) -> dict:
|
|
global_contract = {
|
|
"sampling_contract_version": SAMPLING_CONTRACT_VERSION,
|
|
"conditioning_mode": "t2va",
|
|
"width": 96,
|
|
"height": 64,
|
|
"chunk_seconds": 5.0,
|
|
"continuity": "Balanced — 22 frames",
|
|
"audio_continuity": True,
|
|
"base_seed": 1234,
|
|
}
|
|
if terminal:
|
|
global_contract["execution_semantics"] = {
|
|
"flf_execution": "terminal_merged_10s_seed_v2",
|
|
"terminal_seed_policy": "terminal_pair_seed_v2",
|
|
}
|
|
if reference_tag is not None:
|
|
global_contract["reference"] = {"identity": reference_tag}
|
|
if driving_tag is not None:
|
|
global_contract["driving_audio"] = {"identity": driving_tag}
|
|
contract = {
|
|
"global": global_contract,
|
|
"chunk_count": int(chunks),
|
|
"prompt_mode": "Fixed",
|
|
"prompt_hashes": _prompt_hashes(chunks, prompt_tag),
|
|
"reroll_from_chunk": int(boundary),
|
|
"last_frame_hash": "",
|
|
}
|
|
contract["nonce_lineage_sha256"] = _nonce_lineage_hash(contract)
|
|
return _apply_reroll_branch_contract(
|
|
contract,
|
|
boundary=boundary,
|
|
requested_nonce=nonce,
|
|
effective_nonce=nonce,
|
|
)
|
|
|
|
|
|
def _entry(position: int, contract: dict):
|
|
continuation = position > 0
|
|
plan = make_plan(
|
|
continuation=continuation,
|
|
clip_index=position + 1,
|
|
total_frames=141 if continuation else 124,
|
|
trim_frames=22 if continuation else 0,
|
|
width=96,
|
|
height=64,
|
|
context_frames=22 if continuation else 0,
|
|
state_capacity_frames=39,
|
|
requested_extend_seconds=5,
|
|
debug=False,
|
|
)
|
|
return make_chunk_entry(
|
|
latent={
|
|
"samples": _Nested(
|
|
(
|
|
torch.full(
|
|
(1, 24, 42 if continuation else 37, 2, 2),
|
|
float(position),
|
|
),
|
|
torch.full(
|
|
(1, 32, 2, 235 if continuation else 207),
|
|
float(position),
|
|
),
|
|
)
|
|
)
|
|
},
|
|
plan=plan,
|
|
prompt=f"prompt {position + 1}",
|
|
prompt_hash=contract["prompt_hashes"][position],
|
|
seed=derive_chunk_seed(
|
|
int(contract["global"]["base_seed"]),
|
|
position,
|
|
int(contract["effective_reroll_nonce"])
|
|
if int(contract["reroll_from_chunk"]) > 0
|
|
and position + 1 >= int(contract["reroll_from_chunk"])
|
|
else 0,
|
|
),
|
|
context_frames=22 if continuation else 0,
|
|
motion_score=float(position),
|
|
reused=False,
|
|
)
|
|
|
|
|
|
def _controller(tmp_path, contract: dict) -> RunStorageController:
|
|
controller = RunStorageController("phase-d-review")
|
|
controller.run_root = tmp_path / "run"
|
|
controller.revisions_root = controller.run_root / "revisions"
|
|
controller.contract = contract
|
|
controller.revision_id, controller.contract_sha256 = revision_identity(contract)
|
|
controller.revision_root = controller.revisions_root / controller.revision_id
|
|
controller.prompts = [f"prompt {index + 1}" for index in range(contract["chunk_count"])]
|
|
controller.effective_reroll_nonce = int(contract["effective_reroll_nonce"])
|
|
lifecycle = dict(contract["nonce_lifecycle"])
|
|
controller.manifest = {
|
|
"run_storage_schema_version": RUN_STORAGE_SCHEMA_VERSION,
|
|
"sampling_contract_version": SAMPLING_CONTRACT_VERSION,
|
|
"run_name": controller.run_name,
|
|
"revision_id": controller.revision_id,
|
|
"contract_sha256": controller.contract_sha256,
|
|
"contract": contract,
|
|
"resume_safe": True,
|
|
"resume_disabled_reasons": [],
|
|
"nonce_lifecycle": lifecycle,
|
|
"status": REVISION_STATUS_IN_PROGRESS,
|
|
"created_utc": "2026-08-31T00:00:00+00:00",
|
|
"updated_utc": "2026-08-31T00:00:00+00:00",
|
|
"chunks": [],
|
|
"report_summary": "",
|
|
}
|
|
return controller
|
|
|
|
|
|
def _persist(
|
|
tmp_path,
|
|
contract: dict,
|
|
*,
|
|
prefix: int,
|
|
review_unit: tuple[int, int] | None,
|
|
updated_utc: str,
|
|
) -> RunStorageController:
|
|
controller = _controller(tmp_path, contract)
|
|
entries = [_entry(position, contract) for position in range(prefix)]
|
|
terminal = bool(
|
|
((contract.get("global") or {}).get("execution_semantics") or {}).get(
|
|
"flf_execution"
|
|
) == "terminal_merged_10s_seed_v2"
|
|
)
|
|
for group in physical_groups(
|
|
chunks=int(contract["chunk_count"]),
|
|
terminal_merge_enabled=terminal,
|
|
):
|
|
if group.end > prefix:
|
|
break
|
|
positions = tuple(range(group.start - 1, group.end))
|
|
controller.commit_group(
|
|
tuple(entries[position] for position in positions),
|
|
positions=positions,
|
|
)
|
|
if review_unit is not None:
|
|
start, end = review_unit
|
|
controller.review_generation_mode = GENERATION_MODE_REVIEW
|
|
controller.review_execution = SimpleNamespace(
|
|
max_new_physical_groups=1,
|
|
next_review_unit_start=start,
|
|
next_review_unit_end=end,
|
|
next_review_physical_group=start,
|
|
)
|
|
controller.mark_review_group(
|
|
start=start,
|
|
end=end,
|
|
physical_group=start,
|
|
)
|
|
controller.finalize(
|
|
session={"session_id": f"session-{controller.revision_id}", "chunks": entries},
|
|
report="phase d test",
|
|
review_pause_metadata=controller.review_pause_metadata(),
|
|
)
|
|
controller.manifest["updated_utc"] = updated_utc
|
|
controller._write_manifest()
|
|
return controller
|
|
|
|
|
|
def _resolve(
|
|
tmp_path,
|
|
contract: dict,
|
|
*,
|
|
generation_mode: str = GENERATION_MODE_REVIEW,
|
|
review_action: str = REVIEW_ACTION_CONTINUE,
|
|
take_action: str = "Automatic",
|
|
take_group: int = 0,
|
|
take_revision_id: str = "",
|
|
manual_regenerate_from: int = 0,
|
|
):
|
|
controller = RunStorageController("phase-d-review")
|
|
controller.run_root = tmp_path / "run"
|
|
controller.revisions_root = controller.run_root / "revisions"
|
|
controller.prompts = [f"prompt {index + 1}" for index in range(contract["chunk_count"])]
|
|
controller.contract = contract
|
|
controller.configure_review(
|
|
generation_mode=generation_mode,
|
|
review_action=review_action,
|
|
manual_regenerate_from=manual_regenerate_from,
|
|
take_action=take_action,
|
|
take_group=take_group,
|
|
take_revision_id=take_revision_id,
|
|
)
|
|
resolved, nonce, decision = controller._resolve_review_contract(
|
|
contract,
|
|
requested_nonce=0,
|
|
resume_safe=True,
|
|
)
|
|
return controller, resolved, nonce, decision
|
|
|
|
|
|
def _project(controller: RunStorageController) -> dict:
|
|
import json
|
|
|
|
return json.loads((controller.run_root / "project.json").read_text(encoding="utf-8"))
|
|
|
|
|
|
def test_review_mismatch_diagnostic_reports_runtime_section_not_values():
|
|
import copy
|
|
|
|
stored = _contract()
|
|
stored["global"]["model"] = {
|
|
"runtime": {"weight_probe": [{"sample": "private-old-value"}], "patches": {}},
|
|
"graph_route": {"model": "unchanged"},
|
|
}
|
|
current = copy.deepcopy(stored)
|
|
current["global"]["model"]["runtime"]["weight_probe"][0]["sample"] = "private-new-value"
|
|
before = copy.deepcopy((stored, current))
|
|
rng = torch.random.get_rng_state().clone()
|
|
differences = _review_contract_mismatches(stored, current)
|
|
assert len(differences) == 1
|
|
assert differences[0].startswith("global.model.runtime.weight_probe: saved=")
|
|
assert "private" not in differences[0]
|
|
assert (stored, current) == before
|
|
assert torch.equal(torch.random.get_rng_state(), rng)
|
|
|
|
|
|
def test_retry_mismatched_head_explains_failure_without_reusing_or_writing(tmp_path):
|
|
import copy
|
|
|
|
stored = _contract()
|
|
controller = _persist(
|
|
tmp_path, stored, prefix=1, review_unit=(1, 1),
|
|
updated_utc="2026-09-07T00:00:00+00:00",
|
|
)
|
|
before = {p: p.read_bytes() for p in controller.run_root.rglob("*") if p.is_file()}
|
|
current = copy.deepcopy(stored)
|
|
current["global"]["base_seed"] += 1
|
|
current["nonce_lineage_sha256"] = _nonce_lineage_hash(current)
|
|
with pytest.raises(ReviewControlError, match="existing reviewed unit") as error:
|
|
_resolve(tmp_path, current, review_action=REVIEW_ACTION_REGENERATE_CURRENT)
|
|
assert "global.base_seed: saved=" in str(error.value)
|
|
assert controller.revision_id in str(error.value)
|
|
assert before == {p: p.read_bytes() for p in controller.run_root.rglob("*") if p.is_file()}
|
|
|
|
|
|
def test_retry_without_any_saved_run_explains_missing_head(tmp_path):
|
|
with pytest.raises(ReviewControlError, match="No compatible saved review head"):
|
|
_resolve(tmp_path, _contract(), review_action=REVIEW_ACTION_REGENERATE_CURRENT)
|
|
assert not (tmp_path / "run").exists()
|
|
|
|
|
|
def test_review_mismatch_diagnostic_ignores_derived_nonce_and_unchanged_contract():
|
|
import copy
|
|
|
|
stored = _contract()
|
|
current = copy.deepcopy(stored)
|
|
current["effective_reroll_nonce"] = 99
|
|
assert _review_contract_mismatches(stored, current) == []
|
|
|
|
|
|
def test_matching_retry_does_not_run_mismatch_diagnostic(tmp_path, monkeypatch):
|
|
import ComfyUI_H3_Continuum_Join.run_storage as storage
|
|
|
|
contract = _contract()
|
|
_persist(tmp_path, contract, prefix=1, review_unit=(1, 1),
|
|
updated_utc="2026-09-07T00:00:00+00:00")
|
|
|
|
def unexpected(*args, **kwargs):
|
|
pytest.fail("Compatible retry must not execute mismatch diagnostics")
|
|
|
|
monkeypatch.setattr(storage, "_review_contract_mismatches", unexpected)
|
|
controller, _, nonce, _ = _resolve(
|
|
tmp_path, contract, review_action=REVIEW_ACTION_REGENERATE_CURRENT,
|
|
)
|
|
assert controller.review_head["validated_prefix_count"] == 1
|
|
assert nonce == 1
|
|
|
|
|
|
def _take(project: dict, *, group: int, nonce: int) -> dict:
|
|
return next(
|
|
revision
|
|
for revision in project["group_revisions"]
|
|
if int(revision["group"]["physical_group"]) == group
|
|
and int(revision["variation_nonce"]) == nonce
|
|
)
|
|
|
|
|
|
def _rr_r5_contract(*, changed_group: int = 0) -> dict:
|
|
selectors = {slot: "off" for slot in REFERENCE_SLOT_IDS}
|
|
selectors["R1"] = "all" if not changed_group else ",".join(
|
|
str(index) for index in range(1, 5) if index != changed_group
|
|
)
|
|
if changed_group:
|
|
selectors["R4"] = str(changed_group)
|
|
routing = ReferenceRoutingRuntime(
|
|
schedule=compile_reference_routing_schedule(
|
|
total_chunks=4, terminal_merge_enabled=False,
|
|
mode="Custom", selectors_by_slot=selectors,
|
|
),
|
|
inputs=ReferenceInputSet(
|
|
(torch.full((1, 64, 64, 3), 0.1), None, None,
|
|
torch.full((1, 64, 64, 3), 0.4), *([None] * 5)),
|
|
96, 64, REFERENCE_SIZE_MATCH_OUTPUT,
|
|
),
|
|
)
|
|
plan = build_reference_storage_plan(
|
|
runtime=routing, prompts=[f"prompt {index}" for index in range(1, 5)],
|
|
first_frame_hash="none", last_frame_hash="none",
|
|
)
|
|
contract = _contract(chunks=4)
|
|
contract["global"]["reference_routing_contract_version"] = 1
|
|
contract["reference_group_contracts"] = plan.group_contracts
|
|
contract["nonce_lineage_sha256"] = _nonce_lineage_hash(contract)
|
|
return _apply_reroll_branch_contract(
|
|
contract, boundary=0, requested_nonce=0, effective_nonce=0,
|
|
)
|
|
|
|
|
|
def test_rr_r5_selected_foreign_take_requires_whole_compatible_prefix(tmp_path):
|
|
source = _persist(
|
|
tmp_path, _rr_r5_contract(), prefix=2, review_unit=(2, 2),
|
|
updated_utc="2026-09-24T00:00:00+00:00",
|
|
)
|
|
selected = _take(_project(source), group=2, nonce=0)
|
|
controller, resolved, _, decision = _resolve(
|
|
tmp_path, _rr_r5_contract(changed_group=4),
|
|
take_action=TAKE_ACTION_USE, take_group=2,
|
|
take_revision_id=selected["revision_id"],
|
|
)
|
|
assert decision == "select_take"
|
|
assert controller.review_runtime_metrics["review_decision_created"] == 1
|
|
assert controller._plan_import is not None
|
|
assert controller.selected_take_chain == []
|
|
assert len(controller.validated_prefix.entries) == 2
|
|
assert resolved["nonce_lineage_sha256"] != source.contract["nonce_lineage_sha256"]
|
|
assert source.manifest["chunks"][0]["storage_revision_id"] == source.revision_id
|
|
controller.contract = resolved
|
|
sampling_revision_id, controller.contract_sha256 = revision_identity(resolved)
|
|
controller.revision_id = controller.storage_revision_id_override
|
|
controller.revision_root = controller.revisions_root / controller.revision_id
|
|
controller.manifest = {
|
|
"run_storage_schema_version": RUN_STORAGE_SCHEMA_VERSION,
|
|
"sampling_contract_version": SAMPLING_CONTRACT_VERSION,
|
|
"run_name": controller.run_name,
|
|
"revision_id": controller.revision_id,
|
|
"sampling_revision_id": sampling_revision_id,
|
|
"contract_sha256": controller.contract_sha256,
|
|
"contract": resolved,
|
|
"nonce_lifecycle": dict(resolved["nonce_lifecycle"]),
|
|
"status": REVISION_STATUS_IN_PROGRESS,
|
|
"created_utc": "2026-09-24T01:00:00+00:00",
|
|
"updated_utc": "2026-09-24T01:00:00+00:00",
|
|
"chunks": [],
|
|
}
|
|
controller._write_manifest()
|
|
imported = controller._adopt_plan_prefix(controller._plan_import)
|
|
assert len(imported) == 2
|
|
assert all(record["storage_revision_id"] == controller.revision_id for record in imported)
|
|
assert controller.manifest["prefix_import"]["selected_take"]["revision_id"] == selected["revision_id"]
|
|
assert controller.pending_branch_cut["selected_revision_id"] != selected["revision_id"]
|
|
controller.finalize(
|
|
session={"session_id": "routed-take", "chunks": list(controller.validated_prefix.entries)},
|
|
report="routed Take import", review_pause_metadata=controller.review_pause_metadata(),
|
|
)
|
|
assert controller.manifest["status"] == REVISION_STATUS_REVIEW_READY
|
|
assert source.manifest["chunks"][0]["storage_revision_id"] == source.revision_id
|
|
|
|
|
|
def test_rr_r5_selected_foreign_take_rejects_changed_group_without_fallback(tmp_path):
|
|
source = _persist(
|
|
tmp_path, _rr_r5_contract(), prefix=2, review_unit=(2, 2),
|
|
updated_utc="2026-09-24T00:00:00+00:00",
|
|
)
|
|
selected = _take(_project(source), group=2, nonce=0)
|
|
with pytest.raises(RunStorageError, match="physical group starting with chunk 2"):
|
|
_resolve(
|
|
tmp_path, _rr_r5_contract(changed_group=2),
|
|
take_action=TAKE_ACTION_USE, take_group=2,
|
|
take_revision_id=selected["revision_id"],
|
|
)
|
|
|
|
|
|
def test_rr_r5_explicit_session_keeps_only_compatible_complete_groups(tmp_path, monkeypatch):
|
|
old = _rr_r5_contract()
|
|
current = _rr_r5_contract(changed_group=2)
|
|
old_plan = SimpleNamespace(group_contracts=old["reference_group_contracts"],
|
|
routing_config_sha256="a" * 64)
|
|
current_plan = SimpleNamespace(group_contracts=current["reference_group_contracts"])
|
|
identity = routed_session_identity("base")
|
|
saved = make_session(
|
|
chunks=[_entry(index, old) for index in range(3)],
|
|
width=32, height=32, chunk_seconds=5.0,
|
|
identity_hash=identity, model_fingerprint_value="f" * 64,
|
|
parent_session_id=None, reroll_from_chunk=0,
|
|
settings={"reference_routing_v1": session_routing_settings(old_plan, 3)},
|
|
)
|
|
monkeypatch.setattr(session_io, "session_directory", lambda: tmp_path)
|
|
session_io.save_session(saved, prefix="rr-r5", slot=1)
|
|
saved = session_io.load_session(prefix="rr-r5", slot=1)
|
|
preserved, notes = _preserved_prefix(
|
|
session=saved, prompt_hashes=current["prompt_hashes"], chunks=4,
|
|
reroll_from_chunk=0, width=32, height=32, chunk_seconds=5.0,
|
|
identity_hash=identity, last_frame_hash="none",
|
|
reference_storage_plan=current_plan,
|
|
)
|
|
assert len(preserved) == 1
|
|
assert any("Reference group changed" in note for note in notes)
|
|
|
|
|
|
def test_rr_r5_plan_import_stops_at_first_changed_physical_group(tmp_path):
|
|
source = _persist(
|
|
tmp_path, _rr_r5_contract(), prefix=3, review_unit=(3, 3),
|
|
updated_utc="2026-09-24T00:00:00+00:00",
|
|
)
|
|
destination = RunStorageController("phase-d-review")
|
|
destination.run_root = source.run_root
|
|
destination.revisions_root = source.revisions_root
|
|
destination.prompts = [f"prompt {index}" for index in range(1, 5)]
|
|
current = _rr_r5_contract(changed_group=3)
|
|
imported = destination._find_plan_import(current)
|
|
assert imported is not None
|
|
assert imported["validated_prefix_count"] == 2
|
|
assert [record["sequence_index"] for record in imported["records"]] == [0, 1]
|
|
assert imported["revision_id"] == source.revision_id
|
|
|
|
|
|
def test_rr_r5_review_decision_uses_fixed_imported_prefix_once(tmp_path):
|
|
source = _persist(
|
|
tmp_path, _rr_r5_contract(), prefix=2, review_unit=(2, 2),
|
|
updated_utc="2026-09-24T00:00:00+00:00",
|
|
)
|
|
controller, resolved, _, decision = _resolve(
|
|
tmp_path, _rr_r5_contract(changed_group=3),
|
|
review_action=REVIEW_ACTION_CONTINUE,
|
|
)
|
|
assert controller._plan_import is not None
|
|
assert len(controller.validated_prefix.entries) == 2
|
|
assert controller.review_runtime_metrics["review_decision_created"] == 1
|
|
assert controller.review_runtime_metrics["review_reconcile"] == 0
|
|
assert controller.review_execution.next_review_unit_start == 3
|
|
assert resolved["nonce_lineage_sha256"] != source.contract["nonce_lineage_sha256"]
|
|
assert decision == "inactive"
|
|
|
|
|
|
def test_rr_r5_foreign_take_preserves_verified_nonce_variation(tmp_path):
|
|
source_contract = _apply_reroll_branch_contract(
|
|
_rr_r5_contract(), boundary=3,
|
|
requested_nonce=1, effective_nonce=1,
|
|
)
|
|
source = _persist(
|
|
tmp_path, source_contract, prefix=3, review_unit=(3, 3),
|
|
updated_utc="2026-09-24T00:00:00+00:00",
|
|
)
|
|
selected = _take(_project(source), group=3, nonce=1)
|
|
controller, resolved, nonce, decision = _resolve(
|
|
tmp_path, _rr_r5_contract(changed_group=4),
|
|
take_action=TAKE_ACTION_USE, take_group=3,
|
|
take_revision_id=selected["revision_id"],
|
|
)
|
|
assert decision == "select_take"
|
|
assert (resolved["reroll_from_chunk"], nonce) == (3, 1)
|
|
assert len(controller.validated_prefix.entries) == 3
|
|
assert controller._plan_import is not None
|
|
|
|
|
|
def _persist_resolved_branch(
|
|
controller: RunStorageController,
|
|
contract: dict,
|
|
*,
|
|
new_positions: tuple[int, ...],
|
|
) -> RunStorageController:
|
|
controller.contract = contract
|
|
sampling_revision_id, controller.contract_sha256 = revision_identity(contract)
|
|
controller.revision_id = controller.storage_revision_id_override
|
|
controller.revision_root = controller.revisions_root / controller.revision_id
|
|
controller.effective_reroll_nonce = int(contract["effective_reroll_nonce"])
|
|
controller.manifest = {
|
|
"run_storage_schema_version": RUN_STORAGE_SCHEMA_VERSION,
|
|
"sampling_contract_version": SAMPLING_CONTRACT_VERSION,
|
|
"run_name": controller.run_name,
|
|
"revision_id": controller.revision_id,
|
|
"sampling_revision_id": sampling_revision_id,
|
|
"contract_sha256": controller.contract_sha256,
|
|
"contract": contract,
|
|
"resume_safe": True,
|
|
"resume_disabled_reasons": [],
|
|
"nonce_lifecycle": dict(contract["nonce_lifecycle"]),
|
|
"status": REVISION_STATUS_IN_PROGRESS,
|
|
"created_utc": "2026-09-03T01:00:00+00:00",
|
|
"updated_utc": "2026-09-03T01:00:00+00:00",
|
|
"chunks": list(controller.selected_take_records),
|
|
"report_summary": "",
|
|
"review_control_version": REVIEW_CONTROL_VERSION,
|
|
"branch_regenerate_from": int(contract["reroll_from_chunk"]),
|
|
"effective_reroll_nonce": int(contract["effective_reroll_nonce"]),
|
|
"branch_provenance": {
|
|
"version": 1,
|
|
"active_chain": [
|
|
item["revision_id"] for item in controller.selected_take_chain
|
|
],
|
|
"selection": {
|
|
"action": controller.take_action,
|
|
"revision_id": controller.take_revision_id,
|
|
"physical_group": controller.take_group,
|
|
},
|
|
"branch_cut": dict(controller.pending_branch_cut or {}),
|
|
},
|
|
}
|
|
entries = list(controller.selected_take_revision["entries"])
|
|
for position in new_positions:
|
|
entry = _entry(position, contract)
|
|
entries.append(entry)
|
|
controller.commit_chunk(entry, position=position)
|
|
if new_positions:
|
|
start = new_positions[0] + 1
|
|
end = new_positions[-1] + 1
|
|
controller.mark_review_group(
|
|
start=start,
|
|
end=end,
|
|
physical_group=start,
|
|
)
|
|
controller.finalize(
|
|
session={"session_id": "branch-session", "chunks": entries},
|
|
report="branch",
|
|
review_pause_metadata=controller.review_pause_metadata(),
|
|
)
|
|
return controller
|
|
|
|
|
|
def test_l0_partial_normal_completion_becomes_review_ready(tmp_path):
|
|
controller = _persist(
|
|
tmp_path,
|
|
_contract(),
|
|
prefix=1,
|
|
review_unit=(1, 1),
|
|
updated_utc="2026-08-31T00:00:01+00:00",
|
|
)
|
|
assert controller.manifest["status"] == REVISION_STATUS_REVIEW_READY
|
|
assert controller.manifest["review_unit"] == {
|
|
"start": 1,
|
|
"end": 1,
|
|
"physical_group": 1,
|
|
}
|
|
assert controller.manifest["review_pause_reason"] == "review_each_chunk"
|
|
assert controller.manifest["review_control_version"] == REVIEW_CONTROL_VERSION
|
|
|
|
|
|
def test_l1_full_completion_is_complete_and_keeps_latest_review_unit(tmp_path):
|
|
controller = _persist(
|
|
tmp_path,
|
|
_contract(chunks=3),
|
|
prefix=3,
|
|
review_unit=(3, 3),
|
|
updated_utc="2026-08-31T00:00:01+00:00",
|
|
)
|
|
assert controller.manifest["status"] == REVISION_STATUS_COMPLETE
|
|
assert controller.manifest["review_unit"]["start"] == 3
|
|
|
|
|
|
def test_l2_incomplete_without_intentional_pause_is_interrupted(tmp_path):
|
|
controller = _persist(
|
|
tmp_path,
|
|
_contract(),
|
|
prefix=1,
|
|
review_unit=None,
|
|
updated_utc="2026-08-31T00:00:01+00:00",
|
|
)
|
|
assert controller.manifest["status"] == REVISION_STATUS_INTERRUPTED
|
|
assert "review_unit" not in controller.manifest
|
|
|
|
|
|
def test_l3_commit_keeps_manifest_in_progress(tmp_path):
|
|
contract = _contract()
|
|
controller = _controller(tmp_path, contract)
|
|
controller.commit_chunk(_entry(0, contract), position=0)
|
|
assert controller.manifest["status"] == REVISION_STATUS_IN_PROGRESS
|
|
persisted = controller._manifest_path().read_text(encoding="utf-8")
|
|
assert '"status": "in_progress"' in persisted
|
|
|
|
|
|
def test_l4_review_ready_is_reloaded_as_validated_head(tmp_path):
|
|
contract = _contract()
|
|
original = _persist(
|
|
tmp_path,
|
|
contract,
|
|
prefix=2,
|
|
review_unit=(2, 2),
|
|
updated_utc="2026-08-31T00:00:02+00:00",
|
|
)
|
|
reloaded, _, _, _ = _resolve(tmp_path, contract)
|
|
assert reloaded.review_head["revision_id"] == original.revision_id
|
|
assert reloaded.review_head["validated_prefix_count"] == 2
|
|
|
|
|
|
def test_n0_n2_three_consecutive_regenerates_advance_nonce_and_seed(tmp_path):
|
|
base = _contract()
|
|
_persist(
|
|
tmp_path,
|
|
base,
|
|
prefix=2,
|
|
review_unit=(2, 2),
|
|
updated_utc="2026-08-31T00:00:01+00:00",
|
|
)
|
|
nonces = []
|
|
seeds = []
|
|
for variation in (1, 2, 3):
|
|
_, resolved, nonce, _ = _resolve(
|
|
tmp_path,
|
|
base,
|
|
review_action=REVIEW_ACTION_REGENERATE_CURRENT,
|
|
)
|
|
assert resolved["reroll_from_chunk"] == 2
|
|
assert nonce == variation
|
|
nonces.append(nonce)
|
|
seeds.append(derive_chunk_seed(1234, 1, nonce))
|
|
_persist(
|
|
tmp_path,
|
|
resolved,
|
|
prefix=2,
|
|
review_unit=(2, 2),
|
|
updated_utc=f"2026-08-31T00:00:0{variation + 1}+00:00",
|
|
)
|
|
assert nonces == [1, 2, 3]
|
|
assert len(set(seeds)) == 3
|
|
|
|
|
|
def test_n3_continue_after_nonce_two_keeps_branch_and_nonce(tmp_path):
|
|
branch = _contract(boundary=2, nonce=2)
|
|
_persist(
|
|
tmp_path,
|
|
branch,
|
|
prefix=2,
|
|
review_unit=(2, 2),
|
|
updated_utc="2026-08-31T00:00:03+00:00",
|
|
)
|
|
_, resolved, nonce, _ = _resolve(tmp_path, _contract())
|
|
assert (resolved["reroll_from_chunk"], nonce) == (2, 2)
|
|
|
|
|
|
def test_complete_three_chunk_run_can_start_fresh_review_and_advance_one_chunk(
|
|
tmp_path,
|
|
):
|
|
base = _contract(chunks=3)
|
|
_persist(
|
|
tmp_path,
|
|
base,
|
|
prefix=3,
|
|
review_unit=(3, 3),
|
|
updated_utc="2026-08-31T00:00:01+00:00",
|
|
)
|
|
|
|
first, chunk_1, nonce_1, _ = _resolve(
|
|
tmp_path,
|
|
base,
|
|
manual_regenerate_from=1,
|
|
)
|
|
assert (chunk_1["reroll_from_chunk"], nonce_1) == (1, 1)
|
|
assert first.review_execution.max_new_physical_groups == 1
|
|
assert (
|
|
first.review_execution.next_review_unit_start,
|
|
first.review_execution.next_review_unit_end,
|
|
) == (1, 1)
|
|
_persist(
|
|
tmp_path,
|
|
chunk_1,
|
|
prefix=1,
|
|
review_unit=(1, 1),
|
|
updated_utc="2026-08-31T00:00:02+00:00",
|
|
)
|
|
|
|
second, chunk_2, nonce_2, _ = _resolve(tmp_path, base)
|
|
assert (chunk_2["reroll_from_chunk"], nonce_2) == (1, 1)
|
|
assert (
|
|
second.review_execution.next_review_unit_start,
|
|
second.review_execution.next_review_unit_end,
|
|
) == (2, 2)
|
|
_persist(
|
|
tmp_path,
|
|
chunk_2,
|
|
prefix=2,
|
|
review_unit=(2, 2),
|
|
updated_utc="2026-08-31T00:00:03+00:00",
|
|
)
|
|
|
|
third, chunk_3, nonce_3, _ = _resolve(tmp_path, base)
|
|
assert (chunk_3["reroll_from_chunk"], nonce_3) == (1, 1)
|
|
assert (
|
|
third.review_execution.next_review_unit_start,
|
|
third.review_execution.next_review_unit_end,
|
|
) == (3, 3)
|
|
complete = _persist(
|
|
tmp_path,
|
|
chunk_3,
|
|
prefix=3,
|
|
review_unit=(3, 3),
|
|
updated_utc="2026-08-31T00:00:04+00:00",
|
|
)
|
|
assert complete.manifest["status"] == REVISION_STATUS_COMPLETE
|
|
|
|
|
|
def test_n4_interrupted_nonce_two_resume_does_not_advance(tmp_path):
|
|
branch = _contract(boundary=2, nonce=2)
|
|
_persist(
|
|
tmp_path,
|
|
branch,
|
|
prefix=2,
|
|
review_unit=None,
|
|
updated_utc="2026-08-31T00:00:03+00:00",
|
|
)
|
|
_, resolved, nonce, _ = _resolve(tmp_path, _contract())
|
|
assert (resolved["reroll_from_chunk"], nonce) == (2, 2)
|
|
|
|
|
|
def test_n5_finish_remaining_keeps_current_branch_nonce(tmp_path):
|
|
branch = _contract(boundary=2, nonce=2)
|
|
_persist(
|
|
tmp_path,
|
|
branch,
|
|
prefix=3,
|
|
review_unit=(3, 3),
|
|
updated_utc="2026-08-31T00:00:03+00:00",
|
|
)
|
|
controller, resolved, nonce, _ = _resolve(
|
|
tmp_path,
|
|
_contract(),
|
|
review_action=REVIEW_ACTION_FINISH_REMAINING,
|
|
)
|
|
assert (resolved["reroll_from_chunk"], nonce) == (2, 2)
|
|
assert controller.review_execution.max_new_physical_groups is None
|
|
|
|
|
|
def test_finish_remaining_complete_records_the_final_generated_group(tmp_path):
|
|
contract = _contract(chunks=6, boundary=2, nonce=2)
|
|
controller = _controller(tmp_path, contract)
|
|
controller.review_generation_mode = GENERATION_MODE_REVIEW
|
|
controller.review_execution = SimpleNamespace(max_new_physical_groups=None)
|
|
entries = []
|
|
for position in range(6):
|
|
entry = _entry(position, contract)
|
|
entries.append(entry)
|
|
controller.commit_chunk(entry, position=position)
|
|
if position >= 3:
|
|
controller.mark_review_group(
|
|
start=position + 1,
|
|
end=position + 1,
|
|
physical_group=position + 1,
|
|
)
|
|
controller.finalize(
|
|
session={"session_id": "finish", "chunks": entries},
|
|
report="finish",
|
|
review_pause_metadata=controller.review_pause_metadata(),
|
|
)
|
|
assert controller.manifest["status"] == REVISION_STATUS_COMPLETE
|
|
assert controller.manifest["review_unit"] == {
|
|
"start": 6,
|
|
"end": 6,
|
|
"physical_group": 6,
|
|
}
|
|
|
|
|
|
def test_full_run_complete_does_not_create_review_unit(tmp_path):
|
|
contract = _contract(chunks=3, boundary=2, nonce=2)
|
|
controller = _controller(tmp_path, contract)
|
|
controller.review_generation_mode = GENERATION_MODE_FULL_RUN
|
|
controller.review_execution = SimpleNamespace(max_new_physical_groups=None)
|
|
controller.inherited_review_unit = {
|
|
"start": 2,
|
|
"end": 2,
|
|
"physical_group": 2,
|
|
}
|
|
entries = []
|
|
for position in range(3):
|
|
entry = _entry(position, contract)
|
|
entries.append(entry)
|
|
controller.commit_chunk(entry, position=position)
|
|
controller.mark_review_group(
|
|
start=position + 1,
|
|
end=position + 1,
|
|
physical_group=position + 1,
|
|
)
|
|
assert controller.review_pause_metadata() is None
|
|
controller.finalize(
|
|
session={"session_id": "full", "chunks": entries},
|
|
report="full",
|
|
review_pause_metadata=None,
|
|
)
|
|
assert controller.manifest["status"] == REVISION_STATUS_COMPLETE
|
|
assert "review_unit" not in controller.manifest
|
|
|
|
|
|
def test_b0_canonical_head_prefers_highest_valid_nonce(tmp_path):
|
|
_persist(
|
|
tmp_path,
|
|
_contract(boundary=2, nonce=1),
|
|
prefix=2,
|
|
review_unit=(2, 2),
|
|
updated_utc="2026-08-31T00:00:02+00:00",
|
|
)
|
|
latest = _persist(
|
|
tmp_path,
|
|
_contract(boundary=2, nonce=2),
|
|
prefix=2,
|
|
review_unit=(2, 2),
|
|
updated_utc="2026-08-31T00:00:03+00:00",
|
|
)
|
|
controller, _, _, _ = _resolve(tmp_path, _contract())
|
|
assert controller.review_head["revision_id"] == latest.revision_id
|
|
|
|
|
|
def test_b1_corrupt_newest_branch_falls_back_to_latest_valid_head(tmp_path):
|
|
fallback = _persist(
|
|
tmp_path,
|
|
_contract(boundary=2, nonce=1),
|
|
prefix=2,
|
|
review_unit=(2, 2),
|
|
updated_utc="2026-08-31T00:00:02+00:00",
|
|
)
|
|
corrupt = _persist(
|
|
tmp_path,
|
|
_contract(boundary=2, nonce=2),
|
|
prefix=2,
|
|
review_unit=(2, 2),
|
|
updated_utc="2026-08-31T00:00:03+00:00",
|
|
)
|
|
record = corrupt.manifest["chunks"][-1]
|
|
target = corrupt.revision_root / "chunks" / record["filename"]
|
|
payload = bytearray(target.read_bytes())
|
|
payload[-1] ^= 1
|
|
target.write_bytes(payload)
|
|
|
|
controller, _, nonce, _ = _resolve(tmp_path, _contract())
|
|
assert controller.review_head["revision_id"] == fallback.revision_id
|
|
assert nonce == 1
|
|
assert any("rejected" in note for note in controller.notes)
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"different",
|
|
(
|
|
_contract(prompt_tag="other"),
|
|
_contract(reference_tag="other-reference"),
|
|
_contract(driving_tag="other-driving"),
|
|
),
|
|
)
|
|
def test_b2_b4_incompatible_prompt_reference_or_driving_lineage_is_excluded(
|
|
tmp_path,
|
|
different,
|
|
):
|
|
_persist(
|
|
tmp_path,
|
|
_contract(),
|
|
prefix=2,
|
|
review_unit=(2, 2),
|
|
updated_utc="2026-08-31T00:00:02+00:00",
|
|
)
|
|
controller = RunStorageController("phase-d-review")
|
|
controller.run_root = tmp_path / "run"
|
|
controller.revisions_root = controller.run_root / "revisions"
|
|
controller.prompts = [
|
|
f"prompt {index + 1}" for index in range(different["chunk_count"])
|
|
]
|
|
assert controller.find_latest_review_head(different) is None
|
|
|
|
|
|
def test_terminal_merge_review_and_consecutive_regenerate_are_atomic(tmp_path):
|
|
base = _contract(chunks=3, terminal=True)
|
|
first = _persist(
|
|
tmp_path,
|
|
base,
|
|
prefix=1,
|
|
review_unit=(1, 1),
|
|
updated_utc="2026-08-31T00:00:01+00:00",
|
|
)
|
|
controller, resolved, nonce, _ = _resolve(tmp_path, base)
|
|
execution = controller.review_execution
|
|
assert first.manifest["status"] == REVISION_STATUS_REVIEW_READY
|
|
assert (execution.next_review_unit_start, execution.next_review_unit_end) == (2, 3)
|
|
assert nonce == 0
|
|
|
|
complete = _persist(
|
|
tmp_path,
|
|
resolved,
|
|
prefix=3,
|
|
review_unit=(2, 3),
|
|
updated_utc="2026-08-31T00:00:02+00:00",
|
|
)
|
|
assert complete.manifest["status"] == REVISION_STATUS_COMPLETE
|
|
assert complete.manifest["review_unit"] == {
|
|
"start": 2,
|
|
"end": 3,
|
|
"physical_group": 2,
|
|
}
|
|
|
|
_, first_regen, nonce1, _ = _resolve(
|
|
tmp_path,
|
|
base,
|
|
review_action=REVIEW_ACTION_REGENERATE_CURRENT,
|
|
)
|
|
assert (first_regen["reroll_from_chunk"], nonce1) == (2, 1)
|
|
_persist(
|
|
tmp_path,
|
|
first_regen,
|
|
prefix=3,
|
|
review_unit=(2, 3),
|
|
updated_utc="2026-08-31T00:00:03+00:00",
|
|
)
|
|
_, second_regen, nonce2, _ = _resolve(
|
|
tmp_path,
|
|
base,
|
|
review_action=REVIEW_ACTION_REGENERATE_CURRENT,
|
|
)
|
|
assert (second_regen["reroll_from_chunk"], nonce2) == (2, 2)
|
|
|
|
|
|
def test_terminal_merge_head_rejects_a_single_logical_half(tmp_path):
|
|
contract = _contract(chunks=3, terminal=True)
|
|
stored = _persist(
|
|
tmp_path,
|
|
contract,
|
|
prefix=3,
|
|
review_unit=(2, 3),
|
|
updated_utc="2026-08-31T00:00:02+00:00",
|
|
)
|
|
stored.manifest["review_unit"] = {
|
|
"start": 3,
|
|
"end": 3,
|
|
"physical_group": 3,
|
|
}
|
|
stored._write_manifest()
|
|
controller = RunStorageController("phase-d-review")
|
|
controller.run_root = tmp_path / "run"
|
|
controller.revisions_root = controller.run_root / "revisions"
|
|
controller.prompts = ["prompt 1", "prompt 2", "prompt 3"]
|
|
assert controller.find_latest_review_head(
|
|
contract,
|
|
smart_regenerate_only=True,
|
|
) is None
|
|
assert any("atomic Terminal Merge" in note for note in controller.notes)
|
|
|
|
|
|
def test_restart_restores_continue_regenerate_finish_and_full_branch(tmp_path):
|
|
branch = _contract(boundary=2, nonce=2)
|
|
_persist(
|
|
tmp_path,
|
|
branch,
|
|
prefix=3,
|
|
review_unit=(3, 3),
|
|
updated_utc="2026-08-31T00:00:03+00:00",
|
|
)
|
|
for action, expected_boundary, expected_nonce in (
|
|
(REVIEW_ACTION_CONTINUE, 2, 2),
|
|
(REVIEW_ACTION_REGENERATE_CURRENT, 3, 3),
|
|
(REVIEW_ACTION_FINISH_REMAINING, 2, 2),
|
|
):
|
|
_, resolved, nonce, _ = _resolve(
|
|
tmp_path,
|
|
_contract(),
|
|
review_action=action,
|
|
)
|
|
assert resolved["reroll_from_chunk"] == expected_boundary
|
|
assert nonce == expected_nonce
|
|
controller, resolved, nonce, _ = _resolve(
|
|
tmp_path,
|
|
_contract(),
|
|
generation_mode=GENERATION_MODE_FULL_RUN,
|
|
)
|
|
assert (resolved["reroll_from_chunk"], nonce) == (2, 2)
|
|
assert controller.review_execution.max_new_physical_groups is None
|
|
|
|
|
|
def test_legacy_revision_resumes_but_is_not_a_smart_regenerate_head(tmp_path):
|
|
legacy = _persist(
|
|
tmp_path,
|
|
_contract(chunks=3),
|
|
prefix=3,
|
|
review_unit=None,
|
|
updated_utc="2026-08-31T00:00:01+00:00",
|
|
)
|
|
assert legacy.manifest["status"] == REVISION_STATUS_COMPLETE
|
|
assert "review_control_version" not in legacy.manifest
|
|
|
|
controller = RunStorageController("phase-d-review")
|
|
controller.run_root = tmp_path / "run"
|
|
controller.revisions_root = controller.run_root / "revisions"
|
|
controller.prompts = ["prompt 1", "prompt 2", "prompt 3"]
|
|
assert controller.find_latest_review_head(_contract(chunks=3)) is not None
|
|
assert controller.find_latest_review_head(
|
|
_contract(chunks=3),
|
|
smart_regenerate_only=True,
|
|
) is None
|
|
with pytest.raises(ReviewControlError, match="existing reviewed unit"):
|
|
_resolve(
|
|
tmp_path,
|
|
_contract(chunks=3),
|
|
review_action=REVIEW_ACTION_REGENERATE_CURRENT,
|
|
)
|
|
|
|
|
|
def test_review_controls_remain_internal_not_public_widgets():
|
|
schema = H3ContinuumSamplerProduction.INPUT_TYPES()
|
|
for name in ("generation_mode", "review_action", "max_new_physical_groups"):
|
|
assert name not in schema.get("required", {})
|
|
assert name not in schema.get("optional", {})
|
|
|
|
|
|
def test_finalize_rejects_review_unit_that_is_not_prefix_head(tmp_path):
|
|
contract = _contract()
|
|
controller = _controller(tmp_path, contract)
|
|
entries = [_entry(0, contract), _entry(1, contract)]
|
|
for position, entry in enumerate(entries):
|
|
controller.commit_chunk(entry, position=position)
|
|
controller.review_execution = SimpleNamespace(
|
|
max_new_physical_groups=1,
|
|
next_review_unit_start=1,
|
|
next_review_unit_end=1,
|
|
next_review_physical_group=1,
|
|
)
|
|
controller.review_generation_mode = GENERATION_MODE_REVIEW
|
|
controller.mark_review_group(start=1, end=1, physical_group=1)
|
|
with pytest.raises(RunStorageError, match="review pause metadata is invalid"):
|
|
controller.finalize(
|
|
session={"session_id": "bad", "chunks": entries},
|
|
report="bad",
|
|
review_pause_metadata=controller.review_pause_metadata(),
|
|
)
|
|
|
|
|
|
def test_exception_marks_in_progress_revision_interrupted_without_nonce_change(
|
|
tmp_path,
|
|
):
|
|
contract = _contract(boundary=2, nonce=2)
|
|
controller = _controller(tmp_path, contract)
|
|
controller.manifest.update(
|
|
review_control_version=REVIEW_CONTROL_VERSION,
|
|
branch_regenerate_from=2,
|
|
effective_reroll_nonce=2,
|
|
)
|
|
|
|
class _Lock:
|
|
def acquire(self):
|
|
return None
|
|
|
|
def release(self):
|
|
return None
|
|
|
|
controller.lock = _Lock()
|
|
with pytest.raises(RuntimeError, match="simulated crash"):
|
|
with controller:
|
|
raise RuntimeError("simulated crash")
|
|
assert controller.manifest["status"] == REVISION_STATUS_INTERRUPTED
|
|
assert controller.manifest["branch_regenerate_from"] == 2
|
|
assert controller.manifest["effective_reroll_nonce"] == 2
|
|
|
|
|
|
def test_n2b_schema_v2_is_read_as_legacy_chain_without_rewrite(tmp_path):
|
|
legacy = _persist(
|
|
tmp_path,
|
|
_contract(chunks=3),
|
|
prefix=2,
|
|
review_unit=(2, 2),
|
|
updated_utc="2026-09-03T00:00:01+00:00",
|
|
)
|
|
legacy.manifest["run_storage_schema_version"] = 2
|
|
legacy.manifest.pop("sampling_revision_id", None)
|
|
legacy.manifest.pop("branch_provenance", None)
|
|
legacy._write_manifest()
|
|
before = legacy._manifest_path().read_bytes()
|
|
|
|
controller = RunStorageController("phase-d-review")
|
|
controller.run_root = legacy.run_root
|
|
controller.revisions_root = legacy.revisions_root
|
|
controller.prompts = ["prompt 1", "prompt 2", "prompt 3"]
|
|
head = controller.find_latest_review_head(_contract(chunks=3))
|
|
assert head is not None
|
|
_, catalog, chains = controller._provenance_catalog()
|
|
assert len(catalog) == 2
|
|
assert len(chains[legacy.revision_id]) == 2
|
|
assert legacy._manifest_path().read_bytes() == before
|
|
sampling_revision_id, contract_sha256 = revision_identity(_contract(chunks=3))
|
|
v3_storage_revision_id = _storage_revision_identity(
|
|
contract_sha256=contract_sha256,
|
|
take_action="Automatic",
|
|
selected_revision_id="",
|
|
effective_nonce=0,
|
|
branch_boundary=0,
|
|
)
|
|
assert v3_storage_revision_id != sampling_revision_id
|
|
|
|
|
|
def test_n2b_take_a_b_selection_and_continue_preserve_old_branch(tmp_path):
|
|
take_a = _persist(
|
|
tmp_path,
|
|
_contract(chunks=5, boundary=3, nonce=1),
|
|
prefix=3,
|
|
review_unit=(3, 3),
|
|
updated_utc="2026-09-03T00:00:01+00:00",
|
|
)
|
|
take_b = _persist(
|
|
tmp_path,
|
|
_contract(chunks=5, boundary=3, nonce=2),
|
|
prefix=3,
|
|
review_unit=(3, 3),
|
|
updated_utc="2026-09-03T00:00:02+00:00",
|
|
)
|
|
project = _project(take_b)
|
|
revision_a = _take(project, group=3, nonce=1)
|
|
revision_b = _take(project, group=3, nonce=2)
|
|
assert revision_a["revision_id"] != revision_b["revision_id"]
|
|
|
|
selected, resolved, nonce, decision = _resolve(
|
|
tmp_path,
|
|
_contract(chunks=5),
|
|
take_action=TAKE_ACTION_CONTINUE,
|
|
take_group=3,
|
|
take_revision_id=revision_b["revision_id"],
|
|
)
|
|
assert (resolved["reroll_from_chunk"], nonce, decision) == (
|
|
4,
|
|
3,
|
|
"branch_from_take",
|
|
)
|
|
selected_sources = [
|
|
record["storage_revision_id"] for record in selected.selected_take_records
|
|
]
|
|
_persist_resolved_branch(selected, resolved, new_positions=(3,))
|
|
branched = _project(selected)
|
|
assert branched["canonical_chain"][:3] == [
|
|
item["revision_id"] for item in selected.selected_take_chain
|
|
]
|
|
assert branched["canonical_head_revision_id"] == branched["canonical_chain"][-1]
|
|
assert revision_a["revision_id"] in {
|
|
item["revision_id"] for item in branched["group_revisions"]
|
|
}
|
|
assert revision_b["revision_id"] in {
|
|
item["revision_id"] for item in branched["group_revisions"]
|
|
}
|
|
assert [
|
|
record["storage_revision_id"]
|
|
for record in selected.manifest["chunks"][:3]
|
|
] == selected_sources
|
|
assert selected.manifest["chunks"][3]["storage_revision_id"] == selected.revision_id
|
|
assert selected.manifest["branch_provenance"]["branch_cut"] == {
|
|
"selected_revision_id": revision_b["revision_id"],
|
|
"after_physical_group": 3,
|
|
}
|
|
assert take_a._manifest_path().exists()
|
|
assert take_b._manifest_path().exists()
|
|
restarted, restarted_contract, restarted_nonce, _ = _resolve(
|
|
tmp_path,
|
|
_contract(chunks=5),
|
|
)
|
|
assert restarted.review_head["revision_id"] == selected.revision_id
|
|
assert restarted.review_head["validated_prefix_count"] == 4
|
|
assert (restarted_contract["reroll_from_chunk"], restarted_nonce) == (4, 3)
|
|
|
|
|
|
def test_n2b_use_take_changes_canonical_without_generating(tmp_path):
|
|
_persist(
|
|
tmp_path,
|
|
_contract(chunks=4, boundary=3, nonce=1),
|
|
prefix=3,
|
|
review_unit=(3, 3),
|
|
updated_utc="2026-09-03T00:00:01+00:00",
|
|
)
|
|
latest = _persist(
|
|
tmp_path,
|
|
_contract(chunks=4, boundary=3, nonce=2),
|
|
prefix=3,
|
|
review_unit=(3, 3),
|
|
updated_utc="2026-09-03T00:00:02+00:00",
|
|
)
|
|
project = _project(latest)
|
|
revision_a = _take(project, group=3, nonce=1)
|
|
selected, resolved, nonce, decision = _resolve(
|
|
tmp_path,
|
|
_contract(chunks=4),
|
|
take_action=TAKE_ACTION_USE,
|
|
take_group=3,
|
|
take_revision_id=revision_a["revision_id"],
|
|
)
|
|
assert selected.review_execution.max_new_physical_groups == 0
|
|
assert decision == "select_take"
|
|
_persist_resolved_branch(selected, resolved, new_positions=())
|
|
switched = _project(selected)
|
|
assert switched["canonical_head_revision_id"] == revision_a["revision_id"]
|
|
assert selected.generated_count == 0
|
|
assert selected.manifest["status"] == REVISION_STATUS_REVIEW_READY
|
|
|
|
restarted, _, restarted_nonce, _ = _resolve(tmp_path, _contract(chunks=4))
|
|
assert restarted.review_head["revision_id"] == selected.revision_id
|
|
assert restarted_nonce == nonce
|
|
|
|
|
|
def test_n2b_corrupt_project_recovers_last_valid_canonical_candidate(tmp_path):
|
|
first = _persist(
|
|
tmp_path,
|
|
_contract(chunks=3),
|
|
prefix=1,
|
|
review_unit=(1, 1),
|
|
updated_utc="2026-09-03T00:00:01+00:00",
|
|
)
|
|
expected = _project(first)["canonical_head_revision_id"]
|
|
(first.run_root / "project.json").write_text("{broken", encoding="utf-8")
|
|
controller = RunStorageController("phase-d-review")
|
|
controller.run_root = first.run_root
|
|
controller.revisions_root = first.revisions_root
|
|
controller.prompts = ["prompt 1", "prompt 2", "prompt 3"]
|
|
_, catalog, chains = controller._provenance_catalog()
|
|
storage_revision_id, chain = controller._canonical_project_selection(
|
|
catalog=catalog,
|
|
chains=chains,
|
|
)
|
|
assert storage_revision_id == first.revision_id
|
|
assert chain[-1] == expected
|
|
|
|
|
|
@pytest.mark.parametrize(
|
|
"status",
|
|
[REVISION_STATUS_IN_PROGRESS, REVISION_STATUS_INTERRUPTED],
|
|
)
|
|
def test_n2b_incomplete_revision_is_not_a_take_candidate(tmp_path, status):
|
|
complete = _persist(
|
|
tmp_path,
|
|
_contract(chunks=3),
|
|
prefix=1,
|
|
review_unit=(1, 1),
|
|
updated_utc="2026-09-03T00:00:01+00:00",
|
|
)
|
|
incomplete = _controller(tmp_path, _contract(chunks=3, boundary=2, nonce=1))
|
|
incomplete.commit_chunk(_entry(0, incomplete.contract), position=0)
|
|
incomplete.manifest.update(
|
|
status=status,
|
|
updated_utc="2026-09-03T00:00:02+00:00",
|
|
)
|
|
incomplete._write_manifest()
|
|
|
|
manifests, catalog, chains = incomplete._provenance_catalog()
|
|
assert complete.revision_id in chains
|
|
assert incomplete.revision_id in manifests
|
|
assert incomplete.revision_id not in chains
|
|
assert all(
|
|
revision["storage_revision_id"] != incomplete.revision_id
|
|
for revision in catalog.values()
|
|
)
|
|
|
|
|
|
def test_n2b_wrong_group_selector_is_rejected(tmp_path):
|
|
stored = _persist(
|
|
tmp_path,
|
|
_contract(chunks=3),
|
|
prefix=2,
|
|
review_unit=(2, 2),
|
|
updated_utc="2026-09-03T00:00:01+00:00",
|
|
)
|
|
revision = _take(_project(stored), group=2, nonce=0)
|
|
with pytest.raises(RunStorageError, match="group does not match"):
|
|
_resolve(
|
|
tmp_path,
|
|
_contract(chunks=3),
|
|
take_action=TAKE_ACTION_USE,
|
|
take_group=1,
|
|
take_revision_id=revision["revision_id"],
|
|
)
|
|
|
|
|
|
def _production_kwargs():
|
|
return {
|
|
"model": object(),
|
|
"clip": object(),
|
|
"video_vae": object(),
|
|
"sampler": object(),
|
|
"sigmas": torch.tensor([1.0, 0.0]),
|
|
"sequence_prompt": "prompt",
|
|
"prompt_mode": "Fixed",
|
|
"chunks": 2,
|
|
"chunk_seconds": 5.0,
|
|
"width": 96,
|
|
"height": 64,
|
|
"continuity": "Balanced — 22 frames",
|
|
"base_seed": 1234,
|
|
"audio_continuity": True,
|
|
"diagnostics": "Basic",
|
|
"reroll_from_chunk": "Auto",
|
|
"reroll_nonce": 0,
|
|
"strict_compatibility": False,
|
|
"debug": False,
|
|
"show_preview": False,
|
|
"run_storage": "Save + Auto Resume",
|
|
"generation_mode": GENERATION_MODE_REVIEW,
|
|
"review_action": REVIEW_ACTION_CONTINUE,
|
|
}
|
|
|
|
|
|
def test_production_internal_review_configures_storage_and_finalizes_metadata(
|
|
monkeypatch,
|
|
):
|
|
import ComfyUI_H3_Continuum_Join.run_storage as run_storage
|
|
|
|
class _Storage:
|
|
def __init__(self):
|
|
self.configured = None
|
|
self.finalized = None
|
|
self.review_execution = SimpleNamespace(status_hint="review status")
|
|
|
|
def __enter__(self):
|
|
return self
|
|
|
|
def __exit__(self, exc_type, exc, traceback):
|
|
return False
|
|
|
|
def configure_review(self, **kwargs):
|
|
self.configured = kwargs
|
|
|
|
def summary(self, *, detailed=False):
|
|
return "storage summary"
|
|
|
|
def review_pause_metadata(self):
|
|
return {
|
|
"review_unit": {"start": 1, "end": 1, "physical_group": 1},
|
|
"review_pause_reason": "review_each_chunk",
|
|
}
|
|
|
|
def finalize(self, **kwargs):
|
|
self.finalized = kwargs
|
|
|
|
storage = _Storage()
|
|
monkeypatch.setattr(run_storage, "run_storage_scope", lambda *a, **k: storage)
|
|
monkeypatch.setattr(run_storage, "automatic_project_key", lambda *a, **k: "key")
|
|
monkeypatch.setattr(
|
|
H3ContinuumSamplerV3,
|
|
"run",
|
|
lambda self, **kwargs: (
|
|
{"samples": torch.zeros(1)},
|
|
{"samples": torch.zeros(1)},
|
|
{"target_frames": 120},
|
|
{
|
|
"last_state": {},
|
|
"session": {"session_id": "session", "chunks": [{}]},
|
|
"report": "sampling report",
|
|
},
|
|
),
|
|
)
|
|
|
|
outputs = H3ContinuumSamplerProduction().run(**_production_kwargs())
|
|
assert storage.configured == {
|
|
"generation_mode": GENERATION_MODE_REVIEW,
|
|
"review_action": REVIEW_ACTION_CONTINUE,
|
|
"manual_regenerate_from": 0,
|
|
"take_group": 0,
|
|
"take_revision_id": "",
|
|
"take_action": "Automatic",
|
|
}
|
|
assert storage.finalized["review_pause_metadata"]["review_unit"]["start"] == 1
|
|
assert "review status" in outputs[3]
|
|
|
|
|
|
def test_production_uses_reconciled_review_unit_for_decode_scope(monkeypatch):
|
|
import ComfyUI_H3_Continuum_Join.run_storage as run_storage
|
|
|
|
contract = _contract(chunks=3)
|
|
entries = [_entry(position, contract) for position in range(3)]
|
|
full_decode, full_plan = prepare_physical_decode_entries(
|
|
entries,
|
|
chunk_seconds=5.0,
|
|
preserve_final_frame=False,
|
|
terminal_merged=False,
|
|
)
|
|
|
|
class _Storage:
|
|
review_generation_mode = None
|
|
review_execution = None
|
|
finalized = None
|
|
|
|
def __enter__(self):
|
|
return self
|
|
|
|
def __exit__(self, exc_type, exc, traceback):
|
|
return False
|
|
|
|
def configure_review(self, **kwargs):
|
|
self.review_generation_mode = kwargs["generation_mode"]
|
|
|
|
def summary(self, *, detailed=False):
|
|
return "storage summary"
|
|
|
|
def review_pause_metadata(self):
|
|
return {
|
|
"review_unit": {"start": 2, "end": 2, "physical_group": 2},
|
|
"review_pause_reason": "review_each_chunk",
|
|
}
|
|
|
|
def finalize(self, **kwargs):
|
|
self.finalized = kwargs
|
|
|
|
storage = _Storage()
|
|
monkeypatch.setattr(run_storage, "run_storage_scope", lambda *a, **k: storage)
|
|
monkeypatch.setattr(run_storage, "automatic_project_key", lambda *a, **k: "key")
|
|
|
|
def fake_v3_run(self, **kwargs):
|
|
storage.review_execution = SimpleNamespace(
|
|
status_hint="review status",
|
|
finish_remaining=False,
|
|
next_review_unit_start=2,
|
|
next_review_unit_end=2,
|
|
partial_review=True,
|
|
smart_regenerate=False,
|
|
)
|
|
return (
|
|
[{"samples": entry["video"]} for entry in full_decode],
|
|
[{"samples": entry["audio"]} for entry in full_decode],
|
|
full_plan,
|
|
{
|
|
"last_state": {},
|
|
"session": {"session_id": "session", "chunks": entries},
|
|
"report": "sampling report",
|
|
},
|
|
)
|
|
|
|
monkeypatch.setattr(H3ContinuumSamplerV3, "run", fake_v3_run)
|
|
kwargs = _production_kwargs()
|
|
kwargs["chunks"] = 3
|
|
outputs = H3ContinuumSamplerProduction().run(**kwargs)
|
|
|
|
assert len(outputs[0]) == len(outputs[1]) == 1
|
|
assert torch.equal(outputs[0][0]["samples"], entries[1]["video"])
|
|
assert outputs[2]["target_frames"] == 120
|
|
assert outputs[2]["chunks"][0]["chunk_index"] == 2
|
|
assert len(storage.finalized["session"]["chunks"]) == 3
|
|
assert "Decode preview: Chunk 2" in outputs[3]
|
|
|
|
|
|
def test_review_decode_range_only_selects_a_current_review_unit():
|
|
execution = SimpleNamespace(
|
|
finish_remaining=False,
|
|
next_review_unit_start=2,
|
|
next_review_unit_end=2,
|
|
partial_review=True,
|
|
smart_regenerate=False,
|
|
)
|
|
storage = SimpleNamespace(
|
|
review_generation_mode=GENERATION_MODE_REVIEW,
|
|
review_execution=execution,
|
|
)
|
|
assert _review_decode_chunk_range(
|
|
storage,
|
|
capture_refine_context=False,
|
|
) == (2, 2)
|
|
assert _review_decode_chunk_range(
|
|
storage,
|
|
capture_refine_context=True,
|
|
) == (2, 2)
|
|
|
|
execution.partial_review = False
|
|
assert _review_decode_chunk_range(
|
|
storage,
|
|
capture_refine_context=False,
|
|
) is None
|
|
execution.smart_regenerate = True
|
|
assert _review_decode_chunk_range(
|
|
storage,
|
|
capture_refine_context=False,
|
|
) == (2, 2)
|
|
execution.finish_remaining = True
|
|
assert _review_decode_chunk_range(
|
|
storage,
|
|
capture_refine_context=False,
|
|
) is None
|
|
|
|
|
|
def test_projection_decision_is_pure_and_refuses_to_split_physical_groups():
|
|
session = {"chunks": [{}, {}, {}]}
|
|
execution = SimpleNamespace(
|
|
finish_remaining=False,
|
|
next_review_unit_start=2,
|
|
next_review_unit_end=3,
|
|
partial_review=False,
|
|
smart_regenerate=True,
|
|
)
|
|
|
|
decision = resolve_projection_decision(
|
|
review_execution=execution,
|
|
effective_result_status=REVISION_STATUS_REVIEW_READY,
|
|
session=session,
|
|
physical_group_facts=((1,), (2, 3)),
|
|
)
|
|
assert decision.kind == PROJECTION_CURRENT_REVIEW_UNIT
|
|
assert (decision.start_chunk, decision.end_chunk) == (2, 3)
|
|
|
|
split_terminal_group = resolve_projection_decision(
|
|
review_execution=SimpleNamespace(
|
|
finish_remaining=False,
|
|
next_review_unit_start=2,
|
|
next_review_unit_end=2,
|
|
partial_review=True,
|
|
smart_regenerate=False,
|
|
),
|
|
effective_result_status=REVISION_STATUS_REVIEW_READY,
|
|
session=session,
|
|
physical_group_facts=((1,), (2, 3)),
|
|
)
|
|
assert split_terminal_group.kind == PROJECTION_FULL_ACCEPTED_PREFIX
|
|
|
|
complete = resolve_projection_decision(
|
|
review_execution=execution,
|
|
effective_result_status=REVISION_STATUS_COMPLETE,
|
|
session=session,
|
|
physical_group_facts=((1,), (2, 3)),
|
|
)
|
|
assert complete.kind == PROJECTION_FULL_ACCEPTED_PREFIX
|
|
|
|
|
|
def test_partial_review_rebuilds_decode_outputs_without_truncating_session():
|
|
contract = _contract(chunks=3)
|
|
entries = [_entry(position, contract) for position in range(3)]
|
|
full_decode, full_plan = prepare_physical_decode_entries(
|
|
entries,
|
|
chunk_seconds=5.0,
|
|
preserve_final_frame=False,
|
|
terminal_merged=False,
|
|
)
|
|
verified_route_plan = {"mode": "Custom", "accepted_chunks": 3, "groups": []}
|
|
full_plan["reference_routing_v1"] = verified_route_plan
|
|
result = {
|
|
"last_state": {},
|
|
"session": {"session_id": "session", "chunks": entries},
|
|
"report": "sampling report",
|
|
}
|
|
outputs = (
|
|
[{"samples": entry["video"]} for entry in full_decode],
|
|
[{"samples": entry["audio"]} for entry in full_decode],
|
|
full_plan,
|
|
result,
|
|
{"full_refine_context": True},
|
|
)
|
|
refine_context = outputs[4]
|
|
storage = SimpleNamespace(
|
|
review_generation_mode=GENERATION_MODE_REVIEW,
|
|
review_execution=SimpleNamespace(
|
|
finish_remaining=False,
|
|
next_review_unit_start=2,
|
|
next_review_unit_end=2,
|
|
partial_review=True,
|
|
smart_regenerate=False,
|
|
),
|
|
)
|
|
|
|
scoped = _apply_review_decode_scope(
|
|
outputs,
|
|
storage=storage,
|
|
capture_refine_context=True,
|
|
configured_chunks=3,
|
|
chunk_seconds=5.0,
|
|
first_frame=None,
|
|
last_frame=None,
|
|
timeline_video_source=None,
|
|
)
|
|
|
|
assert len(scoped[0]) == len(scoped[1]) == 1
|
|
assert torch.equal(scoped[0][0]["samples"], entries[1]["video"])
|
|
assert torch.equal(scoped[1][0]["samples"], entries[1]["audio"])
|
|
assert scoped[2]["target_frames"] == 120
|
|
assert scoped[2]["reference_routing_v1"] is verified_route_plan
|
|
assert scoped[2]["chunks"][0]["sequence_index"] == 1
|
|
assert scoped[2]["chunks"][0]["chunk_index"] == 2
|
|
assert scoped[2]["second_pass_contract"]["physical_groups"][0][
|
|
"logical_chunks"
|
|
] == [2]
|
|
assert len(scoped[3]["session"]["chunks"]) == 3
|
|
assert scoped[3]["session"] is result["session"]
|
|
assert scoped[3]["report"].endswith("Decode preview: Chunk 2")
|
|
assert scoped[4] is refine_context
|
|
|
|
|
|
def test_production_review_mode_rejects_run_storage_off():
|
|
kwargs = _production_kwargs()
|
|
kwargs["run_storage"] = "Off"
|
|
with pytest.raises(ValueError, match="requires Run Storage"):
|
|
H3ContinuumSamplerProduction().run(**kwargs)
|