diff --git a/__init__.py b/__init__.py
index 3bccdd5..d87b193 100644
--- a/__init__.py
+++ b/__init__.py
@@ -3161,3 +3161,10 @@ from .iamccs_moss_frame_output import (
 )
 NODE_CLASS_MAPPINGS.update(_MOSS_RESULT_CLASSES)
 NODE_DISPLAY_NAME_MAPPINGS.update(_MOSS_RESULT_NAMES)
+
+from .iamccs_minimax_h3_open_refine import (
+    NODE_CLASS_MAPPINGS as _OPEN_H3_REFINE_CLASSES,
+    NODE_DISPLAY_NAME_MAPPINGS as _OPEN_H3_REFINE_NAMES,
+)
+NODE_CLASS_MAPPINGS.update(_OPEN_H3_REFINE_CLASSES)
+NODE_DISPLAY_NAME_MAPPINGS.update(_OPEN_H3_REFINE_NAMES)
diff --git a/iamccs_h3_continuity_guard.py b/iamccs_h3_continuity_guard.py
new file mode 100644
index 0000000..b86b72c
--- /dev/null
+++ b/iamccs_h3_continuity_guard.py
@@ -0,0 +1,174 @@
+# SPDX-FileCopyrightText: 2026 Carmine Cristallo Scalzi (IAMCCS)
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""Read-only continuation diagnostics. Reports are evidence, not identity scores."""
+from __future__ import annotations
+
+import hashlib
+import json
+import logging
+import math
+import re
+import shutil
+import uuid
+from pathlib import Path
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+
+
+def settings_schema():
+    # Retired fields keep their positions so existing workflows still load.
+    retired = "Retired compatibility field. Ignored; no repair or reference injection runs."
+    return {
+        "h3_guard_mode": (["off", "monitor", "repair"], {"default": "off", "display_name": "GUARD - MODE", "tooltip": "Read-only Extended AV diagnostics. Legacy repair values resolve to Off with a warning."}),
+        "h3_guard_reference_memory": ("BOOLEAN", {"default": True, "display_name": "RETIRED - REFERENCE MEMORY", "tooltip": retired}),
+        "h3_guard_repair_denoise": ("FLOAT", {"default": 0.15, "min": 0.01, "max": 0.35, "step": 0.01, "display_name": "RETIRED - REPAIR DENOISE", "tooltip": retired}),
+        "h3_guard_repair_steps": ("INT", {"default": 6, "min": 1, "max": 30, "display_name": "RETIRED - REPAIR STEPS", "tooltip": retired}),
+        "h3_guard_detail_ratio": ("FLOAT", {"default": 0.65, "min": 0.1, "max": 1.0, "step": 0.01, "display_name": "GUARD - DETAIL LOSS THRESHOLD", "tooltip": "Diagnostic heuristic only. Camera, focus and motion changes can cause false alarms."}),
+        "h3_guard_motion_tolerance": ("FLOAT", {"default": 0.20, "min": 0.01, "max": 1.0, "step": 0.01, "display_name": "RETIRED - MOTION CHANGE LIMIT", "tooltip": retired}),
+    }
+
+
+
+def effective_mode(config):
+    mode = config.get("mode", "off")
+    if mode == "repair":
+        logging.getLogger(__name__).warning(
+            "Continuity Guard Repair has been retired after unsuccessful validation; using Off. "
+            "Select Monitor for read-only diagnostics.")
+        return "off"
+    if mode not in {"off", "monitor"}:
+        raise ValueError("Unknown Continuity Guard mode")
+    return mode
+
+
+def configuration(settings):
+    mode = effective_mode({"mode": settings.get("h3_guard_mode", "off")})
+    threshold = float(settings.get("h3_guard_detail_ratio", 0.65))
+    if not math.isfinite(threshold) or not 0 < threshold <= 1:
+        raise ValueError("Invalid Continuity Guard detail ratio")
+    return {"mode": mode, "detail_ratio": threshold}
+
+
+def storage(output_directory, render_id):
+    if not render_id:
+        raise ValueError("Continuity Guard requires the R49 render identity")
+    key = hashlib.sha256(str(render_id).encode()).hexdigest()[:24]
+    path = Path(output_directory) / "IAMCCS" / "continuity_guard" / key
+    path.mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def conditioning_identity(render_id, index):
+    # R49 assigns the definitive, numbered name at the first native checkpoint.
+    if int(index) == 0:
+        return uuid.uuid4().hex
+    if not str(render_id or "").strip():
+        raise ValueError("Guard continuation requires its predecessor's checkpoint render identity")
+    return str(render_id)
+
+
+def bind_checkpoint(output_directory, report, render_id):
+    """Bind the first segment's provisional measurements to R49's final name."""
+    key = report["storage_key"]
+    if not isinstance(key, str) or not re.fullmatch(r"[0-9a-f]{24}", key):
+        raise ValueError("Invalid Continuity Guard storage key")
+    source = Path(output_directory) / "IAMCCS" / "continuity_guard" / key
+    destination = storage(output_directory, render_id)
+    if source == destination:
+        return
+    if int(report["segment_index"]) != 0:
+        raise ValueError("Guard continuation measurements do not match the checkpoint render identity")
+    for name in ("baseline.json", "segment_0000.json"):
+        path = source / name
+        if path.is_file():
+            shutil.copy2(path, destination / name)
+    if not (destination / "baseline.json").is_file():
+        raise ValueError("Guard first-segment baseline is missing before checkpoint binding")
+    write_report(destination / "checkpoint_identity.json", {"render_id": str(render_id), "provisional_storage_key": key})
+
+
+def write_report(path, data):
+    temporary = path.with_suffix(".tmp")
+    temporary.write_text(json.dumps(data, indent=2, allow_nan=False), encoding="utf-8")
+    temporary.replace(path)
+
+
+def analysis_frames(images):
+    # One analysis size for all segments; at most 48 frames, with uniform timing.
+    ids = torch.linspace(0, images.shape[0] - 1, min(48, images.shape[0]), device=images.device).round().long()
+    x = images[ids, ..., :3].movedim(-1, 1).float()
+    x = F.interpolate(x, size=(144, 256), mode="area")
+    return (x[:, 0] * 0.2126 + x[:, 1] * 0.7152 + x[:, 2] * 0.0722).clamp(0, 1).cpu().numpy()
+
+
+def measure(images):
+    import cv2
+    gray = analysis_frames(images)
+    detail = [float(np.mean(np.abs(cv2.Laplacian(f, cv2.CV_32F)))) for f in gray]
+    light = gray.mean(axis=(1, 2))
+    intervals = max(1, images.shape[0] - 1) / max(1, len(gray) - 1)
+    flow = []
+    for a, b in zip(gray[:-1], gray[1:]):
+        field = cv2.calcOpticalFlowFarneback((a * 255).astype('uint8'), (b * 255).astype('uint8'), None, .5, 3, 15, 3, 5, 1.2, 0)
+        flow.append(float(np.median(np.linalg.norm(field, axis=-1))) / intervals)
+    # Native-resolution tiles prevent large textured regions from hiding local blur.
+    ids = torch.linspace(0, images.shape[0]-1, min(24, images.shape[0]), device=images.device).long()
+    native = images[ids, ..., :3].float().mean(-1).cpu().numpy()
+    tiles = []
+    for row in range(4):
+        for col in range(4):
+            patch = native[:, row*native.shape[1]//4:(row+1)*native.shape[1]//4,
+                           col*native.shape[2]//4:(col+1)*native.shape[2]//4]
+            values = [float(np.mean(abs(cv2.Laplacian(f, cv2.CV_32F)))) for f in patch]
+            tiles.append(float(np.median(values)))
+    return {"local_detail": tiles, "detail": float(np.median(detail)), "luminance": float(np.median(light)),
+            "flicker": float(np.median(np.abs(np.diff(light, n=2)))) if len(light) > 2 else 0.0,
+            "motion": float(np.median(flow)) if flow else 0.0,
+            "frames": int(images.shape[0]), "analysis": "luma_texture_optical_flow_v1",
+            "limitations": "No semantic identity, intent or lip-sync certification."}
+
+
+def assess(current, baseline, config):
+    ratio = current["detail"] / max(baseline["detail"], 1e-6)
+    exposure = abs(current["luminance"] - baseline["luminance"])
+    moving = current["motion"] / max(baseline["motion"], 0.02)
+    uncertain = exposure > 0.15 or moving < 0.4 or moving > 2.5
+    local_before = baseline.get("local_detail", [])
+    local_now = current.get("local_detail", [])
+    local_ratios = [b/max(a, 1e-6) for a,b in zip(local_before, local_now)]
+    # 10% local texture loss is a candidate trigger, never proof of degradation.
+    affected = [i for i,r in enumerate(local_ratios) if r < .90 and local_before[i] > .005]
+    loss = ratio < config["detail_ratio"] or bool(affected)
+    return {"detail_ratio": ratio, "local_detail_ratios": local_ratios, "affected_tiles": affected, "exposure_change": exposure, "motion_ratio": moving,
+            "texture_loss_detected": bool(loss and not uncertain),
+            "review_recommended": bool(uncertain or loss)}
+
+
+def process(config, sampled, raw_frames, *, directory, index, head_frames, visible_frames):
+    """Measure decoded frames without modifying video, audio or conditioning."""
+    if effective_mode(config) != "monitor":
+        return sampled, raw_frames, {"status": "off", "repair_attempts": 0}
+
+    visible = raw_frames[head_frames:head_frames + visible_frames]
+    current = measure(visible)
+    baseline_path = directory / "baseline.json"
+    report = {"schema": "iamccs.guard.report.v1", "segment_index": index,
+              "storage_key": directory.name,
+              "mode": config["mode"], "before": current, "repair_attempts": 0,
+              "audio_policy": "Original sampled audio preserved exactly", "status": "monitored"}
+    if index == 0:
+        write_report(baseline_path, current)
+        report["status"] = "baseline_recorded"
+    elif not baseline_path.is_file():
+        raise ValueError("Guard baseline missing. Start this render from its first segment.")
+    else:
+        baseline = json.loads(baseline_path.read_text(encoding="utf-8"))
+        verdict = assess(current, baseline, config)
+        report["assessment"] = verdict
+        if verdict["review_recommended"]:
+            report["status"] = "review_recommended"
+    write_report(directory / f"segment_{index:04d}.json", report)
+    sampled = {**sampled, "_iamccs_continuity_guard": report}
+    return sampled, raw_frames, report
diff --git a/iamccs_minimax_h3_atomic_backend.py b/iamccs_minimax_h3_atomic_backend.py
index b972ab2..146fe1c 100644
--- a/iamccs_minimax_h3_atomic_backend.py
+++ b/iamccs_minimax_h3_atomic_backend.py
@@ -1426,7 +1426,15 @@ def _secondary_lora_settings(shotplan: dict[str, Any]) -> dict[str, Any]:
     return settings if isinstance(settings, dict) else {"enabled": False}
 
 
-def _apply_secondary_lora(model, shotplan: dict[str, Any], include_vfx=False):
+def _secondary_lora_applies_to_segment(shotplan: dict[str, Any], chunk_index: int = 0) -> bool:
+    """Scope the optional slot to temporal segments, including external resumes."""
+    settings = _secondary_lora_settings(shotplan)
+    return (not bool(settings.get("continuation_only", False))
+            or int(chunk_index) > 0
+            or _external_continuation_active(shotplan, int(chunk_index)))
+
+
+def _apply_secondary_lora(model, shotplan: dict[str, Any], include_vfx=False, chunk_index=0):
     """Apply an independent model-only H3 LoRA without changing sampling.
 
     The second slot is deliberately separate from Turbo. It never selects a
@@ -1447,6 +1455,8 @@ def _apply_secondary_lora(model, shotplan: dict[str, Any], include_vfx=False):
             return model, f"off (optional H3 LoRA unavailable: {missing})"
         return model, "off"
 
+    if not _secondary_lora_applies_to_segment(shotplan, chunk_index):
+        return model, "off (segment 1; second LoRA starts at segment 2)"
     lora_name = str(settings.get("lora_name", "") or "").strip()
     strength = float(settings.get("strength", 0.0) or 0.0)
     if not lora_name or abs(strength) <= 1e-8:
@@ -1474,7 +1484,8 @@ def _apply_secondary_lora(model, shotplan: dict[str, Any], include_vfx=False):
             f"Could not apply secondary MiniMax H3 LoRA '{lora_name}'. "
             "Verify that it is compatible with the selected FL2VA/REF2VA base model."
         ) from exc
-    return patched, f"native model-only H3 LoRA {lora_name}@{strength:.2f}"
+    scope = "continuation-only" if settings.get("continuation_only", False) else "all-segments"
+    return patched, f"native model-only H3 LoRA {lora_name}@{strength:.2f} ({scope}, segment {int(chunk_index) + 1})"
 
 
 def _turbo_sampler(shotplan: dict[str, Any]):
@@ -3070,6 +3081,11 @@ class IAMCCS_MiniMaxH3AtomicConditioningBackend:
             prefix_frames=control_prefix_frames,
         )
         positive, refmod_report = _apply_h3_refmod(positive, shotplan)
+        guard_config = shotplan.get("continuity_guard", {})
+        if guard_config.get("mode", "off") == "monitor" and shotboard_task == "fl2va_extended_av":
+            from .iamccs_h3_continuity_guard import conditioning_identity
+            guard_id = conditioning_identity(render_id, segment_index)
+            motion_state["continuity_guard_render_id"] = guard_id
         if legacy_actual_output_bridge:
             motion_report += "; legacy_actual_output_bridge_ignored"
         if motion_state["active"] and motion_state.get("strategy") == "reference_motion_carry":
@@ -3269,7 +3285,7 @@ class IAMCCS_MiniMaxH3GenerationBackendV2:
         turbo_model, turbo_report = _apply_turbo_lora(model, shotplan)
         fasth3_model, fasth3_report = _apply_fasth3_dense_lora(turbo_model, shotplan)
         pdd_model, pdd_report = _apply_pdd_lora(fasth3_model, shotplan)
-        lora_model, secondary_lora_report = _apply_secondary_lora(pdd_model, shotplan, include_vfx=True)
+        lora_model, secondary_lora_report = _apply_secondary_lora(pdd_model, shotplan, include_vfx=True, chunk_index=chunk_index)
         if turbo_enabled:
             # Apply the selected Turbo LoRA without silently replacing any
             # authored sampler, scheduler or AV shift.  Presets populate those
@@ -3558,6 +3574,16 @@ class IAMCCS_MiniMaxH3GenerationBackendV2:
             cleanup_report = _clean_vram_before_decode()
 
         native_frames = comfy_nodes.VAEDecode().decode(vae=video_vae, samples=sampled)[0]
+        guard_report = {"status": "off"}
+        guard_config = shotplan.get("continuity_guard", {})
+        if guard_config.get("mode", "off") == "monitor" and shotplan.get("task_mode") == "fl2va_extended_av":
+            from .iamccs_h3_continuity_guard import process as process_guard, storage as guard_storage
+            guard_directory = guard_storage(folder_paths.get_output_directory(), motion_state["continuity_guard_render_id"])
+            sampled, native_frames, guard_report = process_guard(
+                guard_config, sampled, native_frames, directory=guard_directory, index=int(chunk_index),
+                head_frames=int(motion_state.get("trim_frames", 0)),
+                visible_frames=int(motion_state["export_frames"]))
+            LOG.info("IAMCCS Continuity Guard | chunk=%d | %s | report=%s", int(chunk_index)+1, guard_report["status"], guard_directory)
         native_audio = VAEDecodeAudio.execute(vae=audio_vae, samples=sampled)[0]
         if (
             isinstance(sampled, dict)
@@ -3977,6 +4003,7 @@ class IAMCCS_MiniMaxH3GenerationBackendV2:
             f"lipsync_lock={lipsync_lock_report} | "
             f"pre_sample_cleanup={conditioning_cleanup} | "
             f"terminal_closure={terminal_closure_report} | "
+            f"continuity_guard={guard_report['status']} | "
             f"pre_decode_cleanup={cleanup_report} | native_last_frame=captured | "
             f"resolution={resolution_contract} | "
             f"pianosequenza={pianosequenza_report} | "
diff --git a/iamccs_minimax_h3_latent_upres_variant.py b/iamccs_minimax_h3_latent_upres_variant.py
index 1ee3e47..a6b784c 100644
--- a/iamccs_minimax_h3_latent_upres_variant.py
+++ b/iamccs_minimax_h3_latent_upres_variant.py
@@ -214,7 +214,7 @@ class IAMCCS_MiniMaxH3LatentUpresSamplingR38:
         shift_video = float(sampling.get("shift_video", 12.0))
         shift_audio = float(sampling.get("shift_audio", 3.0))
         turbo_model, turbo_report = _apply_turbo_lora(model, plan)
-        lora_model, secondary_lora_report = _apply_secondary_lora(turbo_model, plan)
+        lora_model, secondary_lora_report = _apply_secondary_lora(turbo_model, plan, chunk_index=segment_index)
         shifted = MiniMaxH3SigmaShift.execute(model=lora_model, shift_video=shift_video, shift_audio=shift_audio)[0]
         if str(plan.get("acceleration", "native")).lower() == "comfy_kitchen":
             from comfy_extras.nodes_model_advanced import ModelAttentionBackend
diff --git a/iamccs_minimax_h3_masked_loop_guided.py b/iamccs_minimax_h3_masked_loop_guided.py
index bf7f531..43cfbf7 100644
--- a/iamccs_minimax_h3_masked_loop_guided.py
+++ b/iamccs_minimax_h3_masked_loop_guided.py
@@ -358,7 +358,7 @@ class IAMCCS_MiniMaxH3MaskedLoopGuidedSampler:
         turbo_model, turbo_report = _apply_turbo_lora(model, shotplan)
         fasth3_model, fasth3_report = _apply_fasth3_dense_lora(turbo_model, shotplan)
         pdd_model, pdd_report = _apply_pdd_lora(fasth3_model, shotplan)
-        lora_model, secondary_report = _apply_secondary_lora(pdd_model, shotplan)
+        lora_model, secondary_report = _apply_secondary_lora(pdd_model, shotplan, chunk_index=chunk_index)
         turbo = _turbo_settings(shotplan)
         turbo_name = str(turbo.get("lora_name", "") or "").strip()
         turbo_enabled = bool(
diff --git a/iamccs_minimax_h3_open_refine.py b/iamccs_minimax_h3_open_refine.py
new file mode 100644
index 0000000..63f835b
--- /dev/null
+++ b/iamccs_minimax_h3_open_refine.py
@@ -0,0 +1,78 @@
+# SPDX-License-Identifier: GPL-3.0-or-later
+"""Settings bridge for the stock-node Open-H3 delivery branch."""
+
+import folder_paths
+
+
+PREFIX = "h3_open_refine_"
+SIGMAS = {
+    "gentle_3step": "0.8, 0.6857142857, 0.48, 0",
+    "reference_3step": "0.909375, 0.857143, 0.666667, 0",
+}
+
+
+def settings_schema():
+    loras = ["", *folder_paths.get_filename_list("loras")]
+    upscalers = ["", *folder_paths.get_filename_list("latent_upscale_models")] if "latent_upscale_models" in folder_paths.folder_names_and_paths else [""]
+    refiner = next((name for name in loras if name.lower().endswith("minimax_h3_open_regenerate_2k_refiner_rank_384_bf16.safetensors")), "")
+    distill = next((name for name in loras if name.lower().endswith("minimax_h3_fl2v_lightx2v_turbo_4step_v0.1_comfy.safetensors")), "")
+    upscaler = next((name for name in upscalers if name.lower().endswith("minimax_h3_latent_upscaler_3d_fp16.safetensors")), "")
+    fields = {
+        "enabled": ("BOOLEAN", {"default": False, "display_name": "OPEN-H3 · ENABLE REFINEMENT", "tooltip": "One native generation followed by Open-H3. Replaces the other upscale routes; requires the Open-H3 workflow branch."}),
+        "scale": ("FLOAT", {"default": 2.0, "min": 1.0, "max": 4.0, "step": 0.05, "display_name": "OPEN-H3 · SPATIAL SCALE", "tooltip": "Learned latent upscale. Output follows the native aspect ratio, rounded to the H3 grid. Full-resolution refinement can exceed low-VRAM capacity."}),
+        "model_name": (upscalers, {"default": upscaler, "display_name": "OPEN-H3 · LATENT UPSCALER"}),
+        "precision": (["fp16", "bf16", "fp32"], {"default": "fp16", "display_name": "OPEN-H3 · UPSCALER PRECISION"}),
+        "device": (["cuda", "rocm", "cpu"], {"default": "cuda", "display_name": "OPEN-H3 · UPSCALER DEVICE"}),
+        "temporal_chunking": ("BOOLEAN", {"default": True, "display_name": "OPEN-H3 · UPSCALER CHUNKING", "tooltip": "Chunks the latent upscaler only. The three-step H3 sampler still processes the complete target latent."}),
+        "lora_name": (loras, {"default": refiner, "display_name": "OPEN-H3 · REFINER LORA"}),
+        "strength": ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01, "display_name": "OPEN-H3 · REFINER STRENGTH"}),
+        "distill_lora_name": (loras, {"default": distill, "display_name": "OPEN-H3 · DISTILLATION LORA", "tooltip": "Kijai's rank-384 file contains only the refiner. The supplied community recipe pairs it with LightX2V v0.1; it is not NVIDIA's complete rank-576 bundle. Leave blank when the selected refiner already includes distillation."}),
+        "distill_strength": ("FLOAT", {"default": 1.0, "min": -10.0, "max": 10.0, "step": 0.01, "display_name": "OPEN-H3 · DISTILLATION STRENGTH"}),
+        "sigma_preset": (["gentle_3step", "reference_3step", "custom"], {"default": "gentle_3step", "display_name": "OPEN-H3 · NOISE SCHEDULE", "tooltip": "Gentle starts at 0.8. Reference starts at 0.909375 and can change identity or performance. Neither preset guarantees preservation."}),
+        "custom_sigmas": ("STRING", {"default": SIGMAS["gentle_3step"], "multiline": False, "display_name": "OPEN-H3 · CUSTOM SIGMAS", "tooltip": "Used only with Custom. Comma-separated Euler sigmas ending in zero."}),
+        "seed": ("INT", {"default": 777, "min": 0, "max": 0xffffffffffffffff, "control_after_generate": False, "display_name": "OPEN-H3 · REFINE SEED"}),
+        "prompt": ("STRING", {"default": "", "multiline": True, "display_name": "OPEN-H3 · REFINE PROMPT", "tooltip": "Blank uses the current shot prompt. Describe the existing action and appearance; new instructions can redraw the performance."}),
+    }
+    return {PREFIX + name: spec for name, spec in fields.items()}
+
+
+def configuration(settings):
+    return {name[len(PREFIX):]: settings.get(name, spec[1]["default"]) for name, spec in settings_schema().items()}
+
+
+class IAMCCS_MiniMaxH3OpenRefineControl:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {"cine_linx": ("IAMCCS_SUPERNODE_LINX",), "segment_index": ("INT", {"default": 0, "min": 0, "forceInput": True})}}
+
+    # File names feed both legacy list-combos and V3 COMBO sockets.
+    RETURN_TYPES = ("BOOLEAN", "STRING", "FLOAT", "*", "COMBO", "COMBO", "BOOLEAN", "*", "FLOAT", "*", "FLOAT", "STRING", "INT", "BOOLEAN")
+    RETURN_NAMES = ("enabled", "prompt", "scale", "upscaler_name", "precision", "device", "temporal_chunking", "refiner_lora", "refiner_strength", "distill_lora", "distill_strength", "sigmas", "seed", "use_face_source")
+    FUNCTION = "resolve"
+    CATEGORY = "IAMCCS/MiniMax H3/Delivery"
+
+    def resolve(self, cine_linx, segment_index):
+        # Atomic imports Shotboard, which imports this module's settings schema.
+        from .iamccs_minimax_h3_atomic_backend import _resolve_shotplan
+
+        plan = _resolve_shotplan(cine_linx)
+        cfg = plan.get("open_h3_refine") or configuration({})
+        enabled = bool(cfg["enabled"])
+        if enabled and bool(plan.get("upscale_enabled")) and plan.get("upscale_mode", "off") != "off":
+            raise ValueError("Open-H3 replaces the other upscale routes. Select Open-H3 in Settings PRO Mode Assistant.")
+        if enabled and not cfg["lora_name"]:
+            raise ValueError("Select an Open-H3 refiner LoRA in Settings PRO Output.")
+        if enabled and not cfg["model_name"]:
+            raise ValueError("Select an H3 latent upscaler in Settings PRO Output.")
+        chunks = plan.get("chunks") or []
+        chunk = chunks[segment_index] if 0 <= segment_index < len(chunks) else {}
+        prompt = cfg["prompt"] or chunk.get("prompt") or plan.get("global_prompt", "")
+        sigmas = cfg["custom_sigmas"] if cfg["sigma_preset"] == "custom" else SIGMAS[cfg["sigma_preset"]]
+        seed = (int(cfg["seed"]) + int(segment_index)) % (1 << 64)
+        distill_strength = float(cfg["distill_strength"]) if cfg["distill_lora_name"] else 0.0
+        use_face_source = bool(plan.get("face_detailer_settings", {}).get("enabled", False)) and plan.get("task_mode") != "longvid_keyframe_continuous"
+        return (enabled, prompt, float(cfg["scale"]), cfg["model_name"], cfg["precision"], cfg["device"], bool(cfg["temporal_chunking"]), cfg["lora_name"], float(cfg["strength"]), cfg["distill_lora_name"], distill_strength, sigmas, seed, use_face_source)
+
+
+NODE_CLASS_MAPPINGS = {"IAMCCS_MiniMaxH3OpenRefineControl": IAMCCS_MiniMaxH3OpenRefineControl}
+NODE_DISPLAY_NAME_MAPPINGS = {"IAMCCS_MiniMaxH3OpenRefineControl": "MiniMax H3 · Open-H3 Refinement Settings"}
diff --git a/iamccs_minimax_h3_seed_scout_variant.py b/iamccs_minimax_h3_seed_scout_variant.py
index cdc5ecf..b9c021a 100644
--- a/iamccs_minimax_h3_seed_scout_variant.py
+++ b/iamccs_minimax_h3_seed_scout_variant.py
@@ -20,6 +20,7 @@ from typing import Any
 
 import folder_paths
 import torch
+from comfy_execution.graph import ExecutionBlocker
 
 from .iamccs_minimax_h3_atomic_backend import (
     H3_FPS,
@@ -78,14 +79,14 @@ def _apply_sparse(model, enabled: bool, budget: float, denser_edges: bool):
         ) from exc
 
 
-def _active_sampling_model(model, plan: dict[str, Any]):
+def _active_sampling_model(model, plan: dict[str, Any], chunk_index=0):
     from comfy_extras.nodes_minimax_h3 import MiniMaxH3SigmaShift
 
     sampling = plan.get("sampling") if isinstance(plan.get("sampling"), dict) else {}
     shift_video = float(sampling.get("shift_video", 12.0))
     shift_audio = float(sampling.get("shift_audio", 3.0))
     turbo_model, turbo_report = _apply_turbo_lora(model, plan)
-    lora_model, secondary_report = _apply_secondary_lora(turbo_model, plan)
+    lora_model, secondary_report = _apply_secondary_lora(turbo_model, plan, chunk_index=chunk_index)
     turbo = _turbo_settings(plan)
     turbo_name = str(turbo.get("lora_name", "") or "").strip()
     compatible, _ = _h3_lora_compatibility(turbo_name)
@@ -123,11 +124,11 @@ class IAMCCS_MiniMaxH3SeedCandidateR40:
     def INPUT_TYPES(cls):
         return {
             "required": {
-                "model": ("MODEL",),
-                "positive": ("CONDITIONING",),
-                "latent": ("LATENT",),
+                "model": ("MODEL", {"lazy": True}),
+                "positive": ("CONDITIONING", {"lazy": True}),
+                "latent": ("LATENT", {"lazy": True}),
                 "cine_linx": (SUPERNODE_LINX_TYPE,),
-                "chunk_index": ("INT", {"forceInput": True}),
+                "chunk_index": ("INT", {"forceInput": True, "lazy": True}),
                 "candidate_index": ("INT", {"default": 0, "min": 0, "max": 3, "step": 1}),
             }
         }
@@ -137,7 +138,22 @@ class IAMCCS_MiniMaxH3SeedCandidateR40:
     FUNCTION = "sample"
     CATEGORY = CATEGORY
 
-    def sample(self, model, positive, latent, cine_linx, chunk_index, candidate_index):
+    @staticmethod
+    def _active(cine_linx, candidate_index):
+        prefix, _ = IAMCCS_MiniMaxH3ScoutDeliveryLazyRouterR43._selection(cine_linx)
+        settings = _scout_settings(_resolve_shotplan(cine_linx))
+        count = max(1, min(4, int(settings.get("candidate_count", 1) or 1)))
+        return prefix == "scout" and 0 <= int(candidate_index) < count
+
+    def check_lazy_status(self, cine_linx, candidate_index, **kwargs):
+        if not self._active(cine_linx, candidate_index):
+            return []
+        return [name for name in ("model", "positive", "latent", "chunk_index") if kwargs.get(name) is None]
+
+    def sample(self, model=None, positive=None, latent=None, cine_linx=None, chunk_index=0, candidate_index=0):
+        if not self._active(cine_linx, candidate_index):
+            blocker = ExecutionBlocker(None)
+            return blocker, blocker, 0, False, f"R40 candidate {int(candidate_index) + 1} bypassed"
         from comfy_extras.nodes_custom_sampler import (
             BasicGuider,
             BasicScheduler,
@@ -148,26 +164,17 @@ class IAMCCS_MiniMaxH3SeedCandidateR40:
 
         plan = _resolve_shotplan(cine_linx)
         scout = _scout_settings(plan)
-        enabled = bool(scout.get("enabled", False))
-        count = max(1, min(4, int(scout.get("candidate_count", 1) or 1))) if enabled else 1
+        count = max(1, min(4, int(scout.get("candidate_count", 1) or 1)))
         index = max(0, min(3, int(candidate_index)))
         sampling = plan.get("sampling") if isinstance(plan.get("sampling"), dict) else {}
         base_seed = int(sampling.get("seed", 0) or 0)
         chunk_stride = int(sampling.get("seed_stride", 1) or 1)
         scout_stride = max(1, int(scout.get("seed_stride", 1_000_003) or 1_000_003))
         actual_seed = (base_seed + int(chunk_index) * chunk_stride + index * scout_stride) & 0xFFFFFFFFFFFFFFFF
-        if index >= count:
-            inactive_sampled = copy.copy(latent)
-            inactive_x0 = copy.copy(latent)
-            inactive_sampled["iamccs_r40_candidate_active"] = False
-            inactive_x0["iamccs_r40_candidate_active"] = False
-            report = f"R40 candidate {index + 1} inactive | configured candidates={count}"
-            return inactive_sampled, inactive_x0, actual_seed, False, report
-
         _audit_lipsync_audio_lock(plan, latent, int(chunk_index))
         cleanup_report = _release_conditioning_models(plan)
         active_model, turbo_enabled, turbo_report, secondary_report, acceleration_report, sparse_report = (
-            _active_sampling_model(model, plan)
+            _active_sampling_model(model, plan, chunk_index=chunk_index)
         )
         noise = RandomNoise.execute(noise_seed=actual_seed)[0]
         guider = BasicGuider.execute(model=active_model, conditioning=positive)[0]
@@ -319,8 +326,8 @@ class IAMCCS_MiniMaxH3SeedPreviewR40:
         return {
             "required": {
                 "latent": ("LATENT",),
-                "video_vae": ("VAE",),
-                "trim_frames": ("INT", {"forceInput": True}),
+                "video_vae": ("VAE", {"lazy": True}),
+                "trim_frames": ("INT", {"forceInput": True, "lazy": True}),
                 "max_preview_frames": ("INT", {"default": 49, "min": 1, "max": 209, "step": 1}),
                 "max_preview_width": ("INT", {"default": 512, "min": 128, "max": 1024, "step": 64}),
             }
@@ -331,9 +338,14 @@ class IAMCCS_MiniMaxH3SeedPreviewR40:
     FUNCTION = "decode"
     CATEGORY = CATEGORY
 
-    def decode(self, latent, video_vae, trim_frames, max_preview_frames, max_preview_width):
+    def check_lazy_status(self, latent, **kwargs):
         if not bool(latent.get("iamccs_r40_candidate_active", False)):
-            return torch.zeros((1, 144, 256, 3), dtype=torch.float32), "R40 candidate inactive"
+            return []
+        return [name for name in ("video_vae", "trim_frames") if kwargs.get(name) is None]
+
+    def decode(self, latent, video_vae=None, trim_frames=0, max_preview_frames=49, max_preview_width=512):
+        if not bool(latent.get("iamccs_r40_candidate_active", False)):
+            return ExecutionBlocker(None), "R40 candidate inactive"
         import nodes as comfy_nodes
 
         frames = comfy_nodes.VAEDecode().decode(vae=video_vae, samples=latent)[0]
@@ -563,7 +575,7 @@ class IAMCCS_MiniMaxH3LatentUpresSamplingR40:
         sampling = plan.get("sampling") if isinstance(plan.get("sampling"), dict) else {}
         seed = (int(shot_lab.get("stage2_seed", 0)) + int(segment_index) * int(shot_lab.get("stage2_seed_stride", 1))) & 0xFFFFFFFFFFFFFFFF
         base, turbo_report = _apply_turbo_lora(model, plan)
-        base, lora2_report = _apply_secondary_lora(base, plan)
+        base, lora2_report = _apply_secondary_lora(base, plan, chunk_index=segment_index)
         base, stage2_lora_report = _stage2_lora(base, shot_lab)
         shifted = MiniMaxH3SigmaShift.execute(
             model=base,
diff --git a/iamccs_minimax_h3_shotboard.py b/iamccs_minimax_h3_shotboard.py
index da8d15f..3d9aa12 100644
--- a/iamccs_minimax_h3_shotboard.py
+++ b/iamccs_minimax_h3_shotboard.py
@@ -29,6 +29,8 @@ from .iamccs_h3_face_swap import settings_schema as face_swap_schema, face_swap_
 from .iamccs_h3_character_swap_lora import settings_schema as character_swap_schema, swap_plan
 from .iamccs_h3_vfx_edit import settings_schema as vfx_edit_schema
 from .iamccs_h3_omni import configure as configure_omni
+from .iamccs_h3_continuity_guard import settings_schema as continuity_guard_schema, configuration as continuity_guard_configuration
+from .iamccs_minimax_h3_open_refine import settings_schema as open_h3_refine_schema, configuration as open_h3_refine_configuration
 
 from .iamccs_minimax_h3_shotboard_core import (
     H3_FPS,
@@ -3485,6 +3487,7 @@ class IAMCCS_MiniMaxH3ShotPlanner:
         extended_av_boundary_polish_strength = EXTEND_BOUNDARY_POLISH_DEFAULT_STRENGTH
         # Append-only Settings/PRO controls. They are intentionally NOT planner widgets,
         # so historical Shotboard widget positions remain byte-for-byte compatible.
+        secondary_lora_continuation_only = False
         upscale_link_to_native = False
         upscale_link_factor = "640x384 -> 1280x768"
         import hashlib
@@ -3647,6 +3650,7 @@ class IAMCCS_MiniMaxH3ShotPlanner:
             secondary_lora_enabled = saved_settings.get("secondary_lora_enabled", secondary_lora_enabled)
             secondary_lora_name = saved_settings.get("secondary_lora_name", secondary_lora_name)
             secondary_lora_strength = saved_settings.get("secondary_lora_strength", secondary_lora_strength)
+            secondary_lora_continuation_only = bool(saved_settings.get("secondary_lora_continuation_only", False))
             pdd_lora_name = saved_settings.get("pdd_lora_name", pdd_lora_name)
             pdd_strength = saved_settings.get("pdd_strength", pdd_strength)
             h3_controlnet_enabled = saved_settings.get("h3_controlnet_enabled", h3_controlnet_enabled)
@@ -4545,6 +4549,7 @@ class IAMCCS_MiniMaxH3ShotPlanner:
             "duplicate_of_turbo": bool(secondary_lora_duplicate),
             "lora_name": selected_secondary_lora,
             "strength": float(secondary_strength),
+            "continuation_only": bool(secondary_lora_continuation_only),
             "loader": "ComfyUI LoraLoaderModelOnly",
             "source": "shotboard",
         }
@@ -4765,6 +4770,7 @@ class IAMCCS_MiniMaxH3ShotPlanner:
             "soft_video_curve": str(saved_settings.get("h3_continuation_soft_video_curve", "smoothstep") or "smoothstep"),
             "soft_audio_ms": max(0.0, min(100.0, _finite_float(saved_settings.get("h3_continuation_soft_audio_ms", 15.0), 15.0, 0.0, 100.0))),
         }
+        plan["continuity_guard"] = continuity_guard_configuration(saved_settings)
         plan["refmod_settings"] = {
             "schema": "iamccs.minimax_h3.refmod.v1",
             "enabled": bool(saved_settings.get("h3_refmod_enabled", False)),
@@ -4802,6 +4808,7 @@ class IAMCCS_MiniMaxH3ShotPlanner:
             "route": "face_detailer_then_optional_upscale" if bool(face_detailer_enabled) else "native_then_optional_upscale",
             "source": "IAMCCS_ShotboardH3Settings" if _h3_settings_from_cine_linx(cine_linx) else "shotboard_defaults",
         }
+        plan["open_h3_refine"] = open_h3_refine_configuration(saved_settings)
         configure_omni(plan, saved_settings)
         chunk_frames = [int(chunk.get("frame_count", 0) or 0) for chunk in plan.get("chunks", [])]
         max_chunk_frames = max(chunk_frames, default=0)
@@ -5571,6 +5578,10 @@ class IAMCCS_MiniMaxH3NativeCheckpointSave:
             )
 
         trim_count = max(0, int(trim_head_frames or 0))
+        guard_report = sampled_latent.get("_iamccs_continuity_guard") if isinstance(sampled_latent, dict) else None
+        if isinstance(guard_report, dict):
+            from .iamccs_h3_continuity_guard import bind_checkpoint
+            bind_checkpoint(folder_paths.get_output_directory(), guard_report, active_render_id)
         join_contract = _checkpoint_join_contract(cine_linx, current_segment, trim_count)
         motion_context_pretrimmed = bool(join_contract["context_pretrimmed"])
         overlap_stitch = join_contract["mode"] == "decoded_overlap"
@@ -7630,6 +7641,12 @@ class IAMCCS_ShotboardH3Settings:
             "h3_omni_enabled": ("BOOLEAN", {"default": False,
                 "display_name": "REF2VA · FASTH3 OMNI 8 STEP",
                 "tooltip": "Full reference-conditioned checkpoint, not a LoRA. Select the Omni loader. Native PDD32, Euler/simple, 8 steps, shifts 12/3. Other modes keep their own model route."}),
+            **continuity_guard_schema(),
+            "secondary_lora_continuation_only": ("BOOLEAN", {
+                "default": False, "display_name": "Second LoRA: from segment 2",
+                "tooltip": "Apply the second LoRA only from segment 2 onward. A saved-AV checkpoint resume already counts as continuation. OFF preserves all-segment behavior. This controls temporal segments, not upscale passes.",
+            }),
+            **open_h3_refine_schema(),
         })}
 
     RETURN_TYPES = (SUPERNODE_LINX_TYPE,)
diff --git a/iamccs_prompter.py b/iamccs_prompter.py
index c805afc..b451af4 100644
--- a/iamccs_prompter.py
+++ b/iamccs_prompter.py
@@ -893,12 +893,42 @@ def _normalise_ai_images(value: Any) -> list[dict[str, str]]:
     return images
 
 
+def _authored_h3_dialogue_lines(text: str) -> list[str]:
+    """Protect exact utterances for referenced characters and standalone voices."""
+    return list(dict.fromkeys(re.findall(
+        r"(?:<Subject\s+\d+>\s*)?\(S\d+(?:\s*,\s*S\d+)*\)[^<>\r\n]{0,160}<d>\[[^\]]+\][\s\S]*?</d>(?:\s*<(?:scenetrans|cutoff)>)*",
+        str(text or ""), flags=re.IGNORECASE,
+    )))
+
+
+def _official_h3_tag_rules(task_mode: str) -> str:
+    """Shared by Global, selected-field rewrite, and compact local fallback."""
+    if task_mode in {"v2va_face_swap_lora", "ref2va_vfx_edit"}:
+        return "Use this mode's native aligned-edit grammar; do not append full-reference labels to its specialized edit prompt."
+    return (
+        "Official H3 tag authoring contract applies even when the rough request has no tags. "
+        "Format every supplied spoken or sung line as (S1) says <d>[Language] exact words</d>, "
+        "assigning stable (S1), (S2) and later speaker IDs by first actual vocal event, independently of subject numbering. "
+        "Keep voice, delivery and acting descriptions outside <d>; preserve the exact words and original language inside it. "
+        "Never invent dialogue. Use <scenetrans> only for speech genuinely continuing across an authored cut, "
+        "and <cutoff> only for speech intentionally interrupted by the clip ending; they are not generic transition decoration. "
+        "For full-reference modes, define reusable people, objects or environments with stable <Subject N> labels. "
+        "Bind their provenance to actual <Picture N> or <Video N> assets and use <Subject N> (Sx) for a referenced speaker. "
+        "A Subject is content, a Picture is an image/frame, a Video is a source or temporal reference, and an Audio is an active audio reference or reuse source. "
+        "Do not equate Subject and speaker numbers. Reference labels are category-specific and must resolve to available inputs or explicit existing context. "
+        "Do not populate unused slots, invent four subjects, or create Audio labels merely because a video contains sound. "
+        "Base T2VA/I2VA/FL2VA/L2VA keep their three-section grammar and applicable image alignment; "
+        "full-reference modes keep their six sections. Global describes output scope, not a plain-prose exemption from these rules."
+    )
+
+
 def _assistant_instruction(
     task_mode: str,
     sections: dict[str, str],
     user_direction: str = "",
     target_keys: Any = None,
     images: Any = None,
+    request_text: str | None = None,
 ) -> tuple[str, str]:
     mode = _normalise_task_mode(task_mode or "t2va")
     if mode not in MODE_SECTIONS:
@@ -962,6 +992,27 @@ def _assistant_instruction(
         "When images are attached, analyze only the contribution named by each image role. An opening image governs the first frame; a closing image governs the last frame; identity, composition and style images govern only those named attributes. "
         "Never mention unavailable media or claim to have seen a detail that is not visible."
     )
+    if request_text is not None:
+        system = (
+            "You compile a filmmaker's brief into MiniMax H3 prompt fields. Return one JSON object with plain-string values, "
+            f"using exactly these selected keys: {selected}. "
+            "Write all generated descriptions in English, even when the brief is in another language. "
+            "Preserve supplied dialogue verbatim in its original language and retain exact reference tags and authored times. "
+            "Develop the brief into concrete, filmable staging: chronological visible movement, physical interactions, performance, "
+            "camera and location sound belong in their respective fields. Add only the minimal physical detail needed to stage the requested action. "
+            "Do not merely copy or translate the brief into one field or repeat it across multiple fields. "
+            "Do not invent characters, dialogue, extra actions, cuts, wardrobe, locations or a different story. "
+            "A scene field establishes the setting and subjects; shot_list describes the visible action in order; acting describes body mechanics; "
+            "camera describes the requested framing and movement; lighting describes the stated visual treatment; sound fields describe audible events. "
+            "For a single continuous action use one concise action passage, without an extra [Shot 1] heading. "
+            "Never emit timing placeholders such as MM:SS, HH:MM or 'end time', and never invent a timestamp. "
+            "Leave dialogue empty when none was supplied. Do not add music unless requested. "
+            "The user brief is the content authority. Existing context supplies only the unselected fields; previous drafts of selected fields are not instructions. "
+            f"Mode rule: {mode_rules} "
+            "Images provide visual evidence only for their assigned roles; do not claim unavailable references. "
+            "Return field contents only, without headings, markdown, commentary or reasoning."
+        )
+    system += "\n" + _official_h3_tag_rules(mode)
     if len(system) > 24000:
         raise RuntimeError("MiniMax assistant system prompt exceeds the 7000-token safety envelope")
     user = json.dumps({
@@ -974,6 +1025,15 @@ def _assistant_instruction(
             for item in visuals
         ],
     }, ensure_ascii=False, indent=2)
+    if request_text is not None:
+        user = json.dumps({
+            "task_mode": mode,
+            "selected_sections": selected,
+            "request": str(request_text).strip(),
+            "direction": str(user_direction or "").strip(),
+            "existing_context": {key: value for key, value in filled.items() if key not in selected},
+            "visual_context": [{"slot": item["slot"], "role": item["role"], "name": item["name"]} for item in visuals],
+        }, ensure_ascii=False)
     return system, user
 
 
@@ -1263,7 +1323,7 @@ def _compact_assistant_instruction(task_mode: str, sections: dict[str, str], use
         "Return one JSON object only, without markdown. Every value must be one plain string. "
         f"Use only these keys: {selected}. Omit a key when the user supplied no relevant content. "
         "Preserve requested identity, action, camera direction, timestamps, language and quoted dialogue. "
-        f"{special}"
+        f"{special} " + _official_h3_tag_rules(mode)
     )
     user = json.dumps({
         "task_mode": mode,
@@ -1316,6 +1376,7 @@ def rewrite_sections_with_ai(
     target_keys: Any = None,
     images: Any = None,
     vision_model: str = "",
+    request_text: str | None = None,
 ) -> tuple[dict[str, str], dict[str, Any]]:
     provider = str(provider or "ollama").strip().lower()
     if provider == "lm_studio":
@@ -1343,7 +1404,7 @@ def rewrite_sections_with_ai(
                 visual_inputs[0].update(data=base64.b64encode(buffer.getvalue()).decode("ascii"), mime_type="image/jpeg")
         except (OSError, ValueError):
             pass
-    system, user = _assistant_instruction(task_mode, sections, user_direction, target_keys, visual_inputs)
+    system, user = _assistant_instruction(task_mode, sections, user_direction, target_keys, visual_inputs, request_text)
     vision_observations = {}
     selected_vision_model = str(vision_model or "").strip()
     if _normalise_task_mode(task_mode) == "v2va_face_swap_lora" and visual_inputs and not selected_vision_model:
@@ -1537,6 +1598,10 @@ def rewrite_sections_with_ai(
     filtered = {key: value for key, value in rewritten.items() if key in requested and value}
     if not filtered:
         raise RuntimeError("The AI did not return any valid filled MiniMax section")
+    if request_text and len(requested) > 1:
+        brief = re.sub(r"\W+", " ", request_text).strip().casefold()
+        if all(re.sub(r"\W+", " ", value).strip().casefold() == brief for value in filtered.values()):
+            raise RuntimeError("The AI echoed REQUEST instead of writing H3 fields. Your existing prompt was kept; retry with another writer model.")
     mode_name = _normalise_task_mode(task_mode)
     if mode_name == "v2va_face_swap_lora":
         text = str(filtered.get("swap_prompt") or "").strip()
@@ -1589,16 +1654,17 @@ def rewrite_sections_with_ai(
             filtered["shot_list"] = canonical_timeline
     # An AI rewrite may paraphrase a Whisper transcript even when told not to.
     # Restore the exact H3 dialogue line supplied by the user after parsing.
-    authored = "\n".join([str(user_direction or ""), *(str(value or "") for value in sections.values())])
-    dialogue_lines = list(dict.fromkeys(re.findall(
-        r"<Subject\s+\d+>\s*\(S\d+\):\s*<d>\[[^\]]+\][\s\S]*?</d>",
-        authored,
-        flags=re.IGNORECASE,
-    )))
+    authored = "\n".join([str(request_text or ""), str(user_direction or ""), *(str(value or "") for value in sections.values())])
+    dialogue_lines = _authored_h3_dialogue_lines(authored)
+    if mode_name == "fl2va" and requested.isdisjoint({"action", "shot_list", "dialogue"}):
+        # Global keyframe fields remain stable authority; utterances belong to locals.
+        dialogue_lines = []
     if dialogue_lines:
         target = "audio_dialogue_map" if "audio_dialogue_map" in requested else next(
             (key for key in target_keys if key in requested), next(iter(requested))
         ) if isinstance(target_keys, list) else next(iter(requested))
+        if target in {"dialogue", "audio_dialogue_map", "multishot_dialogue_map"}:
+            filtered[target] = "\n".join(dialogue_lines)
         for line in dialogue_lines:
             if line not in "\n".join(filtered.values()):
                 filtered[target] = "\n".join(part for part in (filtered.get(target, ""), line) if part)
@@ -1720,7 +1786,7 @@ def build_visual_story_plan_with_ai(provider: str, base_url: str, model: str, ap
         raise ValueError("Describe the relationship between the images")
     visual_map = "\n".join(f"Picture {item['slot']}: {item['name']} · role={item['role']}" for item in visuals)
     payload = _multimodal_json_chat(provider, base_url, model, api_key,
-        VISUAL_STORY_SYSTEM_PROMPT + ("" if visuals else
+        VISUAL_STORY_SYSTEM_PROMPT + "\n" + _official_h3_tag_rules(_normalise_task_mode(task_mode)) + ("" if visuals else
             "\nNo images supplied. Do not invent Picture references. Create one local shot per explicitly numbered prompt in the brief. Preserve those slot numbers and their individual instructions; do not collapse them into the global prompt. If no slots are numbered, choose a short consecutive shot sequence. Global defines shared identity, location and atmosphere; local prompts carry the chronological development."),
         f"CURRENT IAMCCS MODE: {task_mode}\nVISUAL MAP:\n{visual_map}\n\nRELATIONSHIP / STORY INTENT:\n{relation}",
         visuals, temperature, timeout,
@@ -1766,11 +1832,10 @@ def build_visual_story_plan_with_ai(provider: str, base_url: str, model: str, ap
         ) if part)
     # REQUEST → GLOBAL + LOCALS has a separate AI endpoint. Keep verbatim
     # Whisper dialogue here too, even when the model paraphrases its output.
-    for line in dict.fromkeys(re.findall(
-        r"<Subject\s+\d+>\s*\(S\d+\):\s*<d>\[[^\]]+\][\s\S]*?</d>",
-        relation, flags=re.IGNORECASE,
-    )):
+    for line in _authored_h3_dialogue_lines(relation):
         if line not in global_prompt and not any(line in shot["local_prompt"] for shot in shots):
+            if _normalise_task_mode(task_mode) == "fl2va":
+                raise RuntimeError("The H3 plan lost an authored dialogue line from its locals. The brief was preserved; retry the local plan.")
             global_prompt = "\n\n".join(part for part in (global_prompt, line) if part)
     return {"global_prompt": global_prompt,
             "global_direction": global_direction,
@@ -2754,6 +2819,7 @@ def _register_prompter_routes() -> None:
                     payload.get("target_keys"),
                     payload.get("images"),
                     str(payload.get("vision_model", "")),
+                    payload.get("request_text"),
                 )
                 return web.json_response({"ok": True, "sections": rewritten, "report": report})
             except Exception as exc:
diff --git a/tests/test_h3_continuity_guard.py b/tests/test_h3_continuity_guard.py
new file mode 100644
index 0000000..38d317c
--- /dev/null
+++ b/tests/test_h3_continuity_guard.py
@@ -0,0 +1,104 @@
+"""Retired Repair compatibility and read-only diagnostics; no inference."""
+import importlib.util
+from pathlib import Path
+import sys
+
+import torch
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT.parents[1]))
+spec = importlib.util.spec_from_file_location("guard_test_module", ROOT / "iamccs_h3_continuity_guard.py")
+guard = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(guard)
+
+
+def test_legacy_repair_disables_all_interventions(tmp_path):
+    config = guard.configuration({"h3_guard_mode": "repair", "h3_guard_reference_memory": True})
+    assert config['mode'] == 'off'
+    samples, frames = object(), object()
+    result = guard.process({'mode': 'repair'}, samples, frames, directory=tmp_path,
+                           index=1, head_frames=0, visible_frames=1)
+    assert result[0] is samples and result[1] is frames
+    assert result[2]['status'] == 'off'
+    assert list(tmp_path.iterdir()) == []
+
+
+def test_monitor_preserves_video_audio_mask_and_frames(tmp_path):
+    from unittest.mock import patch
+    samples = {'samples': object(), 'noise_mask': object(), 'metadata': {'seed': 42}}
+    frames = torch.rand(8, 12, 12, 3)
+    before = frames.clone()
+    config = guard.configuration({'h3_guard_mode': 'monitor'})
+    with patch.object(guard, 'measure', return_value={'detail': .1, 'luminance': .5, 'motion': .1}):
+        for index in (0, 1):
+            result, returned, report = guard.process(config, samples, frames,
+                directory=tmp_path, index=index, head_frames=2, visible_frames=6)
+            for key, value in samples.items():
+                assert result[key] is value
+            assert returned is frames and torch.equal(frames, before)
+            assert report['repair_attempts'] == 0
+
+
+def test_darkening_or_motion_change_requires_review_not_automatic_repair():
+    config = guard.configuration({})
+    baseline = {'detail': .1, 'luminance': .5, 'motion': .1}
+    assert guard.assess({'detail': .04, 'luminance': .5, 'motion': .1}, baseline, config)['texture_loss_detected']
+    for changed in ({'detail': .04, 'luminance': .2, 'motion': .1}, {'detail': .04, 'luminance': .5, 'motion': .005}):
+        verdict = guard.assess(changed, baseline, config)
+        assert verdict['review_recommended'] and not verdict['texture_loss_detected']
+
+
+def test_metrics_detect_synthetic_blur():
+    import torch.nn.functional as F
+    torch.manual_seed(5)
+    texture = torch.rand(1, 3, 144, 256)
+    movie = torch.cat([torch.roll(texture, i, -1) for i in range(8)]).movedim(1, -1)
+    blurred = F.avg_pool2d(movie.movedim(-1, 1), 7, stride=1, padding=3).movedim(1, -1)
+    a, b = guard.measure(movie), guard.measure(blurred)
+    assert b['detail'] < a['detail'] * .65
+
+
+def test_storage_does_not_use_render_id_as_path(tmp_path):
+    path = guard.storage(tmp_path, '../../outside')
+    assert path.is_relative_to(tmp_path)
+
+
+def test_invalid_configuration_is_rejected():
+    import unittest
+    with unittest.TestCase().assertRaises(ValueError):
+        guard.configuration({'h3_guard_detail_ratio': float('nan')})
+
+
+def test_blank_root_identity_binds_to_numbered_checkpoint_and_continuation(tmp_path):
+    import json
+    provisional = guard.conditioning_identity('', 0)
+    source = guard.storage(tmp_path, provisional)
+    baseline = {'detail': .1, 'motion': .1, 'luminance': .5}
+    guard.write_report(source / 'baseline.json', baseline)
+    report = {'storage_key': source.name, 'segment_index': 0}
+    guard.write_report(source / 'segment_0000.json', report)
+    guard.bind_checkpoint(tmp_path, report, 'soldier_0042')
+    continuation_id = guard.conditioning_identity('soldier_0042', 1)
+    destination = guard.storage(tmp_path, continuation_id)
+    assert json.loads((destination / 'baseline.json').read_text()) == baseline
+    guard.bind_checkpoint(tmp_path, {'storage_key': destination.name, 'segment_index': 1}, continuation_id)
+    assert (source / 'baseline.json').is_file()
+    assert guard.conditioning_identity('', 0) != provisional
+
+
+def test_missing_continuation_identity_and_invalid_binding_key_fail_closed(tmp_path):
+    import unittest
+    with unittest.TestCase().assertRaises(ValueError):
+        guard.conditioning_identity('', 1)
+    with unittest.TestCase().assertRaises(ValueError):
+        guard.bind_checkpoint(tmp_path, {'storage_key': '../../outside', 'segment_index': 0}, 'safe')
+
+
+if __name__ == '__main__':
+    import tempfile
+    import inspect
+    tests = [(name, value) for name, value in globals().copy().items() if name.startswith('test_')]
+    for name, test in tests:
+        with tempfile.TemporaryDirectory() as directory:
+            test(Path(directory)) if inspect.signature(test).parameters else test()
+        print('PASS', name)
diff --git a/tests/test_h3_prompter_request.cjs b/tests/test_h3_prompter_request.cjs
new file mode 100644
index 0000000..becdc80
--- /dev/null
+++ b/tests/test_h3_prompter_request.cjs
@@ -0,0 +1,57 @@
+const assert = require('node:assert/strict');
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+const source = fs.readFileSync(process.argv[2] || path.join(__dirname, '..', 'web', 'iamccs_prompter_ui.js'), 'utf8');
+const start = source.indexOf('    const performAIRewrite = async');
+const end = source.indexOf('    const renderLocalPrompts = () => {', start);
+assert(start > 0 && end > start);
+
+function fixture() {
+    const state = {request: 'Una donna posa una tazza.', task_mode: 't2va', sections: {scene: 'Old scene', camera: 'Old camera', acting: 'Tired hands'}};
+    const context = {
+        project: state, node: {}, MODE_META: {t2va: {sections: [['scene'], ['camera'], ['acting']]}},
+        activePromptKey: null, activePromptArea: null, rewriteBtn: {}, aiScope: {value: 'active_field'},
+        aiDirection: {value: ''}, aiStatus: {}, aiProvider: {value: 'qwen_native'}, aiBaseUrl: {value: ''},
+        aiModel: {value: '__workflow__'}, aiApiKey: {value: ''}, aiVisionModel: {value: ''},
+        aiTemperature: {value: '0.35'}, aiVisualFiles: [], isEditMode: () => false,
+        swapcharSignature: () => '', persistAI() {}, commit() {}, beginAiBusy: () => () => {},
+        buildAIImagePayload: async () => [], nativeClipConfig: () => ({profile: '4b_v3.1'}),
+        snapshotProject() {}, renderControls() {}, renderSections() {}, renderPreview() {},
+        workspace: {showReview() {context.reviewCount = (context.reviewCount || 0) + 1;}},
+        fetchAI: async (_url, options) => {
+            context.sent = JSON.parse(options.body);
+            return {ok: true, json: async () => ({ok: true, sections: {scene: 'A woman lowers a cup onto the table.', camera: 'Fixed eye-level framing.'}})};
+        },
+    };
+    vm.createContext(context);
+    vm.runInContext(source.slice(start, end) + '\nglobalThis.rewrite = performAIRewrite;', context);
+    return context;
+}
+
+(async () => {
+    const request = fixture();
+    assert.equal(await request.rewrite({narrativeRequest: request.project.request, directTargetKeys: ['scene', 'camera']}), true);
+    assert.equal(request.sent.request_text, 'Una donna posa una tazza.');
+    assert.deepEqual(request.sent.sections, {scene: '', camera: '', acting: 'Tired hands'});
+    assert.equal(request.project.sections.scene, 'A woman lowers a cup onto the table.');
+    assert.equal(request.project.sections.acting, 'Tired hands');
+    assert.equal(request.project.request, 'Una donna posa una tazza.');
+    assert.equal(request.reviewCount, 1, 'REQUEST must reveal the compiled H3 prompt');
+
+    const field = fixture();
+    assert.equal(await field.rewrite({directTargetKeys: ['scene', 'camera']}), true);
+    assert.equal(field.sent.request_text, null);
+    assert.equal(field.sent.sections.scene, 'Old scene');
+    assert.equal(field.reviewCount, undefined, 'a field rewrite keeps the current view');
+
+    const edited = fixture();
+    edited.fetchAI = async () => {
+        edited.project.sections.scene = 'User edit while waiting';
+        return {ok: true, json: async () => ({ok: true, sections: {scene: 'Late AI result'}})};
+    };
+    await edited.rewrite({narrativeRequest: edited.project.request, directTargetKeys: ['scene', 'camera']});
+    assert.equal(edited.project.sections.scene, 'User edit while waiting');
+    assert.match(edited.aiStatus.textContent, /Your edits were kept/);
+    console.log('PASS: REQUEST compiles from its brief, field rewrite retains context, late AI cannot overwrite edits');
+})().catch(error => {console.error(error); process.exitCode = 1;});
diff --git a/tests/test_h3_scout_delivery_router.py b/tests/test_h3_scout_delivery_router.py
index 62cfca9..b92680d 100644
--- a/tests/test_h3_scout_delivery_router.py
+++ b/tests/test_h3_scout_delivery_router.py
@@ -37,5 +37,49 @@ class ScoutDeliveryRouterTests(unittest.TestCase):
         self.assertEqual((prefix, reason), ("original", "Scout disabled"))
 
 
+class ScoutBypassTests(unittest.TestCase):
+    def plan(self, enabled=False, count=4, mode="t2va"):
+        return {"task_mode":mode,"seed_scout_settings":{"enabled":enabled,"candidate_count":count}}
+
+    def test_disabled_preview_does_not_request_any_candidate_dependencies(self):
+        candidate=MODULE.IAMCCS_MiniMaxH3SeedCandidateR40()
+        with patch.object(MODULE,"_resolve_shotplan",return_value=self.plan()), patch.object(MODULE,"_release_conditioning_models",side_effect=AssertionError("Unexpected model cleanup")), patch.object(MODULE,"_active_sampling_model",side_effect=AssertionError("Unexpected sampling")):
+            for index in range(4):
+                self.assertEqual(candidate.check_lazy_status({},index),[])
+                result=candidate.sample(cine_linx={},candidate_index=index)
+                self.assertIsInstance(result[0],MODULE.ExecutionBlocker)
+                self.assertIsInstance(result[1],MODULE.ExecutionBlocker)
+                self.assertFalse(result[3])
+
+    def test_enabled_candidate_requests_its_heavy_inputs(self):
+        candidate=MODULE.IAMCCS_MiniMaxH3SeedCandidateR40()
+        with patch.object(MODULE,"_resolve_shotplan",return_value=self.plan(True,2)):
+            self.assertEqual(candidate.check_lazy_status({},0),["model","positive","latent","chunk_index"])
+            self.assertEqual(candidate.check_lazy_status({},1,model=object(),chunk_index=0),["positive","latent"])
+            self.assertEqual(candidate.check_lazy_status({},2),[])
+            self.assertIsInstance(candidate.sample(cine_linx={},candidate_index=3)[0],MODULE.ExecutionBlocker)
+
+    def test_temporal_route_bypasses_even_when_scout_requested(self):
+        candidate=MODULE.IAMCCS_MiniMaxH3SeedCandidateR40()
+        with patch.object(MODULE,"_resolve_shotplan",return_value=self.plan(True,4,"latent_go_ahead")):
+            self.assertEqual(candidate.check_lazy_status({},0),[])
+            self.assertFalse(candidate.sample(cine_linx={})[3])
+
+    def test_inactive_preview_never_requests_vae_or_allocates_an_image(self):
+        preview=MODULE.IAMCCS_MiniMaxH3SeedPreviewR40()
+        latent={"iamccs_r40_candidate_active":False}
+        self.assertEqual(preview.check_lazy_status(latent),[])
+        self.assertIsInstance(preview.decode(latent)[0],MODULE.ExecutionBlocker)
+        self.assertEqual(preview.check_lazy_status({"iamccs_r40_candidate_active":True}),["video_vae","trim_frames"])
+
+    def test_existing_socket_names_are_preserved_and_heavy_inputs_are_lazy(self):
+        candidate=MODULE.IAMCCS_MiniMaxH3SeedCandidateR40.INPUT_TYPES()["required"]
+        for name in ("model","positive","latent","chunk_index"):
+            self.assertTrue(candidate[name][1]["lazy"])
+        preview=MODULE.IAMCCS_MiniMaxH3SeedPreviewR40.INPUT_TYPES()["required"]
+        self.assertTrue(preview["video_vae"][1]["lazy"])
+        self.assertTrue(preview["trim_frames"][1]["lazy"])
+
+
 if __name__ == "__main__":
     unittest.main()
diff --git a/tests/test_h3_secondary_lora_scope.py b/tests/test_h3_secondary_lora_scope.py
new file mode 100644
index 0000000..f35d5a6
--- /dev/null
+++ b/tests/test_h3_secondary_lora_scope.py
@@ -0,0 +1,89 @@
+"""Exercise the real adapter loader's segment gate without GPU inference."""
+import ast
+from pathlib import Path
+import sys
+from types import ModuleType, SimpleNamespace
+from typing import Any
+from unittest.mock import Mock
+
+import pytest
+
+ROOT = Path(__file__).resolve().parents[1]
+
+
+def backend(monkeypatch):
+    package = ModuleType("secondary_scope_test")
+    package.__path__ = []
+    swap = ModuleType(package.__name__ + ".iamccs_h3_character_swap_lora")
+    swap.apply_loras = lambda model, plan: model
+    monkeypatch.setitem(sys.modules, package.__name__, package)
+    monkeypatch.setitem(sys.modules, swap.__name__, swap)
+    loader = Mock(side_effect=lambda **kw: (object(),))
+    monkeypatch.setitem(sys.modules, "nodes", SimpleNamespace(
+        LoraLoaderModelOnly=lambda: SimpleNamespace(load_lora_model_only=loader)))
+    names = {"_external_continuation_active", "_secondary_lora_settings",
+             "_secondary_lora_applies_to_segment", "_apply_secondary_lora"}
+    tree = ast.parse((ROOT / "iamccs_minimax_h3_atomic_backend.py").read_text(encoding="utf-8"))
+    functions = [n for n in tree.body if isinstance(n, ast.FunctionDef) and n.name in names]
+    ns = {"__package__": package.__name__, "Any": Any,
+          "folder_paths": SimpleNamespace(get_full_path=lambda *args: "registered-adapter"),
+          "_h3_lora_compatibility": lambda name: (True, "compatible")}
+    exec(compile(ast.Module(body=functions, type_ignores=[]), "<secondary-scope>", "exec"), ns)
+    return ns["_apply_secondary_lora"], loader
+
+
+@pytest.mark.parametrize("segment", [0, 1, 3])
+def test_legacy_all_segments_stays_enabled(monkeypatch, segment):
+    apply, loader = backend(monkeypatch)
+    original = object()
+    plan = {"secondary_lora": {"enabled": True, "lora_name": "test.safetensors", "strength": .5}}
+    result, report = apply(original, plan, chunk_index=segment)
+    assert result is not original
+    assert loader.call_count == 1
+    assert "all-segments" in report
+
+
+def test_first_segment_skips_then_continuations_apply_without_mutating_plan(monkeypatch):
+    apply, loader = backend(monkeypatch)
+    original = object()
+    settings = {"enabled": True, "continuation_only": True, "lora_name": "test.safetensors", "strength": .5}
+    plan = {"secondary_lora": settings.copy()}
+    result, report = apply(original, plan, chunk_index=0)
+    assert result is original and loader.call_count == 0
+    assert "starts at segment 2" in report
+    for segment in (1, 2):
+        result, report = apply(original, plan, chunk_index=segment)
+        assert result is not original
+        assert "continuation-only" in report
+    assert loader.call_count == 2
+    assert plan["secondary_lora"] == settings
+    # Returning to the first segment must not inherit the patched model.
+    assert apply(original, plan, chunk_index=0)[0] is original
+    assert loader.call_count == 2
+
+
+@pytest.mark.parametrize("checkpoint,enabled,expected", [("native.pt", True, 1), ("", True, 0), ("native.pt", False, 0)])
+def test_checkpoint_resume_counts_as_continuation(monkeypatch, checkpoint, enabled, expected):
+    apply, loader = backend(monkeypatch)
+    plan = {"secondary_lora": {"enabled": True, "continuation_only": True,
+                               "lora_name": "test.safetensors", "strength": .5},
+            "continuation_settings": {"enabled": enabled, "checkpoint": checkpoint}}
+    apply(object(), plan, chunk_index=0)
+    assert loader.call_count == expected
+
+
+def test_disabled_slot_never_loads_on_continuation(monkeypatch):
+    apply, loader = backend(monkeypatch)
+    apply(object(), {"secondary_lora": {"enabled": False, "continuation_only": True}}, chunk_index=2)
+    assert loader.call_count == 0
+
+
+def test_settings_schema_is_append_only():
+    tree = ast.parse((ROOT / "iamccs_minimax_h3_shotboard.py").read_text(encoding="utf-8"))
+    settings = next(n for n in tree.body if isinstance(n, ast.ClassDef) and n.name == "IAMCCS_ShotboardH3Settings")
+    method = next(n for n in settings.body if isinstance(n, ast.FunctionDef) and n.name == "INPUT_TYPES")
+    keys = [n.value for n in ast.walk(method) if isinstance(n, ast.Constant) and n.value == "secondary_lora_continuation_only"]
+    assert len(keys) == 1
+    # New widget remains after the final historical extension.
+    source = ast.get_source_segment((ROOT / "iamccs_minimax_h3_shotboard.py").read_text(encoding="utf-8"), method)
+    assert source.index('"secondary_lora_continuation_only"') > source.index("**continuity_guard_schema()")
diff --git a/tests/test_open_h3_refine.py b/tests/test_open_h3_refine.py
new file mode 100644
index 0000000..9222237
--- /dev/null
+++ b/tests/test_open_h3_refine.py
@@ -0,0 +1,60 @@
+import importlib.util
+import sys
+import types
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT.parents[1]))
+PACKAGE = "_open_h3_test"
+package = types.ModuleType(PACKAGE)
+package.__path__ = [str(ROOT)]
+sys.modules[PACKAGE] = package
+spec = importlib.util.spec_from_file_location(PACKAGE + ".iamccs_minimax_h3_open_refine", ROOT / "iamccs_minimax_h3_open_refine.py")
+module = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(module)
+atomic = types.ModuleType(PACKAGE + ".iamccs_minimax_h3_atomic_backend")
+atomic._resolve_shotplan = lambda value: value
+
+
+class OpenH3SettingsTests(unittest.TestCase):
+    def resolve(self, settings=None, **plan):
+        payload = {"open_h3_refine": module.configuration(settings or {}), **plan}
+        with patch.dict(sys.modules, {atomic.__name__: atomic}):
+            return module.IAMCCS_MiniMaxH3OpenRefineControl().resolve(payload, 1)
+
+    def test_defaults_keep_existing_workflows_disabled(self):
+        self.assertFalse(self.resolve()[0])
+
+    def test_open_refine_does_not_stack_another_upscale(self):
+        with self.assertRaisesRegex(ValueError, "replaces the other upscale"):
+            self.resolve({"h3_open_refine_enabled": True}, upscale_enabled=True, upscale_mode="h3_ultimate_tiled")
+
+    def test_missing_assets_fail_explicitly(self):
+        with self.assertRaisesRegex(ValueError, "refiner LoRA"):
+            self.resolve({"h3_open_refine_enabled": True, "h3_open_refine_lora_name": ""})
+
+    def test_custom_schedule_prompt_and_segment_seed(self):
+        result = self.resolve({"h3_open_refine_sigma_preset": "custom", "h3_open_refine_custom_sigmas": "0.5,0.2,0", "h3_open_refine_seed": 100, "h3_open_refine_prompt": "Preserve the yawn."}, global_prompt="Other prompt")
+        self.assertEqual((result[1], result[11], result[12]), ("Preserve the yawn.", "0.5,0.2,0", 101))
+
+    def test_blank_distill_is_disabled_and_shot_prompt_wins(self):
+        result = self.resolve({"h3_open_refine_distill_lora_name": ""}, global_prompt="Global", chunks=[{}, {"prompt": "Local shot"}])
+        self.assertEqual(result[1], "Local shot")
+        self.assertEqual(result[10], 0.0)
+
+    def test_reference_schedule_and_output_contract(self):
+        result = self.resolve({"h3_open_refine_sigma_preset": "reference_3step"})
+        self.assertEqual(result[11], module.SIGMAS["reference_3step"])
+        self.assertEqual(len(result), len(module.IAMCCS_MiniMaxH3OpenRefineControl.RETURN_TYPES))
+        self.assertEqual(len(result), len(module.IAMCCS_MiniMaxH3OpenRefineControl.RETURN_NAMES))
+
+    def test_optional_face_source_is_retained_for_native_shots(self):
+        self.assertTrue(self.resolve(face_detailer_settings={"enabled": True}, task_mode="ref2va")[13])
+        self.assertFalse(self.resolve(face_detailer_settings={"enabled": True}, task_mode="longvid_keyframe_continuous")[13])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_open_h3_refine_ui.cjs b/tests/test_open_h3_refine_ui.cjs
new file mode 100644
index 0000000..21ba52f
--- /dev/null
+++ b/tests/test_open_h3_refine_ui.cjs
@@ -0,0 +1,32 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+const assert = require('node:assert/strict');
+const source = fs.readFileSync(path.join(__dirname, '../web/iamccs_h3_settings_pro_ui.js'), 'utf8');
+const values = {upscale_enabled:true,upscale_mode:'h3_ultimate_tiled',h3_open_refine_enabled:false,h3_open_refine_sigma_preset:'reference_3step',rife_mode:'off',h3_omni_enabled:true,steps:8,seed:42};
+const node = {id:811, properties:{}, widgets:Object.entries(values).map(([name,value])=>({name,value}))};
+const widget = (n,key)=>n.widgets.find(w=>w.name===key);
+let connected = ['IAMCCS_MiniMaxH3OpenRefineControl'];
+const context = vm.createContext({node,widget,setValue:(n,key,value)=>{const w=widget(n,key);if(w)w.value=value;},connectedNodes:()=>connected.map(type=>({type})),nodeClass:n=>n.type,shotboardMode:()=> 'ref2va',modeFamily:()=> 'ref2va',document:{dispatchEvent(){}},CustomEvent:class{}});
+const constants = source.slice(source.indexOf('const NODE_TYPE ='), source.indexOf('const widget ='));
+const gate = source.slice(source.indexOf('function branchGate('), source.indexOf('function modeAvailability('));
+const recipes = source.slice(source.indexOf('function applyRecipe('), source.indexOf('const FACE_REFINE_PRESET_HELP'));
+vm.runInContext(constants + gate + recipes + 'globalThis.apply=applyRecipe;globalThis.layout=FUNCTIONAL_LAYOUT;globalThis.groups=GROUPS;',context);
+assert.equal(context.apply(node,'open-h3-refine'),true);
+assert.equal(widget(node,'h3_open_refine_enabled').value,true);
+assert.equal(widget(node,'upscale_enabled').value,false);
+assert.equal(widget(node,'upscale_mode').value,'off');
+assert.equal(widget(node,'h3_open_refine_sigma_preset').value,'gentle_3step');
+assert.equal(widget(node,'h3_omni_enabled').value,true);
+assert.equal(widget(node,'steps').value,8);
+assert.equal(widget(node,'seed').value,42);
+context.apply(node,'native-delivery');
+assert.equal(widget(node,'h3_open_refine_enabled').value,false);
+connected=[];
+assert.equal(context.apply(node,'open-h3-refine'),false);
+assert.equal(widget(node,'h3_open_refine_enabled').value,false);
+const section=context.layout.finish.find(([title])=>title.startsWith('OPEN-H3 REFINEMENT'));
+assert.equal(section[1].length,14);
+assert.ok(context.groups.find(g=>g.id==='finish').fields.includes('h3_open_refine_seed'));
+assert.match(source,/addRecipe\(delivery, "OPEN-H3 REFINEMENT/);
+console.log('PASS: Mode Assistant selection, separate Output box, lazy-branch gate and one-native-generation settings');
diff --git a/tests/test_open_h3_resolution_summary.cjs b/tests/test_open_h3_resolution_summary.cjs
new file mode 100644
index 0000000..7f6f236
--- /dev/null
+++ b/tests/test_open_h3_resolution_summary.cjs
@@ -0,0 +1,25 @@
+const fs = require('node:fs');
+const path = require('node:path');
+const vm = require('node:vm');
+const assert = require('node:assert/strict');
+const source = fs.readFileSync(path.join(__dirname, '../web/iamccs_h3_settings_pro_ui.js'), 'utf8');
+const start = source.indexOf('function openH3ResolutionEstimate(');
+const end = source.indexOf('function openH3ResolutionSummary(', start);
+const context = vm.createContext({widget: (node, name) => node.widgets.find(item => item.name === name)});
+vm.runInContext(source.slice(start, end) + '\nglobalThis.estimate = openH3ResolutionEstimate;', context);
+const node = {widgets: Object.entries({width: 640, height: 384, h3_open_refine_scale: 2, h3_open_refine_enabled: true}).map(([name, value]) => ({name, value}))};
+const set = (name, value) => {node.widgets.find(item => item.name === name).value = value;};
+let result = context.estimate(node);
+assert.deepEqual([result.targetWidth, result.targetHeight, result.pixelGain], [1280, 768, 4]);
+set('width', 1024); set('height', 576); set('h3_open_refine_scale', 2.5);
+result = context.estimate(node);
+assert.deepEqual([result.targetWidth, result.targetHeight, result.pixelGain], [2560, 1440, 6.25]);
+set('width', 736); set('height', 416); set('h3_open_refine_scale', 1.5);
+result = context.estimate(node);
+assert.deepEqual([result.targetWidth, result.targetHeight], [1088, 640], 'match Python half-to-even, not Math.round');
+set('h3_open_refine_enabled', false);
+assert.equal(context.estimate(node).enabled, false);
+set('width', 0);
+assert.equal(context.estimate(node), null);
+assert.match(source, /section\.append\(openH3ResolutionSummary\(node\)\)/);
+console.log('PASS: native/target sizes, pixel gain, QHD, Python grid rounding and bypass state');
diff --git a/tests/test_prompter_request.py b/tests/test_prompter_request.py
new file mode 100644
index 0000000..72c9eba
--- /dev/null
+++ b/tests/test_prompter_request.py
@@ -0,0 +1,52 @@
+import json
+from pathlib import Path
+import sys
+import unittest
+from unittest.mock import patch
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from test_prompter_native_qwen import prompter
+
+
+class RequestCompilationTests(unittest.TestCase):
+    def test_request_is_authority_and_selected_drafts_are_not_context(self):
+        sections = {"scene": "Previous railway scene", "camera": "Old camera", "acting": "Keep her tired performance"}
+        system, user = prompter._assistant_instruction(
+            "t2va", sections, "Develop the requested shot", ["scene", "camera"],
+            request_text="Una donna posa una tazza sul tavolo.",
+        )
+        message = json.loads(user)
+        self.assertEqual(message["request"], "Una donna posa una tazza sul tavolo.")
+        self.assertEqual(message["existing_context"], {"acting": "Keep her tired performance"})
+        self.assertNotIn("Previous railway scene", user)
+        self.assertIn("in English", system)
+        self.assertIn("Never emit timing placeholders", system)
+        self.assertEqual(sections["scene"], "Previous railway scene")
+
+    def test_request_returns_generated_fields(self):
+        generated = {"scene": "A woman approaches a table holding a cup.", "camera": "A fixed eye-level composition holds the table in view."}
+        with patch.object(prompter, "native_json_chat", return_value=generated) as writer:
+            fields, report = prompter.rewrite_sections_with_ai(
+                "qwen_native", "", "__workflow__", "", "t2va", {"scene": "", "camera": ""},
+                target_keys=["scene", "camera"], request_text="Una donna posa una tazza sul tavolo.",
+            )
+        self.assertEqual(fields, generated)
+        self.assertEqual(report["rewritten_sections"], ["camera", "scene"])
+        self.assertIn('"request":', writer.call_args.args[2])
+
+    def test_request_echo_is_not_reported_as_success(self):
+        brief = "Una donna posa una tazza sul tavolo."
+        with patch.object(prompter, "native_json_chat", return_value={"scene": brief, "camera": brief}):
+            with self.assertRaisesRegex(RuntimeError, "echoed REQUEST"):
+                prompter.rewrite_sections_with_ai(
+                    "qwen_native", "", "__workflow__", "", "t2va", {"scene": "", "camera": ""},
+                    target_keys=["scene", "camera"], request_text=brief,
+                )
+
+    def test_single_field_rewrite_keeps_its_original_contract(self):
+        _, user = prompter._assistant_instruction("t2va", {"scene": "A quiet room"}, target_keys=["scene"])
+        self.assertEqual(json.loads(user)["rough_sections"], {"scene": "A quiet room"})
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_prompter_tag_authoring.py b/tests/test_prompter_tag_authoring.py
new file mode 100644
index 0000000..1ede6b9
--- /dev/null
+++ b/tests/test_prompter_tag_authoring.py
@@ -0,0 +1,77 @@
+import json
+from pathlib import Path
+import sys
+import unittest
+from unittest.mock import patch
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from test_prompter_native_qwen import prompter
+
+
+class OfficialTagAuthoringTests(unittest.TestCase):
+    def test_global_request_creates_speech_tags_even_when_input_has_none(self):
+        system, user = prompter._assistant_instruction(
+            't2va', {}, 'Compile Global', ['scene', 'dialogue'],
+            request_text='Una donna dice: Aspettami qui.',
+        )
+        self.assertIn('even when the rough request has no tags', system)
+        self.assertIn('<d>[Language] exact words</d>', system)
+        self.assertIn('independently of subject numbering', system)
+        self.assertIn('<scenetrans>', system)
+        self.assertIn('<cutoff>', system)
+        self.assertIn('Global describes output scope', system)
+        self.assertEqual(json.loads(user)['request'], 'Una donna dice: Aspettami qui.')
+
+    def test_reference_grammar_distinguishes_assets_content_and_speakers(self):
+        keys=[key for key,_ in prompter.MODE_SECTIONS['ref2va']]
+        system,_=prompter._assistant_instruction('ref2va',{},'',keys,request_text='The second character speaks.')
+        for tag in ['<Subject N>', '<Picture N>', '<Video N>', '<Audio N>']:
+            self.assertIn(tag,system)
+        self.assertIn('Do not populate unused slots',system)
+        self.assertIn('full-reference modes keep their six sections',system)
+
+    def test_compact_retry_retains_tag_rules(self):
+        system,_=prompter._compact_assistant_instruction('i2va',{},'She says hello.',['dialogue'])
+        self.assertIn('<d>[Language] exact words</d>',system)
+
+    def test_specialized_edit_grammars_are_not_overwritten(self):
+        for mode in ['v2va_face_swap_lora','ref2va_vfx_edit']:
+            self.assertIn('native aligned-edit grammar',prompter._official_h3_tag_rules(mode))
+            self.assertNotIn('Format every supplied',prompter._official_h3_tag_rules(mode))
+
+    def test_reference_output_preserves_independent_subject_and_speaker_ids(self):
+        line='<Subject 2> (S1) says <d>[Italian] Aspettami qui.</d>'
+        payload={'subject_definitions':'<Subject 2> is the woman in <Picture 1>.','detailed_description':'[Shot 1] '+line}
+        reply={'choices':[{'message':{'content':json.dumps(payload)}}]}
+        with patch.object(prompter,'_http_json',return_value=reply):
+            fields,_=prompter.rewrite_sections_with_ai('lm_studio','','local','','ref2va',{},target_keys=list(payload),request_text='Una donna dice: Aspettami qui.')
+        self.assertIn(line,fields['detailed_description'])
+        self.assertNotIn('<Subject 1>',fields['detailed_description'])
+
+    def test_global_and_locals_endpoint_uses_the_same_tag_contract(self):
+        payload={'global_prompt':'A quiet room.','shots':[{'slot':1,'local_prompt':'(S1) says <d>[Italian] Resta.</d>'}]}
+        with patch.object(prompter,'_multimodal_json_chat',return_value=payload) as chat:
+            plan,_=prompter.build_visual_story_plan_with_ai('lm_studio','','local','','Prompt 1: una donna dice Resta.','t2va',[])
+        self.assertIn('even when the rough request has no tags',chat.call_args.args[4])
+        self.assertIn('<d>[Italian] Resta.</d>',plan['shots'][0]['local_prompt'])
+
+    def test_request_utterance_with_says_and_cutoff_survives_a_bad_rewrite(self):
+        line='<Subject 2> (S1) says <d>[Italian] Non andare!</d><cutoff>'
+        reply={'choices':[{'message':{'content':json.dumps({'dialogue':'The woman says go.'})}}]}
+        with patch.object(prompter,'_http_json',return_value=reply):
+            fields,_=prompter.rewrite_sections_with_ai('lm_studio','','local','','t2va',{},target_keys=['dialogue'],request_text=line)
+        self.assertIn(line,fields['dialogue'])
+        self.assertNotIn('The woman says go.',fields['dialogue'])
+
+    def test_standalone_voice_and_cross_cut_markers_are_preserved(self):
+        line='(S2) speaks off-screen <d>[English] Stay here.</d><scenetrans>'
+        self.assertEqual(prompter._authored_h3_dialogue_lines(line),[line])
+
+    def test_keyframe_global_does_not_absorb_timed_dialogue_from_request(self):
+        line='(S1) says <d>[Italian] Resta.</d>'
+        reply={'choices':[{'message':{'content':json.dumps({'reference_use':'Keep the same opening frame.'})}}]}
+        with patch.object(prompter,'_http_json',return_value=reply):
+            fields,_=prompter.rewrite_sections_with_ai('lm_studio','','local','','fl2va',{},target_keys=['reference_use'],request_text=line)
+        self.assertNotIn('<d>',fields['reference_use'])
+
+
+if __name__=='__main__':unittest.main()
diff --git a/web/iamccs_h3_prompter_workspace.js b/web/iamccs_h3_prompter_workspace.js
index 25b03a6..509e616 100644
--- a/web/iamccs_h3_prompter_workspace.js
+++ b/web/iamccs_h3_prompter_workspace.js
@@ -103,8 +103,6 @@ export function createPrompterWorkspace({ root, layout, left, center, right, mod
         buttons.set(key, button);
     }
     function refresh() {
-        const request = center.querySelector('[data-workspace="direction"]');
-        if (request && center.firstElementChild !== request) center.prepend(request);
         const hasShots = Boolean(center.querySelector('[data-workspace="shots"]'));
         buttons.get("shots").disabled = !hasShots;
         if (selected === "shots" && !hasShots) selected = "direction";
@@ -122,5 +120,5 @@ export function createPrompterWorkspace({ root, layout, left, center, right, mod
         }
     }
     refresh();
-    return { refresh };
+    return { refresh, showReview() { selected = "review"; refresh(); } };
 }
diff --git a/web/iamccs_h3_settings_pro_ui.js b/web/iamccs_h3_settings_pro_ui.js
index 4827da4..932a7d6 100644
--- a/web/iamccs_h3_settings_pro_ui.js
+++ b/web/iamccs_h3_settings_pro_ui.js
@@ -9,6 +9,7 @@ const NODE_TYPE = "IAMCCS_ShotboardH3SettingsPro";
 const SHOTBOARD_TYPE = "IAMCCS_MiniMaxH3ShotPlanner";
 const BRIDGE_TYPES = new Set(["IAMCCS_CineH3Input", "IAMCCS_CineH3FunControlInput", "IAMCCS_MiniMaxH3FunControlInput"]);
 const SHOTBOARD_OWNED = new Set(["task_mode"]);
+const OPEN_H3_REFINE_FIELDS = ["h3_open_refine_enabled", "h3_open_refine_scale", "h3_open_refine_model_name", "h3_open_refine_precision", "h3_open_refine_device", "h3_open_refine_temporal_chunking", "h3_open_refine_lora_name", "h3_open_refine_strength", "h3_open_refine_distill_lora_name", "h3_open_refine_distill_strength", "h3_open_refine_sigma_preset", "h3_open_refine_custom_sigmas", "h3_open_refine_seed", "h3_open_refine_prompt"];
 const AUTO_IMPORT_BLOCKED = new Set([
   "global_prompt", "timeline_data", "image_paths", "frame_rate", "audio_mode",
   "guide_policy", "min_guide_gap_seconds", "max_guides", "default_force", "promptrelay_epsilon",
@@ -38,11 +39,13 @@ const INTERNAL = new Set([
 // compiler intentionally does not publish to CineLinX, so the PRO surface does
 // not present them as a second source of truth.
 const COMPATIBILITY_ONLY = new Set([
+  "h3_guard_reference_memory", "h3_guard_repair_denoise", "h3_guard_repair_steps", "h3_guard_motion_tolerance",
   "frame_rate", "guide_policy", "min_guide_gap_seconds", "max_guides", "default_force",
   "promptrelay_epsilon", "ltx_round_mode", "image_width", "image_height",
   "image_resize_method", "image_multiple_of", "img_compression",
 ]);
 const GROUPS = [
+  { id: "continuity_guard", label: "CONTINUITY MONITOR", title: "Read-only Extended AV diagnostics. Repair has been retired; this monitor does not prevent degradation.", modeEngine: true, fields: ["h3_guard_mode", "h3_guard_detail_ratio"] },
   { id: "ahead", label: "AHEAD CONTROL ROOM", title: "LatentGoAhead seam controls", fields: [] },
   { id: "extension", label: "LONG TAKE · EXTEND", title: "Automatic native AV extension for one authored shot beyond 15 seconds", modeEngine: true, fields: ["extended_av_profile", "extended_av_custom_window_frames", "extended_av_custom_overlap_frames"] },
   { id: "continuation", label: "SAVED TAKE · CONTINUATION", title: "Start a new generation from a previously saved AV checkpoint", fields: ["h3_continuation_enabled", "h3_continuation_save_enabled", "h3_continuation_checkpoint", "h3_continuation_context_frames", "h3_continuation_handover_mode", "h3_continuation_manual_tail_frames", "h3_continuation_visual_handover", "h3_continuation_run_and_gun_enabled", "h3_continuation_run_and_gun_join", "h3_continuation_soft_video_frames", "h3_continuation_soft_video_curve", "h3_continuation_soft_audio_ms"] },
@@ -64,7 +67,7 @@ const GROUPS = [
   { id: "audio", label: "2 · AUDIO", title: "Audio authority and EXTEND seam polish", fields: ["audio_mode", "reference_audio_role", "voice_reference_picture_index", "extended_av_soft_audio_handover_ms", "extended_av_boundary_polish_ms", "extended_av_boundary_polish_strength"] },
   { id: "memory", label: "3 · MEMORY", title: "VRAM preset", fields: ["performance_profile", "motion_context_window_frames", "text_encoder_device", "h3_exact_profile", "h3_exact_chunk_rows", "h3_exact_precision_mode", "h3_exact_qkv_streaming", "h3_exact_attention_memory", "h3_clipproj_profile", "h3_clipproj_load_mode", "vram_clean_before_decode"] },
   { id: "sampling", label: "4 · SAMPLE", title: "Native H3 sampling", fields: ["seed", "seed_policy", "seed_stride", "steps", "sampler_name", "scheduler", "denoise", "shift_video", "shift_audio"] },
-{ id: "speed", label: "5 · SPEED", title: "Acceleration recipe", fields: ["h3_attention_backend", "h3_veda_enabled", "h3_veda_predictor", "h3_veda_verbose", "acceleration", "turbo_mode", "turbo_lora_name", "turbo_strength", "turbo_sampler_mode", "fused_turbo_model_name", "fused_turbo_sigma_preset", "pdd_lora_name", "pdd_strength", "secondary_lora_enabled", "secondary_lora_name", "secondary_lora_strength", "ref_image_size", "sol_conditioning", "spectrum_profile", "h3_sla_sparsity", "h3_sla_dense_last_steps"] },
+{ id: "speed", label: "5 · SPEED", title: "Acceleration recipe", fields: ["h3_attention_backend", "h3_veda_enabled", "h3_veda_predictor", "h3_veda_verbose", "acceleration", "turbo_mode", "turbo_lora_name", "turbo_strength", "turbo_sampler_mode", "fused_turbo_model_name", "fused_turbo_sigma_preset", "pdd_lora_name", "pdd_strength", "secondary_lora_enabled", "secondary_lora_name", "secondary_lora_strength", "secondary_lora_continuation_only", "ref_image_size", "sol_conditioning", "spectrum_profile", "h3_sla_sparsity", "h3_sla_dense_last_steps"] },
   { id: "direction", label: "6 · DIRECT · LEGACY", title: "Legacy Direct compatibility", fields: ["reference_role_1", "reference_role_2", "reference_role_3", "reference_role_4", "reference_video_role", "v2v_guide_mode", "v2v_source_range_policy", "v2v_source_offset_seconds", "v2v_source_fit", "v2v_source_end_policy", "v2v_audio_pairing", "flf_join_mode", "flf_overlap_frames", "flf_continuity_mode", "flf_continuity_tail_frames", "flf_continuity_audio", "longvid_guide_window_policy", "keyframe_joint_latent_new", "longvid_terminal_endpoint_mode", "longvid_pianosequenza_2stage_enabled"] }, // IAMCCS_LONGVID_ENDPOINT_STRATEGIES_V1
   { id: "control", label: "CONTROLNET", title: "H3 Fun ControlNet", contextual: "control", modeEngine: true, fields: ["h3_controlnet_enabled", "h3_controlnet_name", "h3_controlnet_kind", "h3_controlnet_preprocess_resolution", "h3_controlnet_strength", "h3_controlnet_start_percent", "h3_controlnet_end_percent", "h3_controlnet_frame_scope", "h3_controlnet_end_policy", "h3_controlnet_use_video_audio", "h3_controlnet_dwpose_torch_gpu"] },
   { id: "vfx_edit", label: "VFX EDIT", title: "REF2VA · VFX EDIT · aligned video guide", modeEngine: true, fields: ["h3_vfx_lora_name", "h3_vfx_lora_strength", "h3_edit_video_source", "upscale_enabled", "upscale_mode", "upscale_width", "upscale_height"] },
@@ -75,6 +78,7 @@ const GROUPS = [
   { id: "finish", label: "7 · OUTPUT", title: "Delivery", fields: ["h3_editor_enabled", "upscale_mode", "upscale_enabled", "upscale_width", "upscale_height", "h3_pixel_tiled_method", "h3_pixel_tiled_model_name", "h3_pixel_tiled_tile_size", "h3_pixel_tiled_overlap", "upscale_prompt", "upscale_sage", "upscale_seed_offset", "wan_upscale_denoise", "ltx_seam_safe", "ltx_detailer_enabled", "ltx_detailer_lora_name", "ltx_detailer_strength", "ltx_4k_enabled", "ltx_4k_quality", "ltx_looper_temporal_tile_size", "ltx_looper_temporal_overlap", "ltx_looper_guiding_strength", "ltx_looper_overlap_strength", "ltx_looper_cond_image_strength", "ltx_looper_horizontal_tiles", "ltx_looper_vertical_tiles", "ltx_looper_spatial_overlap", "h3_upres_model_name", "h3_upres_precision", "h3_upres_device", "h3_upres_keep_models_resident", "h3_fast_latent_temporal_chunk", "h3_fast_latent_stage2_window", "h3_fast_latent_stage2_overlap", "h3_fast_latent_stage2_guides", "h3_upres_seed", "h3_upres_steps", "h3_upres_denoise", "h3_upres_sampler", "h3_upres_scheduler", "h3_upres_temporal_chunk", "h3_upres_temporal_overlap", "h3_upres_anchor_strength", "h3_upres_tile_width", "h3_upres_tile_height", "h3_upres_overlap_width", "h3_upres_overlap_height", "h3_upres_fade_width", "h3_upres_fade_height", "h3_upres_min_tile_size", "h3_upres_overlap_mode", "h3_upres_overlap_blend", "h3_upres_rtx_enabled", "h3_upres_rtx_quality", "h3_upres_pixel_groups", "h3_upres_window_frames", "h3_upres_window_overlap", "h3_upres_pixel_method"] },
   { id: "advanced", label: "TECHNICAL", title: "Technical controls", dynamic: true, fields: [] },
 ];
+GROUPS.find(group => group.id === "finish").fields.push(...OPEN_H3_REFINE_FIELDS);
 const ENGINE_IDS = Object.freeze(GROUPS.filter((group) => group.modeEngine || ["ahead", "continuation", "refmod", "face_refine", "scout"].includes(group.id)).map((group) => group.id));
 const ENGINE_ID_SET = new Set(ENGINE_IDS);
 const ASSIGNED = new Set(GROUPS.flatMap((group) => group.fields));
@@ -116,6 +120,7 @@ const FUNCTIONAL_LAYOUT = {
   ],
   finish: [
     ["OUTPUT", ["rife_mode", "upscale_enabled", "upscale_mode", "upscale_width", "upscale_height", "upscale_prompt", "upscale_sage", "upscale_seed_offset", "wan_upscale_denoise"]],
+    ["OPEN-H3 REFINEMENT · AFTER ONE NATIVE GENERATION", OPEN_H3_REFINE_FIELDS],
     ["PIXEL SAFE · LOW VRAM", ["h3_pixel_tiled_method", "h3_pixel_tiled_model_name", "h3_pixel_tiled_tile_size", "h3_pixel_tiled_overlap"]],
     ["LTX DELIVERY", ["ltx_seam_safe", "ltx_detailer_enabled", "ltx_detailer_lora_name", "ltx_detailer_strength", "ltx_4k_enabled", "ltx_4k_quality", "ltx_looper_temporal_tile_size", "ltx_looper_temporal_overlap", "ltx_looper_guiding_strength", "ltx_looper_overlap_strength", "ltx_looper_cond_image_strength", "ltx_looper_horizontal_tiles", "ltx_looper_vertical_tiles", "ltx_looper_spatial_overlap"]],
     ["H3 2-PASS MODEL", ["h3_upres_model_name", "h3_upres_precision", "h3_upres_device", "h3_upres_keep_models_resident"]],
@@ -314,6 +319,7 @@ function selectDeliveryMode(node, mode) {
   if (!deliveryModeAvailable(node,mode)) return false;
   const option = H3_DELIVERY_MODES.find(([key]) => key === mode);
   if (!option) return false;
+  setValue(node,"h3_open_refine_enabled",false,false);
   if (["h3_fast_latent_2pass","h3_ultimate_tiled"].includes(mode)) {
     const selected = String(widget(node,"h3_upres_model_name")?.value || "");
     const installed = selected && !/^none$/i.test(selected) ? selected : firstChoice(node,"h3_upres_model_name",name => /minimax_h3.*upscaler/i.test(name));
@@ -330,6 +336,44 @@ function selectDeliveryMode(node, mode) {
 }
 
 const widget = (node, name) => (node?.widgets || []).find((item) => item?.name === name);
+
+function openH3ResolutionEstimate(node) {
+  const width = Number(widget(node, "width")?.value), height = Number(widget(node, "height")?.value);
+  const scale = Number(widget(node, "h3_open_refine_scale")?.value);
+  if (![width, height, scale].every(value => Number.isFinite(value) && value > 0)) return null;
+  // Match the latent upscaler's Python round-to-even on its 32-pixel grid.
+  const align = value => {
+    const cells = value / 32, lower = Math.floor(cells);
+    return Math.max(16, (cells - lower === 0.5 ? lower + lower % 2 : Math.round(cells)) * 32);
+  };
+  const targetWidth = align(width * scale), targetHeight = align(height * scale);
+  return {width, height, scale, targetWidth, targetHeight,
+    widthGain: targetWidth / width, heightGain: targetHeight / height,
+    pixelGain: targetWidth * targetHeight / (width * height),
+    enabled: Boolean(widget(node, "h3_open_refine_enabled")?.value)};
+}
+
+function openH3ResolutionSummary(node) {
+  const box = document.createElement("div");
+  box.className = "h3p-context";
+  box.dataset.openH3Resolution = "true";
+  box.style.cssText = "margin:0 0 10px;line-height:1.6";
+  box.setAttribute("role", "status");
+  box.setAttribute("aria-label", "Open-H3 resolution and pixel gain");
+  const estimate = openH3ResolutionEstimate(node);
+  if (!estimate) { box.textContent = "Set the Native width, height and Open-H3 scale to preview the output size."; return box; }
+  const {width, height, targetWidth, targetHeight, widthGain, heightGain, pixelGain, enabled} = estimate;
+  const format = value => value.toLocaleString("en-US", {maximumFractionDigits: 2});
+  const size = document.createElement("b");
+  size.textContent = `${width} × ${height} → ${targetWidth} × ${targetHeight}`;
+  const gain = document.createElement("div");
+  gain.textContent = `${format(widthGain)}× width · ${format(heightGain)}× height · ${format(pixelGain)}× pixels`;
+  const note = document.createElement("div");
+  note.style.cssText = "color:#a9b7c5;font-size:9px";
+  note.textContent = `${enabled ? "Estimated Open-H3 output" : "Open-H3 OFF: configured target only; refinement disabled"}. Based on the Native canvas, rounded to 32 px. Pixel gain does not measure quality gain.`;
+  box.append(size, gain, note);
+  return box;
+}
 const nodeClass = (node) => String(node?.comfyClass || node?.type || "");
 function hideWidget(item) {
   if (!item || item._iamccsProHidden) return;
@@ -545,6 +589,10 @@ function connectedNodes(node) {
 function branchGate(node, name) {
   const classes = node._iamccsSettingsProConnectedClasses || connectedNodes(node).map(nodeClass);
   const has = (pattern) => classes.some((value) => pattern.test(value));
+  if (name.startsWith("h3_open_refine_")) return {
+    available: has(/^IAMCCS_MiniMaxH3OpenRefineControl$/),
+    reason: "Load the R49 Open-H3 workflow with its connected refinement settings branch.",
+  };
   if (name === "keyframe_joint_latent_new") return {
     available: Boolean(widget(node, "extended_av_profile")),
     reason: "LATENT NEW uses the B1 EXTEND backend.",
@@ -1222,6 +1270,7 @@ function selectedMemory(node) {
 }
 // IAMCCS FACE/UPSCALE MODE ASSISTANT V2
 function selectedDelivery(node) {
+  if (widget(node, "h3_open_refine_enabled")?.value) return "open-h3-refine";
   if (!widget(node, "upscale_enabled")?.value) return "native-delivery";
   const mode = String(widget(node, "upscale_mode")?.value || "off");
   if (!deliveryBranchGate(node, mode).available) return "native-delivery";
@@ -1274,8 +1323,14 @@ function deliveryModeAvailable(node, mode) {
 
 function applyRecipe(node, recipe) {
   const mode = shotboardMode(node), family = modeFamily(mode), set = (name, value) => setValue(node, name, value, false);
+  if (["native-delivery", "ultimate-tiled", "upres", "h3-pixel", "pixel-safe", "ltx-master", "ltx-per-shot", "rtx-final"].includes(recipe)) set("h3_open_refine_enabled", false);
   if (["native", "pdd", "fasth3", "sla", "fused"].includes(recipe)) set("h3_omni_enabled", false);
-  if (recipe === "omni") {
+  if (recipe === "open-h3-refine") {
+    if (!branchGate(node, "h3_open_refine_enabled").available) return false;
+    set("upscale_enabled", false); set("upscale_mode", "off");
+    set("h3_open_refine_enabled", true); set("rife_mode", "off");
+    set("h3_open_refine_sigma_preset", "gentle_3step");
+  } else if (recipe === "omni") {
     resetAcceleration(set); set("h3_omni_enabled", true); set("acceleration", "h3_sage"); set("h3_attention_backend", "h3_sage");
     set("steps", 8); set("sampler_name", "euler"); set("scheduler", "simple");
     set("denoise", 1); set("shift_video", 12); set("shift_audio", 3);
@@ -1834,6 +1889,7 @@ function mount(node) {
     const targetEngine = modeEngineGroup(node, assistantModeKey(node, mode));
     return GROUPS.filter((group) => {
       if (group.id === "engine_reference_image") return false;
+      if (group.id === "continuity_guard") return true;
       if (group.id === "ahead" && mode !== "latent_go_ahead") return false;
       if (group.modeEngine && group.id !== targetEngine) return false;
       return ["continuation", "refmod"].includes(group.id) || group.assistant || group.dynamic || group.fields.some((name) => widget(node, name));
@@ -1844,10 +1900,11 @@ function mount(node) {
     return (node.widgets || []).map((item) => item?.name).filter((name) => name && !ASSIGNED.has(name) && !SHOTBOARD_OWNED.has(name) && !INTERNAL.has(name) && !COMPATIBILITY_ONLY.has(name) && fieldRelevant(name, mode));
   }
   function makeControl(name) {
-    const item = widget(node, name); if (!item) return null;
+    const item = widget(node, name); if (!item || (name.startsWith("h3_guard_") && COMPATIBILITY_ONLY.has(name))) return null;
     const box = document.createElement("div"); box.className = "h3p-field";
-    const label = document.createElement("label"); label.textContent = human(name); box.append(label);
-    let control; const options = choices(item);
+    if (name === "secondary_lora_continuation_only") box.style.gridColumn = "1 / -1";
+    const label = document.createElement("label"); label.textContent = name === "secondary_lora_continuation_only" ? "Second LoRA: from segment 2" : human(name); box.append(label);
+    let control; const options = name === "h3_guard_mode" ? ["off", "monitor"] : choices(item);
     if (options.length) {
       control = document.createElement("select"); options.forEach((value) => control.add(new Option(
         name === "h3_fast_latent_stage2_guides"
@@ -1859,6 +1916,19 @@ function mount(node) {
       control = document.createElement("input"); control.type = typeof item.value === "number" ? "number" : "text"; control.value = item.value ?? "";
       if (control.type === "number") { if (Number.isFinite(item.options?.min)) control.min = item.options.min; if (Number.isFinite(item.options?.max)) control.max = item.options.max; control.step = item.options?.step ?? "any"; }
     }
+    if (name.startsWith("h3_guard_")) {
+      const supported = assistantModeKey(node) === "fl2va_extended_av";
+      const mode = String(widget(node, "h3_guard_mode")?.value || "off");
+      if (name === "h3_guard_mode" && mode === "repair") {
+        control.value = "off";
+        control.title = "Saved Repair mode is retired and runs as Off. Select Monitor for diagnostics.";
+        const notice = document.createElement("small");
+        notice.textContent = "Saved Repair mode retired - effective mode: Off.";
+        box.append(notice);
+      }
+      control.disabled = !supported || (name !== "h3_guard_mode" && mode !== "monitor");
+      if (!supported) control.title = "Continuity Guard currently supports Extended AV only.";
+    }
     const gate = branchGate(node, name);
     if (!gate.available) {
       control.disabled = true;
@@ -1880,6 +1950,10 @@ function mount(node) {
       const value = control.type === "checkbox" ? control.checked : control.type === "number" ? Number(control.value) : control.value;
       if (name === "duration_seconds") setShotboardDuration(node, value);
       else if (name === "audio_mode") setShotboardAudio(node, value);
+      else if (name === "h3_open_refine_enabled") {
+        if (value) applyRecipe(node, "open-h3-refine");
+        else setValue(node, name, false, false);
+      }
       else if (name === "upscale_enabled") selectDeliveryMode(node,value ? (String(widget(node,"upscale_mode")?.value || "off") !== "off" ? widget(node,"upscale_mode").value : node.properties?.iamccs_delivery_route || "h3_ultimate_tiled") : "off");
       else if (name === "upscale_mode") selectDeliveryMode(node,String(value));
       else if (["upscale_width","upscale_height"].includes(name)) {
@@ -2181,6 +2255,7 @@ function mount(node) {
     const delivery = document.createElement("div"); delivery.className = "h3p-recipes h3p-delivery-recipes";
     addRecipe(delivery, "FACE REFINE · TOGGLE", "face-refine", true, selectedFace);
     addRecipe(delivery, "NATIVE DELIVERY", "native-delivery", true, selectedFinish === "native-delivery");
+    addRecipe(delivery, "OPEN-H3 REFINEMENT · 3 STEP", "open-h3-refine", branchGate(node, "h3_open_refine_enabled").available, selectedFinish === "open-h3-refine");
     addRecipe(delivery, "H3 DETAIL · 1-STEP REFINE", "ultimate-tiled", deliveryModeAvailable(node, "h3_ultimate_tiled"), selectedFinish === "ultimate-tiled");
     addRecipe(delivery, "H3 2-PASS UPRES", "upres", branchGate(node, "h3_upres_model_name").available && deliveryModeAvailable(node, "h3_fast_latent_2pass"), selectedFinish === "upres");
     addRecipe(delivery, "PIXEL SAFE · LOW VRAM", "pixel-safe", deliveryModeAvailable(node, "pixel_tiled_low_vram"), selectedFinish === "pixel-safe");
@@ -2191,6 +2266,7 @@ function mount(node) {
     grid.append(delivery);
     const detailNote = document.createElement("p");
     detailNote.textContent = mode === "v2va_face_swap" ? "SAM3 crop swap supports Native / RTX delivery. H3 Detail needs a full-frame latent and is unavailable for this legacy crop mode." : "H3 DETAIL uses the proven SwapChar second-pass recipe for full-frame video modes: learned latent upscale, 1 step, SA Solver / simple, denoise 0.2, seed 777. Output exposes the shared seed, dimensions, model, sampling and tile controls. The native pass keeps its own settings.";
+    if (selectedFinish === "open-h3-refine") detailNote.textContent = "One native generation followed by Open-H3 refinement. Dedicated controls are in Output / Open-H3 Refinement. The source soundtrack is retained. Gentle sigma 0.8 still requires visual review of identity and acting; the high-resolution transformer pass is not tiled.";
     grid.append(detailNote);
   }
   async function renderAssetLibrary(kind, grid) {
@@ -2667,10 +2743,10 @@ function mount(node) {
       stack.append(stackText, reset);
       recipes.append(presetGrid, stack);
     }
-    const recipeSet = active === "memory" ? [["≤ 8–12 GB · 124F / 2048 ROWS", "vram8"], ["12–16 GB · 209F / 4096 ROWS", "vram12"], ["16–24 GB · 294F / 8192 ROWS", "vram16"], ["24 GB+ · 362F / 16384 ROWS", "vram24"]] : active === "speed" ? [["NATIVE QUALITY · 20 STEP", "native"], ["PDD · 8 STEP", "pdd"], ["FASTH3 · 6 STEP", "fasth3"], ["SLA · 4 STEP", "sla"], ["FUSED FAST · T2VA ONLY", "fused"]] : active === "control" ? [["ENABLE + SELECT INSTALLED MODEL", "control"]] : active === "face" ? [["SAM3 SUBJECT SWAP · SAFE DEFAULTS", "face"]] : active === "face_refine" ? [["FACE REFINE · TOGGLE", "face-refine"]] : active === "finish" ? [["NATIVE DELIVERY", "native-delivery"], ["H3 DETAIL · 1-STEP REFINE", "ultimate-tiled"], ["PIXEL SAFE · LOW VRAM", "pixel-safe"], ["H3 2-PASS UPRES", "upres"], ["H3 PIXEL REFINE", "h3-pixel"], ["LTX 2.3 MASTER", "ltx-master"], ["LTX 2.3 PER-SHOT", "ltx-per-shot"], ["RTX FINAL", "rtx-final"]] : [];
+    const recipeSet = active === "memory" ? [["≤ 8–12 GB · 124F / 2048 ROWS", "vram8"], ["12–16 GB · 209F / 4096 ROWS", "vram12"], ["16–24 GB · 294F / 8192 ROWS", "vram16"], ["24 GB+ · 362F / 16384 ROWS", "vram24"]] : active === "speed" ? [["NATIVE QUALITY · 20 STEP", "native"], ["PDD · 8 STEP", "pdd"], ["FASTH3 · 6 STEP", "fasth3"], ["SLA · 4 STEP", "sla"], ["FUSED FAST · T2VA ONLY", "fused"]] : active === "control" ? [["ENABLE + SELECT INSTALLED MODEL", "control"]] : active === "face" ? [["SAM3 SUBJECT SWAP · SAFE DEFAULTS", "face"]] : active === "face_refine" ? [["FACE REFINE · TOGGLE", "face-refine"]] : active === "finish" ? [["OPEN-H3 REFINEMENT · 3 STEP", "open-h3-refine"], ["NATIVE DELIVERY", "native-delivery"], ["H3 DETAIL · 1-STEP REFINE", "ultimate-tiled"], ["PIXEL SAFE · LOW VRAM", "pixel-safe"], ["H3 2-PASS UPRES", "upres"], ["H3 PIXEL REFINE", "h3-pixel"], ["LTX 2.3 MASTER", "ltx-master"], ["LTX 2.3 PER-SHOT", "ltx-per-shot"], ["RTX FINAL", "rtx-final"]] : [];
     recipeSet.forEach(([label, id]) => {
-      const deliveryRecipe = ["native-delivery", "ultimate-tiled", "pixel-safe", "upres", "h3-pixel", "ltx-master", "ltx-per-shot", "rtx-final", "face-refine"].includes(id);
-      const deliveryAvailable = id === "upres"
+      const deliveryRecipe = ["open-h3-refine", "native-delivery", "ultimate-tiled", "pixel-safe", "upres", "h3-pixel", "ltx-master", "ltx-per-shot", "rtx-final", "face-refine"].includes(id);
+      const deliveryAvailable = id === "open-h3-refine" ? branchGate(node, "h3_open_refine_enabled").available : id === "upres"
         ? branchGate(node, "h3_upres_model_name").available && deliveryModeAvailable(node, "h3_fast_latent_2pass")
         : id === "ultimate-tiled" ? deliveryModeAvailable(node, "h3_ultimate_tiled")
         : id === "h3-pixel" ? deliveryModeAvailable(node, "h3_pixel_refine")
@@ -2757,6 +2833,7 @@ function mount(node) {
     const grid = q("[data-grid]"); grid.className = "h3p-grid"; grid.replaceChildren();
     if (mode === "v2va_face_swap_lora" && ["swap_lora", "overview"].includes(active)) swapDuration.render(grid);
     let names = fieldNames(group, mode);
+    if (active === "finish") names = [...new Set([...names, ...OPEN_H3_REFINE_FIELDS.filter(name => widget(node, name))])];
     if (active === "swap_lora" && !names.includes("duration_seconds")) names.unshift("duration_seconds");
     if (active === "overview" && (mode !== "longvid_guides" || String(widget(node,"upscale_mode")?.value) === "h3_fast_latent_2pass")) {
       names = names.filter((name) => !["upscale_link_to_native", "upscale_link_factor"].includes(name));
@@ -2774,7 +2851,7 @@ function mount(node) {
       if (!check.checked) {
         const selected = selectedAcceleration(node);
         const fields = {omni: ["h3_omni_enabled", "h3_clipproj_profile", "h3_clipproj_load_mode"], native: [], pdd: ["pdd_lora_name"], fasth3: ["turbo_lora_name"], sla: ["turbo_lora_name", "h3_sla_sparsity"], fused: ["fused_turbo_model_name"]}[selected] || ["turbo_mode", "turbo_lora_name"];
-        names = names.filter(name => ["acceleration", "h3_attention_backend", "h3_veda_enabled", "h3_veda_predictor", "h3_veda_verbose", ...fields].includes(name));
+        names = names.filter(name => ["acceleration", "h3_attention_backend", "h3_veda_enabled", "h3_veda_predictor", "h3_veda_verbose", ...fields, "secondary_lora_enabled", "secondary_lora_name", "secondary_lora_strength", "secondary_lora_continuation_only"].includes(name));
       }
     }
     let layout = FUNCTIONAL_LAYOUT[active];
@@ -2784,7 +2861,7 @@ function mount(node) {
     }
     if (layout) {
       const used = new Set();
-      layout.forEach(([title, fields]) => { const relevant = fields.filter((name) => names.includes(name)); if (!relevant.length) return; const section = document.createElement("section"); section.className = "h3p-functional"; section.innerHTML = `<div class="h3p-functional-title">${title}</div>`; const inner = document.createElement("div"); inner.className = "h3p-functional-grid"; relevant.forEach((name) => { used.add(name); const control = makeControl(name); if (control) inner.append(control); }); section.append(inner); grid.append(section); });
+      layout.forEach(([title, fields]) => { const relevant = fields.filter((name) => names.includes(name)); if (!relevant.length) return; const section = document.createElement("section"); section.className = "h3p-functional"; section.innerHTML = `<div class="h3p-functional-title">${title}</div>`; if (relevant.includes("h3_open_refine_scale")) section.append(openH3ResolutionSummary(node)); const inner = document.createElement("div"); inner.className = "h3p-functional-grid"; relevant.forEach((name) => { used.add(name); const control = makeControl(name); if (control) inner.append(control); }); section.append(inner); grid.append(section); });
       const remaining = names.filter((name) => !used.has(name)); if (remaining.length) { const section = document.createElement("section"); section.className = "h3p-functional"; section.innerHTML = '<div class="h3p-functional-title">OTHER</div>'; const inner = document.createElement("div"); inner.className = "h3p-functional-grid"; remaining.forEach((name) => { const control = makeControl(name); if (control) inner.append(control); }); section.append(inner); grid.append(section); }
     } else names.forEach((name) => { const control = makeControl(name); if (control) grid.append(control); });
     if (active === "direction" && ["keyframe_joint_native", "latent_go_ahead"].includes(String(mode))) {
@@ -2806,6 +2883,7 @@ function mount(node) {
     const assetIssues = selectedH3AssetCompatibility(node, mode);
     const values = [["Sampling recipe", samplingRecipeLabel(node)], ["Generation authority", node.properties?.iamccs_settings_master ? "SETTINGS PRO" : "SHOTBOARD / INITIAL"], ["Duration authority", node.properties?.iamccs_settings_master ? `SETTINGS PRO · ${widget(node,"duration_seconds")?.value ?? "—"} s · synced to Shotboard` : `SHOTBOARD · ${widget(node,"duration_seconds")?.value ?? "—"} s`], ["Mode", `${mode} · Settings PRO when connected`], ["Editorial authority", "SHOTBOARD · prompts, guides, media, timeline and audio"], ["Asset compatibility", assetIssues.some(([kind]) => kind === "error") ? "INCOMPATIBLE" : assetIssues.length ? "REVIEW" : "COMPATIBLE"], ["VRAM preset", friendly(widget(node, "performance_profile")?.value)], ["Memory contract", `${widget(node,"motion_context_window_frames")?.value ?? "—"} frames · ${widget(node,"h3_exact_chunk_rows")?.value ?? "—"} rows`], ["Guide window", String(mode) === "longvid_guides" ? selectedGuideWindowStrategy(node) : "N/A"], ["Extension engine", String(mode) === "fl2va_extended_av" ? `${friendly(widget(node,"extended_av_profile")?.value)} · MASKED + EXACT · TRIM PINNED HEAD` : "OFF"], ["Sampling / legacy profile", friendly(widget(node, "acceleration")?.value)], ["Speed adapter (Turbo / FastH3 / SLA)", String(widget(node, "turbo_mode")?.value || "off") === "off" && !["fasth3_dense_6step", "h3_sla"].includes(String(widget(node, "acceleration")?.value || "")) ? "OFF" : (widget(node, "turbo_lora_name")?.value || "MISSING")], ["PDD LoRA", widget(node,"pdd_lora_name")?.value || "OFF"], ["Fused model", widget(node, "fused_turbo_model_name")?.value || "OFF"], ["Effective sampling", `${widget(node, "steps")?.value ?? "—"} steps · ${widget(node, "sampler_name")?.value ?? "—"} · ${widget(node, "scheduler")?.value ?? "—"}`], ["Canvas", `${widget(node, "width")?.value ?? "—"} × ${widget(node, "height")?.value ?? "—"}`], ["ControlNet", widget(node, "h3_controlnet_name")?.value || "OFF"], ["Delivery", widget(node, "upscale_enabled")?.value ? widget(node, "upscale_mode")?.value : "NATIVE"], ["Video Editor", Boolean(widget(node,"h3_editor_enabled")?.value) ? "ON · post-master" : "OFF · direct joined master"]];
     values.splice(1,0,["Attention & memory",attentionLabel(node)]);
+    if (widget(node,"h3_open_refine_enabled")?.value) values.find(([label]) => label === "Delivery")[1] = `OPEN-H3 REFINEMENT · ${widget(node,"h3_open_refine_scale")?.value ?? 2}× · ${widget(node,"h3_open_refine_sigma_preset")?.value || "gentle_3step"}`;
     values.push(["VEDA", widget(node,"h3_veda_enabled")?.value ? `ON · ${widget(node,"h3_veda_predictor")?.value || "auto"}` : "OFF"]);
     const list = q(".h3p-truth-list"); list.replaceChildren(); values.forEach(([label, value]) => { const row = document.createElement("div"); row.className = "h3p-truth-row"; const caption = document.createElement("span"), content = document.createElement("b"); caption.textContent = label; content.textContent = String(value ?? "—"); row.append(caption, content); list.append(row); });
     const issueList = warnings(mode), health = q(".h3p-health"); health.className = `h3p-health ${issueList.some(([kind]) => kind === "error") ? "error" : issueList.some(([kind]) => kind === "warn") ? "warn" : ""}`; health.innerHTML = issueList.map(([, message]) => `• ${message}`).join("<br>");
diff --git a/web/iamccs_minimax_h3_shotboard_ui.js b/web/iamccs_minimax_h3_shotboard_ui.js
index cf975cc..fc4d233 100644
--- a/web/iamccs_minimax_h3_shotboard_ui.js
+++ b/web/iamccs_minimax_h3_shotboard_ui.js
@@ -12773,6 +12773,7 @@ function renderShotboardV3(node) {
     addWidgetBoolSetting("Enable second H3 LoRA", "secondary_lora_enabled");
     addSelectSetting("Second LoRA file", "secondary_lora_name", Array.isArray(secondaryLoraValues) && secondaryLoraValues.length ? secondaryLoraValues : [""]);
     addSetting("Second LoRA strength", "secondary_lora_strength", "0.05", "-2");
+    addWidgetBoolSetting("Second LoRA: from segment 2", "secondary_lora_continuation_only");
     const pddLoraValues = getWidget(node, "pdd_lora_name")?.options?.values;
     addSelectSetting("PDD acceleration LoRA", "pdd_lora_name", Array.isArray(pddLoraValues) && pddLoraValues.length ? pddLoraValues : [""]);
     addSetting("PDD strength / trained 1.0", "pdd_strength", "0.05", "0");
@@ -20902,7 +20903,7 @@ const H3_SETTINGS_UI_GROUPS = [
             "fused_turbo_model_name", "fused_turbo_sigma_preset",
             "h3_exact_profile", "h3_clipproj_profile", "h3_clipproj_load_mode",
             "h3_exact_chunk_rows", "h3_exact_precision_mode", "h3_exact_qkv_streaming", "h3_exact_attention_memory",
-            "secondary_lora_enabled", "secondary_lora_name", "secondary_lora_strength",
+            "secondary_lora_enabled", "secondary_lora_name", "secondary_lora_strength", "secondary_lora_continuation_only",
             "seed", "seed_stride", "sampler_name", "scheduler", "denoise", "shift_video", "shift_audio",
             "ref_image_size", "sol_conditioning", "spectrum_profile", "vram_clean_before_decode", "rife_mode",
         ],
@@ -20981,7 +20982,7 @@ const H3_SETTINGS_FULL_UI_GROUPS = [
         note: "Primary/secondary H3 LoRA and execution acceleration. Every visible box remains editable truth.",
         names: [
             "turbo_mode", "turbo_lora_name", "turbo_strength", "turbo_sampler_mode",
-            "secondary_lora_enabled", "secondary_lora_name", "secondary_lora_strength",
+            "secondary_lora_enabled", "secondary_lora_name", "secondary_lora_strength", "secondary_lora_continuation_only",
             "acceleration", "ref_image_size", "sol_conditioning", "spectrum_profile", "vram_clean_before_decode", "rife_mode",
             "fused_turbo_model_name", "fused_turbo_sigma_preset",
         ],
@@ -21087,7 +21088,7 @@ const H3_SETTINGS_PRO_UI_GROUPS = [
     {
         id: "speed", label: "4 · H3 SPEED", title: "STAGE A · NATIVE H3 ACCELERATION",
         note: "Speeds up only the native H3 sample. It does not select an upscale or add a delivery stage. PDD and LightX2V Turbo are separate routes.",
-        names: ["acceleration", "pdd_lora_name", "pdd_strength", "turbo_mode", "turbo_lora_name", "turbo_strength", "turbo_sampler_mode", "fused_turbo_model_name", "fused_turbo_sigma_preset", "secondary_lora_enabled", "secondary_lora_name", "secondary_lora_strength", "ref_image_size", "sol_conditioning", "spectrum_profile", "vram_clean_before_decode", "rife_mode", "h3_exact_profile", "h3_clipproj_profile", "h3_clipproj_load_mode", "h3_exact_chunk_rows", "h3_exact_precision_mode", "h3_exact_qkv_streaming", "h3_exact_attention_memory"],
+        names: ["acceleration", "pdd_lora_name", "pdd_strength", "turbo_mode", "turbo_lora_name", "turbo_strength", "turbo_sampler_mode", "fused_turbo_model_name", "fused_turbo_sigma_preset", "secondary_lora_enabled", "secondary_lora_name", "secondary_lora_strength", "secondary_lora_continuation_only", "ref_image_size", "sol_conditioning", "spectrum_profile", "vram_clean_before_decode", "rife_mode", "h3_exact_profile", "h3_clipproj_profile", "h3_clipproj_load_mode", "h3_exact_chunk_rows", "h3_exact_precision_mode", "h3_exact_qkv_streaming", "h3_exact_attention_memory"],
     },
     {
         id: "direction", label: "5 · DIRECT", title: "MODE-SPECIFIC CONTRACT",
@@ -21118,7 +21119,7 @@ const H3_SETTINGS_TAB_GROUPS = [...H3_SETTINGS_PRO_UI_GROUPS, ...H3_SETTINGS_FUL
 const H3_SETTINGS_ADVANCED_FIELDS = new Set([
     "reference_resize_megapixels", "reference_resize_filter", "h3_exact_profile", "h3_clipproj_load_mode",
     "h3_exact_chunk_rows", "h3_exact_precision_mode", "h3_exact_qkv_streaming", "h3_exact_attention_memory",
-    "turbo_sampler_mode", "secondary_lora_enabled", "secondary_lora_name", "secondary_lora_strength",
+    "turbo_sampler_mode", "secondary_lora_enabled", "secondary_lora_name", "secondary_lora_strength", "secondary_lora_continuation_only",
     "seed_stride", "sampler_name", "scheduler", "denoise", "shift_video", "shift_audio", "ref_image_size",
     "sol_conditioning", "spectrum_profile", "vram_clean_before_decode", "rife_mode",
     "upscale_prompt", "upscale_sage", "upscale_seed_offset", "wan_upscale_denoise", "ltx_seam_safe",
@@ -21206,6 +21207,7 @@ function h3SettingsUiLabel(name) {
         turbo_strength: "Turbo strength", turbo_sampler_mode: "Turbo sampler", reference_resize_policy: "Fit policy",
         secondary_lora_enabled: "Enable creative / projection H3 LoRA", secondary_lora_name: "Creative / projection H3 LoRA",
         secondary_lora_strength: "Creative / projection strength",
+        secondary_lora_continuation_only: "Second LoRA: from segment 2",
         pdd_lora_name: "PDD acceleration LoRA", pdd_strength: "PDD strength",
         h3_controlnet_enabled: "Enable H3 Fun ControlNet", h3_controlnet_name: "Fun ControlNet model",
         h3_controlnet_kind: "Control kind / preprocessor", h3_controlnet_strength: "Control strength",
diff --git a/web/iamccs_prompter_ui.js b/web/iamccs_prompter_ui.js
index cf1ce5e..94de2b9 100644
--- a/web/iamccs_prompter_ui.js
+++ b/web/iamccs_prompter_ui.js
@@ -2115,6 +2115,7 @@ function mountPrompter(node) {
                     prompt:[shot.local_prompt,shot.h3_transition_prompt].filter(Boolean).join("\n")}));
                 project.injection_target = "global";
                 aiApiKey.value = ""; commit(); renderSections(); renderPreview();
+                workspace?.showReview();
                 aiStatus.className = "iamccs-pr-ai-status ok";
                 aiStatus.textContent = `Global + ${project.local_prompts.length} local prompts ready. Review, then INJECT → SHOTBOARD.`;
             } catch (error) { aiStatus.className = "iamccs-pr-ai-status error"; aiStatus.textContent = error.message; }
@@ -2503,11 +2504,9 @@ function mountPrompter(node) {
                 ? "Qwen CLIP: loading the encoder, reading references and writing the H3 prompt. The first REQUEST includes model loading; keep this window open."
                 : `Sending ${targetKeys.join(", ")} to ${aiProvider.options[aiProvider.selectedIndex]?.text || aiProvider.value}.`;
             const imagePayload = await buildAIImagePayload();
-            // A new image request is authoritative. Never feed previous generated
-            // image fields back as rough text, otherwise local models tend to
-            // concatenate the old prompt with the new refinement.
-            const rewriteInputSections = isImageRequest || isSwapCharRequest
-                ? Object.fromEntries(Object.keys(allSections).map((key) => [key, ""]))
+            // REQUEST replaces selected drafts; unselected fields remain context.
+            const rewriteInputSections = narrativeRequest !== null
+                ? Object.fromEntries(Object.entries(allSections).map(([key, value]) => [key, targetKeys.includes(key) ? "" : value]))
                 : allSections;
             const response = await fetchAI("/iamccs/prompter/rewrite", {
                 method: "POST",
@@ -2520,6 +2519,7 @@ function mountPrompter(node) {
                     task_mode: project.task_mode,
                     sections: rewriteInputSections,
                     target_keys: targetKeys,
+                    request_text: narrativeRequest,
                     user_direction: project.omni_preset && project.task_mode === "ref2va" ? `${omniRequestDirection(project)}\n${direction}` : project.task_mode === "reference_image"
                         ? `${project.image_preset === "reference_sheet" ? "REFERENCE SHEET: one combined canvas containing every requested character and prop." : "SINGLE STATIC IMAGE."}\n${direction}` : direction,
                     vision_model: aiVisionModel.value.trim(),
@@ -2589,6 +2589,7 @@ function mountPrompter(node) {
             renderSections();
             renderPreview();
             commit();
+            if (narrativeRequest !== null) workspace?.showReview();
             aiStatus.className = "iamccs-pr-ai-status ok";
             const visualCount = Number(data.report?.visual_references?.length || 0);
             aiStatus.textContent = isExtendedEvolvingRequest