diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_reference_preview_js_test.mjs b/ComfyUI-MiniMaxH3-Context-Loop/tests/_reference_preview_js_test.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..db401c1bc9e8915f440d478737f07ab4e8fe1bd6
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_reference_preview_js_test.mjs
@@ -0,0 +1,781 @@
+import assert from "node:assert/strict";
+import {
+    availableReferenceRecords,
+    collectScheduleNodes,
+    collectSemanticAnchorNodes,
+    collectTaggedNodes,
+    convertTaggedPictureReference,
+    coreReferenceRecords,
+    findProjectAssetManager,
+    findScheduledRef2VA,
+    findTaggedRef2VA,
+    imageToVideoReferenceRecords,
+    referencePreviewRecords,
+    referenceIsActive,
+    referenceReplacementToken,
+    replacePromptReferenceOccurrence,
+    scheduledReferenceRecords,
+    taggedReferenceRecords,
+    taggedPictureReferenceMode,
+    taggedPictureReferenceToken,
+} from "../web/h3_reference_preview_core.mjs";
+
+assert.equal(taggedPictureReferenceToken("@hero", "native"), "@hero");
+assert.equal(taggedPictureReferenceToken("hero", "semantic"), "#hero");
+assert.equal(
+    taggedPictureReferenceToken("hero", "semantic", 2.5),
+    "#hero[2.50s]",
+);
+assert.equal(taggedPictureReferenceMode("Use @hero.", "hero"), "native");
+assert.equal(taggedPictureReferenceMode("Use @Hero.", "hero"), "unused");
+assert.equal(taggedPictureReferenceMode("Use #hero.", "hero"), "semantic");
+assert.equal(taggedPictureReferenceMode("Use #Hero.", "hero"), "unused");
+assert.equal(
+    taggedPictureReferenceMode("Use #hero[2.50s].", "hero"),
+    "semantic",
+);
+assert.equal(
+    taggedPictureReferenceMode("Use @hero then #hero[2.50s].", "hero"),
+    "mixed",
+);
+assert.equal(
+    convertTaggedPictureReference(
+        "Use @hero, but keep @heroine and mail x@hero.",
+        "hero", "semantic", 1.25,
+    ),
+    "Use #hero[1.25s], but keep @heroine and mail x@hero.",
+);
+assert.equal(
+    convertTaggedPictureReference("Use @hero.", "hero", "semantic"),
+    "Use #hero.",
+);
+assert.equal(
+    convertTaggedPictureReference("Keep @Hero unchanged.", "hero", "semantic"),
+    "Keep @Hero unchanged.",
+);
+assert.equal(
+    convertTaggedPictureReference(
+        "Use #hero, #hero[0.00s], then #hero[2.5].", "hero", "native",
+    ),
+    "Use @hero, @hero, then @hero.",
+);
+const heroRecord = {
+    kind: "picture", tag: "hero", token: "@hero", nativeToken: "@hero",
+};
+const alternateRecord = {
+    kind: "picture", tag: "alternate", token: "@alternate",
+    nativeToken: "@alternate",
+};
+assert.equal(
+    referenceReplacementToken(alternateRecord, "semantic", 3.125),
+    "#alternate[3.13s]",
+);
+assert.equal(
+    replacePromptReferenceOccurrence(
+        "Use @hero, then @hero.", 16, 21, alternateRecord, "native",
+    ),
+    "Use @hero, then @alternate.",
+);
+assert.equal(
+    replacePromptReferenceOccurrence(
+        "Use #hero[1.00s] now.", 4, 16, heroRecord, "semantic", 2.5,
+    ),
+    "Use #hero[2.50s] now.",
+);
+assert.equal(
+    replacePromptReferenceOccurrence(
+        "Use @hero.", -1, 9, alternateRecord, "native",
+    ),
+    "Use @hero.",
+);
+assert.equal(
+    referenceReplacementToken(
+        {kind: "audio", tag: "voice", token: "@voice"}, "semantic", 1,
+    ),
+    "",
+);
+assert.equal(
+    referenceReplacementToken({
+        kind: "picture", tag: "only", token: "#only[0.00s]",
+        nativeToken: null, semanticOnly: true,
+    }, "native"),
+    "",
+);
+
+function makeNode(id, type, widgets = {}) {
+    return {
+        id,
+        type,
+        title: type,
+        widgets: Object.entries(widgets).map(([name, value]) => ({name, value})),
+        inputs: [],
+        outputs: [{name: "output", links: []}],
+    };
+}
+
+const graph = {
+    _nodes: [],
+    links: {},
+    getNodeById(id) { return this._nodes.find((node) => node.id === id); },
+};
+let nextLink = 1;
+function add(node) {
+    node.graph = graph;
+    graph._nodes.push(node);
+    return node;
+}
+function connect(source, target, targetName, sourceSlot = 0) {
+    const id = nextLink++;
+    while (source.outputs.length <= sourceSlot) {
+        source.outputs.push({name: `output_${source.outputs.length}`, links: []});
+    }
+    source.outputs[sourceSlot].links.push(id);
+    target.inputs.push({name: targetName, link: id});
+    graph.links[id] = {
+        origin_id: source.id,
+        origin_slot: sourceSlot,
+        target_id: target.id,
+        target_slot: target.inputs.length - 1,
+    };
+}
+
+function connectExistingInput(source, target, targetName, sourceSlot = 0) {
+    const targetSlot = target.inputs.findIndex(
+        (input) => input.name === targetName,
+    );
+    assert.notEqual(targetSlot, -1);
+    const id = nextLink++;
+    source.outputs[sourceSlot].links.push(id);
+    target.inputs[targetSlot].link = id;
+    graph.links[id] = {
+        origin_id: source.id,
+        origin_slot: sourceSlot,
+        target_id: target.id,
+        target_slot: targetSlot,
+    };
+}
+
+function makeSubgraph(host, inputs = [], outputs = []) {
+    const subgraph = {
+        _nodes: [],
+        links: {},
+        inputs: inputs.map((name) => ({name, linkIds: []})),
+        outputs: outputs.map((name) => ({name, linkIds: []})),
+        rootGraph: graph,
+        getNodeById(id) {
+            return this._nodes.find((node) => node.id === id);
+        },
+    };
+    host.subgraph = subgraph;
+    host.inputs = inputs.map((name) => ({name, link: null}));
+    host.outputs = outputs.map((name) => ({name, links: []}));
+    return subgraph;
+}
+
+function addInside(subgraph, node) {
+    node.graph = subgraph;
+    subgraph._nodes.push(node);
+    return node;
+}
+
+function connectInside(source, target, targetName, sourceSlot = 0) {
+    const owner = source.graph;
+    const id = nextLink++;
+    while (source.outputs.length <= sourceSlot) {
+        source.outputs.push({name: `output_${source.outputs.length}`, links: []});
+    }
+    source.outputs[sourceSlot].links.push(id);
+    target.inputs.push({name: targetName, link: id});
+    owner.links[id] = {
+        origin_id: source.id,
+        origin_slot: sourceSlot,
+        target_id: target.id,
+        target_slot: target.inputs.length - 1,
+    };
+}
+
+function connectSubgraphInput(subgraph, inputSlot, target, targetName) {
+    const id = nextLink++;
+    target.inputs.push({name: targetName, link: id});
+    subgraph.inputs[inputSlot].linkIds.push(id);
+    subgraph.links[id] = {
+        origin_id: -10,
+        origin_slot: inputSlot,
+        target_id: target.id,
+        target_slot: target.inputs.length - 1,
+    };
+}
+
+function connectSubgraphOutput(subgraph, source, sourceSlot, outputSlot) {
+    const id = nextLink++;
+    source.outputs[sourceSlot].links.push(id);
+    subgraph.outputs[outputSlot].linkIds.push(id);
+    subgraph.links[id] = {
+        origin_id: source.id,
+        origin_slot: sourceSlot,
+        target_id: -20,
+        target_slot: outputSlot,
+    };
+}
+
+const editor = add(makeNode(1, "MiniMaxH3ChainScenePromptEditor"));
+const relay = add(makeNode(2, "MiniMaxH3ChainCurrent"));
+const wrapper = add(makeNode(3, "MiniMaxH3ScheduledReferenceToVideo"));
+const firstImage = add(makeNode(4, "LoadImage", {image: "first.png"}));
+const secondImage = add(makeNode(5, "LoadImage", {image: "second.png"}));
+const audioFile = add(makeNode(6, "LoadAudio", {audio: "score.wav"}));
+const first = add(makeNode(7, "MiniMaxH3ScheduledPictureReference", {
+    tag: "picture_1", scenes: "1",
+}));
+const second = add(makeNode(8, "MiniMaxH3ScheduledPictureReference", {
+    tag: "picture_2", scenes: "",
+}));
+const audio = add(makeNode(9, "MiniMaxH3ScheduledAudioReference", {
+    tag: "score", scenes: "all",
+}));
+
+connect(editor, relay, "state");
+connect(relay, wrapper, "prompt");
+connect(firstImage, first, "image");
+connect(first, second, "previous");
+connect(secondImage, second, "image");
+connect(second, audio, "previous");
+connect(audioFile, audio, "audio");
+connect(audio, wrapper, "reference_schedule");
+
+assert.equal(findScheduledRef2VA(editor), wrapper);
+assert.deepEqual(collectScheduleNodes(wrapper), [first, second, audio]);
+assert.equal(referenceIsActive("1,3:5", 4), true);
+assert.equal(referenceIsActive("1,3:5", 2), false);
+
+const sceneOne = scheduledReferenceRecords(editor, 1).records;
+assert.deepEqual(sceneOne.map(({tag, label, active}) => ({tag, label, active})), [
+    {tag: "picture_1", label: "<Picture 1>", active: true},
+    {tag: "picture_2", label: "<Picture 2>", active: true},
+    {tag: "score", label: "<Audio 1>", active: true},
+]);
+const sceneTwo = scheduledReferenceRecords(editor, 2).records;
+assert.deepEqual(sceneTwo.map(({tag, label, active}) => ({tag, label, active})), [
+    {tag: "picture_1", label: null, active: false},
+    {tag: "picture_2", label: "<Picture 1>", active: true},
+    {tag: "score", label: "<Audio 1>", active: true},
+]);
+assert.deepEqual(
+    availableReferenceRecords(editor, 2).records.map(({tag}) => tag),
+    ["picture_2", "score"],
+);
+assert.deepEqual(
+    availableReferenceRecords(editor, 2, {includeInactive: true})
+        .records.map(({tag}) => tag),
+    ["picture_1", "picture_2", "score"],
+);
+
+const taggedEditor = add(makeNode(30, "MiniMaxH3ChainScenePromptEditor"));
+const taggedRelay = add(makeNode(31, "MiniMaxH3ChainCurrent"));
+const taggedWrapper = add(makeNode(32, "MiniMaxH3TaggedReferenceToVideo"));
+const taggedPromptSet = add(makeNode(64, "SetNode", {
+    Constant: "tagged_prompt",
+}));
+const taggedPromptGet = add(makeNode(65, "GetNode", {
+    Constant: "tagged_prompt",
+}));
+const taggedReferenceReroute = add(makeNode(66, "Reroute"));
+const taggedReferenceSet = add(makeNode(67, "SetNode", {
+    Constant: "tagged_references",
+}));
+const taggedReferenceGet = add(makeNode(68, "GetNode", {
+    Constant: "tagged_references",
+}));
+const taggedImageA = add(makeNode(33, "LoadImage", {image: "face.png"}));
+const taggedImageB = add(makeNode(34, "LoadImage", {image: "look.png"}));
+const taggedVideoFile = add(makeNode(35, "LoadVideo", {video: "motion.mp4"}));
+const taggedVideoAudio = add(makeNode(36, "LoadAudio", {audio: "motion.wav"}));
+const taggedPictureA = add(makeNode(37, "MiniMaxH3TaggedPictureReference", {
+    tag: "hero_face",
+}));
+const taggedPictureTagText = add(makeNode(169, "PrimitiveNode", {
+    value: "connected_face",
+}));
+taggedPictureTagText.outputs[0].name = "STRING";
+const taggedPictureTagSet = add(makeNode(170, "SetNode", {
+    Constant: "picture_tag_text",
+}));
+const taggedPictureTagGet = add(makeNode(171, "GetNode", {
+    Constant: "picture_tag_text",
+}));
+const taggedPictureB = add(makeNode(38, "MiniMaxH3TaggedPictureReference", {
+    tag: "hero_look",
+}));
+const taggedVideo = add(makeNode(39, "MiniMaxH3TaggedVideoReference", {
+    tag: "performance", audio_tag: "performance_audio",
+}));
+const taggedMotionVideo = add(makeNode(60, "LoadVideo", {
+    video: "motion-role.mp4",
+}));
+const taggedMotion = add(makeNode(61, "MiniMaxH3TaggedMotionReference", {
+    tag: "motion", target_subject: "<Subject 1> and <Subject 2>",
+}));
+const taggedLazyLoader = add(makeNode(63, "MiniMaxH3LazyMotionAVLoader", {
+    video_path: "/media/lazy-motion.mkv",
+}));
+const taggedLazyMotion = add(makeNode(
+    62, "MiniMaxH3TaggedMotionReferencePath", {
+        video_path: "", tag: "lazy_motion",
+        target_subject: "<Subject 1>", use_embedded_audio: true,
+        audio_tag: "lazy_motion_audio",
+    },
+));
+connect(taggedEditor, taggedPromptSet, "*");
+connect(taggedPromptGet, taggedRelay, "state");
+connect(taggedRelay, taggedWrapper, "prompt");
+connect(taggedImageA, taggedPictureA, "image");
+connect(taggedPictureTagText, taggedPictureTagSet, "*");
+connect(taggedPictureTagGet, taggedPictureA, "tag");
+connect(taggedPictureA, taggedPictureB, "previous");
+connect(taggedImageB, taggedPictureB, "image");
+connect(taggedPictureB, taggedVideo, "previous");
+connect(taggedVideoFile, taggedVideo, "video");
+connect(taggedVideoAudio, taggedVideo, "audio");
+connect(taggedVideo, taggedMotion, "previous");
+connect(taggedMotionVideo, taggedMotion, "video");
+connect(taggedMotion, taggedLazyMotion, "previous");
+connect(taggedLazyLoader, taggedLazyMotion, "source_video");
+connect(taggedLazyMotion, taggedReferenceReroute, "*");
+connect(taggedReferenceReroute, taggedReferenceSet, "*");
+connect(taggedReferenceGet, taggedWrapper, "references");
+
+assert.equal(findTaggedRef2VA(taggedEditor), taggedWrapper);
+assert.deepEqual(
+    collectTaggedNodes(taggedWrapper),
+    [taggedPictureA, taggedPictureB, taggedVideo, taggedMotion,
+        taggedLazyMotion],
+);
+const promptRefs = taggedReferenceRecords(
+    taggedEditor,
+    "<Subject 1> and <Subject 2> use @hero_look, " +
+    "@performance_audio, @motion, and @lazy_motion.",
+).records;
+assert.deepEqual(
+    promptRefs.map(({tag, label, active, sourceLabel}) => ({
+        tag, label, active, sourceLabel,
+    })),
+    [
+        {tag: "connected_face", label: null, active: false,
+            sourceLabel: undefined},
+        {tag: "hero_look", label: "<Picture 1>", active: true,
+            sourceLabel: undefined},
+        {tag: "performance", label: "<Video 1>", active: true,
+            sourceLabel: "<Video 1>"},
+        {tag: "motion", label: "<Subject 3>", active: true,
+            sourceLabel: "<Video 2>"},
+        {tag: "lazy_motion", label: "<Subject 4>", active: true,
+            sourceLabel: "<Video 3>"},
+        {tag: "performance_audio", label: "<Audio 1>", active: true,
+            sourceLabel: undefined},
+        {tag: "lazy_motion_audio", label: "<Audio 2>", active: true,
+            sourceLabel: undefined},
+    ],
+);
+assert.equal(
+    promptRefs.find(({tag}) => tag === "lazy_motion").source,
+    taggedLazyLoader,
+);
+assert.equal(
+    promptRefs.find(({tag}) => tag === "lazy_motion_audio").source,
+    taggedLazyLoader,
+);
+const semanticPromptRefs = taggedReferenceRecords(
+    taggedEditor, "Use #connected_face[1.50s].",
+).records;
+const semanticHero = semanticPromptRefs.find(
+    ({tag}) => tag === "connected_face",
+);
+assert.equal(semanticHero.active, true);
+assert.equal(semanticHero.nativeActive, false);
+assert.equal(semanticHero.semanticActive, true);
+assert.equal(semanticHero.label, "<Video 1>");
+assert.equal(semanticHero.nativeToken, "@connected_face");
+assert.equal(semanticHero.semanticToken, "#connected_face");
+assert.equal(semanticHero.supportsSemantic, true);
+const bareSemanticHero = taggedReferenceRecords(
+    taggedEditor, "Use #connected_face as an untimed visual.",
+).records.find(({tag}) => tag === "connected_face");
+assert.equal(bareSemanticHero.active, true);
+assert.equal(bareSemanticHero.label, "<Picture 1>");
+assert.equal(bareSemanticHero.semanticLabel, "<Picture 1>");
+assert.equal(referencePreviewRecords(
+    taggedEditor, 2, {prompt: "Use @hero_look."}).mode, "tagged");
+assert.deepEqual(
+    availableReferenceRecords(taggedEditor, 2, {
+        prompt: "Use @hero_look.",
+    }).records.map(({tag}) => tag),
+    ["hero_look"],
+);
+assert.deepEqual(
+    availableReferenceRecords(taggedEditor, 2, {
+        prompt: "Use @hero_look.", includeInactive: true,
+    }).records.map(({tag}) => tag),
+    ["connected_face", "hero_look", "performance", "motion", "lazy_motion",
+        "performance_audio", "lazy_motion_audio"],
+);
+
+const semanticEditor = add(makeNode(80, "MiniMaxH3ChainScenePromptEditor"));
+const semanticRelay = add(makeNode(81, "MiniMaxH3ChainCurrent"));
+const semanticWrapper = add(makeNode(82, "MiniMaxH3TaggedReferenceToVideo"));
+const nativeImage = add(makeNode(83, "LoadImage", {image: "native.png"}));
+const nativePicture = add(makeNode(84, "MiniMaxH3TaggedPictureReference", {
+    tag: "native",
+}));
+const semanticImageA = add(makeNode(85, "LoadImage", {image: "beat-a.png"}));
+const semanticImageB = add(makeNode(86, "LoadImage", {image: "beat-b.png"}));
+const semanticAnchorA = add(makeNode(
+    87, "MiniMaxH3SemanticPictureAnchor", {tag: "beat_a"},
+));
+const semanticAnchorB = add(makeNode(
+    88, "MiniMaxH3SemanticPictureAnchor", {tag: "beat_b"},
+));
+const semanticBundle = add(makeNode(
+    89, "MiniMaxH3SemanticAnchorBundle", {
+        semantic_anchor_size: "768",
+        semantic_anchor_mode: "picture_storyboard",
+    },
+));
+connect(semanticEditor, semanticRelay, "state");
+connect(semanticRelay, semanticWrapper, "prompt");
+connect(nativeImage, nativePicture, "image");
+connect(semanticImageA, semanticAnchorA, "image");
+connect(semanticAnchorA, semanticAnchorB, "previous");
+connect(semanticImageB, semanticAnchorB, "image");
+connect(semanticAnchorB, semanticBundle, "anchors");
+connect(nativePicture, semanticBundle, "references");
+connect(semanticBundle, semanticWrapper, "references", 0);
+
+assert.deepEqual(collectTaggedNodes(semanticWrapper), [nativePicture]);
+assert.deepEqual(
+    collectSemanticAnchorNodes(semanticWrapper).nodes,
+    [semanticAnchorA, semanticAnchorB],
+);
+const separateRecords = taggedReferenceRecords(
+    semanticEditor, "Use @native and #beat_b[2.50s].",
+).records;
+assert.deepEqual(
+    separateRecords.map((item) => ({
+        tag: item.tag,
+        token: item.token,
+        label: item.label,
+        active: item.active,
+        semanticOnly: Boolean(item.semanticOnly),
+        supportsSemantic: item.supportsSemantic,
+    })),
+    [
+        {tag: "native", token: "@native", label: "<Picture 1>",
+            active: true, semanticOnly: false, supportsSemantic: true},
+        {tag: "beat_a", token: "#beat_a", label: null,
+            active: false, semanticOnly: true, supportsSemantic: false},
+        {tag: "beat_b", token: "#beat_b", label: "<Picture 2>",
+            active: true, semanticOnly: true, supportsSemantic: false},
+    ],
+);
+
+// Packing the semantic registry into a ComfyUI subgraph is presentation-only.
+// Discovery must cross the output rail to find the bundle and the input rail
+// to resolve an externally connected image used by an internal anchor.
+const nestedEditor = add(makeNode(180, "MiniMaxH3ChainScenePromptEditor"));
+const nestedRelay = add(makeNode(181, "MiniMaxH3ChainCurrent"));
+const nestedWrapper = add(makeNode(182, "MiniMaxH3TaggedReferenceToVideo"));
+const nestedHost = add(makeNode(183, "semantic-registry-subgraph"));
+const nestedImage = add(makeNode(184, "LoadImage", {image: "nested.png"}));
+const nestedGraph = makeSubgraph(
+    nestedHost, ["semantic_image"], ["references"],
+);
+const nestedAnchor = addInside(nestedGraph, makeNode(
+    185, "MiniMaxH3SemanticPictureAnchor", {tag: "nested_beat"},
+));
+const nestedBundle = addInside(nestedGraph, makeNode(
+    186, "MiniMaxH3SemanticAnchorBundle", {
+        semantic_anchor_size: "768",
+        semantic_anchor_mode: "timestamped_video",
+    },
+));
+connect(nestedEditor, nestedRelay, "state");
+connect(nestedRelay, nestedWrapper, "prompt");
+connectExistingInput(nestedImage, nestedHost, "semantic_image");
+connectSubgraphInput(nestedGraph, 0, nestedAnchor, "image");
+connectInside(nestedAnchor, nestedBundle, "anchors");
+connectSubgraphOutput(nestedGraph, nestedBundle, 0, 0);
+connect(nestedHost, nestedWrapper, "references");
+
+assert.equal(findTaggedRef2VA(nestedEditor), nestedWrapper);
+assert.equal(collectSemanticAnchorNodes(nestedWrapper).bundle, nestedBundle);
+assert.deepEqual(
+    collectSemanticAnchorNodes(nestedWrapper).nodes,
+    [nestedAnchor],
+);
+const nestedRecords = taggedReferenceRecords(
+    nestedEditor, "Use #nested_beat[1.00s].",
+).records;
+assert.deepEqual(
+    nestedRecords.map(({tag, active, source}) => ({
+        tag, active, source: source.id,
+    })),
+    [{tag: "nested_beat", active: true, source: nestedImage.id}],
+);
+
+// The 0.5 Source Timeline motion node can be the final link in a tagged chain.
+// Discovery must traverse through it or every earlier picture reference also
+// disappears from both prompt editors.
+const timelineEditor = add(makeNode(70, "MiniMaxH3ChainScenePromptEditor"));
+const timelineRelay = add(makeNode(71, "MiniMaxH3ChainCurrent"));
+const timelineWrapper = add(makeNode(72, "MiniMaxH3TaggedReferenceToVideo"));
+const timelineCharacterImage = add(makeNode(73, "LoadImage", {
+    image: "timeline-character.png",
+}));
+const timelineKeyframeImage = add(makeNode(74, "LoadImage", {
+    image: "timeline-keyframe.png",
+}));
+const timelineCharacter = add(makeNode(
+    75, "MiniMaxH3TaggedPictureReference", {tag: "character"},
+));
+const timelineKeyframe = add(makeNode(
+    76, "MiniMaxH3TaggedPictureReference", {tag: "keyframe"},
+));
+const sourceTimeline = add(makeNode(77, "MiniMaxH3SourceTimeline", {
+    video_path: "/media/source-motion.mp4",
+}));
+const timelineMotion = add(makeNode(
+    78, "MiniMaxH3TaggedMotionReferenceTimeline", {
+        tag: "motion", paired_audio: "embedded", audio_tag: "audio_1",
+    },
+));
+connect(timelineEditor, timelineRelay, "state");
+connect(timelineRelay, timelineWrapper, "prompt");
+connect(timelineCharacterImage, timelineCharacter, "image");
+connect(timelineCharacter, timelineKeyframe, "previous");
+connect(timelineKeyframeImage, timelineKeyframe, "image");
+connect(timelineKeyframe, timelineMotion, "previous");
+connect(sourceTimeline, timelineMotion, "source_timeline");
+connect(timelineMotion, timelineWrapper, "references");
+
+assert.deepEqual(
+    collectTaggedNodes(timelineWrapper),
+    [timelineCharacter, timelineKeyframe, timelineMotion],
+);
+const timelineRecords = taggedReferenceRecords(
+    timelineEditor, "Use @character, @keyframe, @motion, and @audio_1.",
+).records;
+assert.deepEqual(
+    timelineRecords.map(({tag, label, active, source}) => ({
+        tag, label, active, source: source.id,
+    })),
+    [
+        {tag: "character", label: "<Picture 1>", active: true,
+            source: timelineCharacterImage.id},
+        {tag: "keyframe", label: "<Picture 2>", active: true,
+            source: timelineKeyframeImage.id},
+        {tag: "motion", label: "<Subject 1>", active: true,
+            source: sourceTimeline.id},
+        {tag: "audio_1", label: "<Audio 1>", active: true,
+            source: sourceTimeline.id},
+    ],
+);
+
+const coreEditor = add(makeNode(10, "MiniMaxH3ChainScenePromptEditor"));
+const coreRelay = add(makeNode(11, "MiniMaxH3ChainCurrent"));
+const core = add(makeNode(12, "MiniMaxH3ReferenceToVideo"));
+const coreImage = add(makeNode(13, "LoadImage", {image: "core.png"}));
+const coreAudio = add(makeNode(14, "LoadAudio", {audio: "core.wav"}));
+connect(coreEditor, coreRelay, "state");
+connect(coreRelay, core, "prompt");
+connect(coreImage, core, "ref_images.ref_image_0");
+connect(coreAudio, core, "ref_audios.ref_audio_0");
+const native = coreReferenceRecords(coreEditor);
+assert.equal(native.mode, "native");
+assert.deepEqual(native.records.map(({kind, token, label}) => ({kind, token, label})), [
+    {kind: "picture", token: "<Picture 1>", label: "<Picture 1>"},
+    {kind: "audio", token: "<Audio 1>", label: "<Audio 1>"},
+]);
+assert.equal(referencePreviewRecords(coreEditor, 1).mode, "native");
+assert.deepEqual(
+    availableReferenceRecords(coreEditor, 1).records.map(({token}) => token),
+    ["<Picture 1>", "<Audio 1>"],
+);
+
+const flEditor = add(makeNode(15, "MiniMaxH3ChainScenePromptEditor"));
+const flRelay = add(makeNode(16, "MiniMaxH3ChainCurrent"));
+const fl2v = add(makeNode(17, "MiniMaxH3ImageToVideo"));
+const firstFrame = add(makeNode(18, "LoadImage", {image: "first.png"}));
+const lastFrame = add(makeNode(19, "LoadImage", {image: "last.png"}));
+connect(flEditor, flRelay, "state");
+connect(flRelay, fl2v, "prompt");
+connect(firstFrame, fl2v, "first_frame");
+connect(lastFrame, fl2v, "last_frame");
+const keyframes = imageToVideoReferenceRecords(flEditor);
+assert.equal(keyframes.mode, "native_keyframes");
+assert.deepEqual(
+    keyframes.records.map(({token, role}) => ({token, role})),
+    [
+        {token: "<Picture 1>", role: "first frame"},
+        {token: "<Picture 2>", role: "last frame"},
+    ],
+);
+assert.equal(referencePreviewRecords(flEditor, 1).mode, "native_keyframes");
+
+const indexedEditor = add(makeNode(40, "MiniMaxH3ChainRichScenePromptEditor"));
+const indexedRelay = add(makeNode(41, "MiniMaxH3ChainCurrent"));
+const indexedFl2v = add(makeNode(42, "MiniMaxH3ImageToVideo"));
+const indexedGate = add(makeNode(43, "MiniMaxH3ChainFirstSceneImage"));
+const indexedSwitch = add(makeNode(44, "MiniMaxH3ChainFrameIndexSwitch"));
+const frameA = add(makeNode(45, "LoadImage", {image: "frame-a.png"}));
+const frameB = add(makeNode(46, "LoadImage", {image: "frame-b.png"}));
+connect(indexedEditor, indexedRelay, "state");
+connect(indexedRelay, indexedFl2v, "prompt");
+connect(frameA, indexedGate, "image");
+connect(frameB, indexedSwitch, "frame_1");
+connect(frameA, indexedSwitch, "frame_2");
+connect(indexedSwitch, indexedGate, "last_frame");
+connect(indexedGate, indexedFl2v, "first_frame", 0);
+connect(indexedGate, indexedFl2v, "last_frame", 3);
+
+const indexedSceneOne = imageToVideoReferenceRecords(indexedEditor, 1).records;
+assert.deepEqual(
+    indexedSceneOne.map(({token, role, source}) => ({token, role, source: source.id})),
+    [
+        {token: "<Picture 1>", role: "first frame", source: frameA.id},
+        {token: "<Picture 2>", role: "last frame", source: frameB.id},
+    ],
+);
+const indexedSceneTwo = imageToVideoReferenceRecords(indexedEditor, 2).records;
+assert.deepEqual(
+    indexedSceneTwo.map(({token, role, active, source}) => ({
+        token, role, active, source: source.id,
+    })),
+    [
+        {token: "<Picture 1>", role: "first frame", active: false, source: frameA.id},
+        {token: "<Picture 1>", role: "last frame", active: true, source: frameA.id},
+    ],
+);
+assert.deepEqual(
+    availableReferenceRecords(indexedEditor, 1).records.map(({source}) => source.id),
+    [frameA.id, frameB.id],
+);
+
+const i2vEditor = add(makeNode(24, "MiniMaxH3ChainScenePromptEditor"));
+const i2vRelay = add(makeNode(25, "MiniMaxH3ChainCurrent"));
+const i2v = add(makeNode(26, "MiniMaxH3ImageToVideo"));
+const openingFrame = add(makeNode(27, "LoadImage", {image: "opening.png"}));
+const firstSceneGate = add(makeNode(28, "MiniMaxH3ChainFirstSceneImage"));
+connect(i2vEditor, i2vRelay, "state");
+connect(i2vRelay, i2v, "prompt");
+connect(openingFrame, firstSceneGate, "image");
+connect(firstSceneGate, i2v, "first_frame");
+assert.deepEqual(
+    imageToVideoReferenceRecords(i2vEditor, 1).records
+        .map(({token, selector, active, source}) => ({
+            token, selector, active, source: source.type,
+        })),
+    [{token: "<Picture 1>", selector: "1", active: true,
+        source: "LoadImage"}],
+);
+assert.deepEqual(
+    referencePreviewRecords(i2vEditor, 2).records
+        .map(({token, selector, active}) => ({token, selector, active})),
+    [{token: "<Picture 1>", selector: "1", active: false}],
+);
+assert.deepEqual(availableReferenceRecords(i2vEditor, 2).records, []);
+
+const lEditor = add(makeNode(20, "MiniMaxH3ChainScenePromptEditor"));
+const lRelay = add(makeNode(21, "MiniMaxH3ChainCurrent"));
+const l2v = add(makeNode(22, "MiniMaxH3ImageToVideo"));
+const onlyLastFrame = add(makeNode(23, "LoadImage", {image: "last-only.png"}));
+connect(lEditor, lRelay, "state");
+connect(lRelay, l2v, "prompt");
+connect(onlyLastFrame, l2v, "last_frame");
+assert.deepEqual(
+    imageToVideoReferenceRecords(lEditor).records.map(({token, role}) => ({token, role})),
+    [{token: "<Picture 1>", role: "last frame"}],
+);
+
+const projectEditor = add(makeNode(270, "MiniMaxH3ChainScenePromptEditor"));
+const projectManager = add(makeNode(271, "MiniMaxH3ProjectAssetManager", {
+    catalog_json: JSON.stringify({
+        project: "episode_1",
+        assets: [
+            {id: "p", kind: "image", role: "picture", tag: "hero",
+                enabled: true, metadata: {}},
+            {id: "s", kind: "image", role: "semantic_anchor", tag: "door",
+                enabled: true, metadata: {}},
+            {id: "v", kind: "video", role: "motion", tag: "walk",
+                enabled: true, metadata: {has_audio: true}, options: {}},
+            {id: "a", kind: "audio", role: "audio_reference", tag: "voice",
+                enabled: true, metadata: {}},
+        ],
+    }),
+    semantic_anchor_mode: "timestamped_video",
+}));
+const projectRef2va = add(makeNode(272, "MiniMaxH3TaggedReferenceToVideo"));
+connect(projectEditor, projectRef2va, "prompt");
+connect(projectManager, projectRef2va, "references", 1);
+const projectRecords = taggedReferenceRecords(
+    projectEditor, "Use @hero and @walk with #door[2.00s] and @voice.",
+).records;
+assert.deepEqual(
+    projectRecords.map(({tag, active, semanticOnly}) => ({
+        tag, active, semanticOnly: Boolean(semanticOnly),
+    })),
+    [
+        {tag: "hero", active: true, semanticOnly: false},
+        {tag: "door", active: true, semanticOnly: true},
+        {tag: "walk", active: true, semanticOnly: false},
+        {tag: "walk_audio", active: true, semanticOnly: false},
+        {tag: "voice", active: true, semanticOnly: false},
+    ],
+);
+assert.ok(projectRecords.every((record) => record.previewUrl?.includes(
+    "project=episode_1")));
+
+const compactEditor = add(makeNode(273, "MiniMaxH3ChainScenePromptEditor"));
+const compactLoopStart = add(makeNode(274, "MiniMaxH3ChainLoopStart"));
+const compactRef2va = add(makeNode(
+    275, "MiniMaxH3CurrentTaggedReferenceScene",
+));
+connect(compactEditor, compactLoopStart, "plan");
+connect(compactLoopStart, compactRef2va, "state");
+connect(projectManager, compactRef2va, "references", 1);
+assert.equal(findTaggedRef2VA(compactEditor), compactRef2va);
+assert.deepEqual(
+    availableReferenceRecords(compactEditor, 1, {
+        prompt: "Use @hero with #door[2.00s].",
+    }).records.map(({tag}) => tag),
+    ["hero", "door"],
+);
+
+const studioManager = add(makeNode(276, "MiniMaxH3ProjectAssetManager", {
+    catalog_json: JSON.stringify({
+        project: "studio_project",
+        assets: [{
+            id: "studio-picture", kind: "image", role: "picture",
+            tag: "Comfy", enabled: true, metadata: {},
+        }],
+    }),
+    semantic_anchor_mode: "timestamped_video",
+}));
+const modernPlan = add(makeNode(277, "MiniMaxH3ChainPlanModern"));
+const planStudio = add(makeNode(278, "MiniMaxH3ChainPlanStudio"));
+const richEditor = add(makeNode(
+    279, "MiniMaxH3ChainRichScenePromptEditor",
+));
+connect(studioManager, modernPlan, "project_assets");
+connect(modernPlan, planStudio, "plan");
+connect(studioManager, planStudio, "tagged_references", 1);
+connect(planStudio, richEditor, "plan");
+assert.equal(findProjectAssetManager(richEditor), studioManager);
+assert.equal(findTaggedRef2VA(richEditor), null);
+assert.deepEqual(
+    availableReferenceRecords(richEditor, 1, {
+        includeInactive: true,
+        prompt: "No reference inserted yet.",
+    }).records.map(({tag, active}) => ({tag, active})),
+    [{tag: "Comfy", active: false}],
+);
+
+console.log("H3 reference preview: tagged/scheduled Ref2VA, core Ref2VA, and core I2V/FL2V discovery pass");
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_reference_scheduler_unit_test.py b/ComfyUI-MiniMaxH3-Context-Loop/tests/_reference_scheduler_unit_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..c063d519807b484eb69fb8bd3baf8a6e367e2f1b
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_reference_scheduler_unit_test.py
@@ -0,0 +1,1460 @@
+#!/usr/bin/env python3
+"""Standalone scheduler compiler test without importing a ComfyUI checkout."""
+
+import importlib.util
+import json
+import math
+import pathlib
+import sys
+import tempfile
+import types
+
+
+ROOT = pathlib.Path(__file__).resolve().parents[1]
+PACKAGE = "h3_reference_scheduler_unit"
+
+folder_paths = types.ModuleType("folder_paths")
+folder_paths.get_output_directory = lambda: str(ROOT)
+folder_paths.get_temp_directory = lambda: str(ROOT)
+folder_paths.get_input_directory = lambda: str(ROOT)
+folder_paths.get_annotated_filepath = lambda value: str(value)
+sys.modules["folder_paths"] = folder_paths
+
+package = types.ModuleType(PACKAGE)
+package.__path__ = [str(ROOT)]
+sys.modules[PACKAGE] = package
+
+shared_nodes = types.ModuleType(PACKAGE + ".nodes")
+shared_nodes.MiniMaxH3MotionContext = object
+shared_nodes._claim_inline_patch_ownership = lambda _conditioning=None: "test patch owner"
+shared_nodes._prepare_native_guide_conditioning = lambda *args: None
+shared_nodes._resize = lambda *args: None
+shared_nodes._streams_from_latent = lambda *args: None
+sys.modules[shared_nodes.__name__] = shared_nodes
+
+spec = importlib.util.spec_from_file_location(
+    PACKAGE + ".chain_nodes", ROOT / "chain_nodes.py")
+chain = importlib.util.module_from_spec(spec)
+sys.modules[spec.name] = chain
+spec.loader.exec_module(chain)
+
+
+exact_362_audio = {
+    "waveform": chain.torch.ones((1, 2, 482667)),
+    "sample_rate": 32000,
+}
+aligned_362_audio, aligned_362_status = (
+    chain._align_audio_reference_to_h3_grid(exact_362_audio, 362))
+assert int(aligned_362_audio["waveform"].shape[-1]) == 482240
+assert "target 603 steps, safe 15.070000s" in aligned_362_status
+
+exact_362_audio_44k = {
+    "waveform": chain.torch.ones((1, 2, round(362 / 24 * 44100))),
+    "sample_rate": 44100,
+}
+aligned_362_audio_44k, _ = chain._align_audio_reference_to_h3_grid(
+    exact_362_audio_44k, 362)
+aligned_44k_samples = int(aligned_362_audio_44k["waveform"].shape[-1])
+assert aligned_44k_samples == 664587
+assert math.ceil(aligned_44k_samples * 32000 / 44100) == 482240
+
+short_audio = {
+    "waveform": chain.torch.ones((1, 2, 480000)),
+    "sample_rate": 32000,
+}
+unchanged_audio, unchanged_status = (
+    chain._align_audio_reference_to_h3_grid(short_audio, 362))
+assert unchanged_audio is short_audio
+assert "unchanged" in unchanged_status
+
+
+class LazyAudio:
+    """Minimal non-dict ComfyUI AUDIO proxy for compatibility testing."""
+
+    def __init__(self, value):
+        self.value = value
+        self.reads = 0
+
+    def __getitem__(self, key):
+        self.reads += 1
+        return self.value[key]
+
+
+class FakeDynamicPrompt:
+    def __init__(self, nodes):
+        self.nodes = nodes
+
+    def all_node_ids(self):
+        return set(self.nodes)
+
+    def get_node(self, node_id):
+        return self.nodes[node_id]
+
+def schedule():
+    return chain._make_reference_schedule([
+        {
+            "kind": "picture", "tag": "hero_face", "scenes": "1:7",
+            "ranges": ((1, 7),), "value": object(), "content_hash": "face",
+            "declaration": "THIS LEGACY TEXT MUST NEVER BE INSERTED",
+        },
+        {
+            "kind": "picture", "tag": "hero_look", "scenes": "all",
+            "ranges": (), "value": object(), "content_hash": "look",
+        },
+        {
+            "kind": "video", "tag": "performance", "scenes": "4:6",
+            "ranges": ((4, 6),), "value": object(), "audio": object(),
+            "audio_tag": "performance_audio", "content_hash": "video",
+            "audio_hash": "paired-audio",
+            "audio_declaration": "NOR THIS LEGACY TEXT",
+        },
+        {
+            "kind": "audio", "tag": "song", "scenes": "all",
+            "ranges": (), "value": object(), "content_hash": "song",
+        },
+    ])
+
+
+workflow = json.loads((
+    ROOT / "example_workflows" / "Archive" /
+    "Looping Seamless Chain V2 - Scheduled Refs - MiniMax H3.json"
+).read_text(encoding="utf-8"))
+plan_node = next(node for node in workflow["nodes"]
+                 if node.get("type") == "MiniMaxH3ChainPlan")
+plan = json.loads(plan_node["widgets_values"][0])
+
+for scene in (1, 4, 8):
+    source = "\n".join(plan["shots"][scene - 1]["prompt"])
+    compiled, mapping, _bindings = chain._compile_scheduled_reference_prompt(
+        schedule(), scene, 14, source)
+    assert "@hero" not in compiled
+    assert "@performance" not in compiled
+    assert "@song" not in compiled
+    assert "LEGACY TEXT" not in compiled
+    assert "{ref}" not in compiled
+    assert compiled.startswith("subject_definitions:\n<Subject 1>")
+    if scene == 1:
+        assert "<Picture 1>" in compiled and "<Picture 2>" in compiled
+        assert "<Audio 1> is the current frame-exact" in compiled
+    elif scene == 4:
+        assert "<Video 1> provides a weak reference" in compiled
+        assert "<Audio 1> is the synchronized soundtrack" in compiled
+        assert "<Audio 2> is the current frame-exact" in compiled
+    else:
+        assert "defined by <Picture 1>" in compiled
+        assert "<Picture 2>" not in compiled
+        assert "<Audio 1> is the current frame-exact" in compiled
+    assert mapping.startswith("scene %d/14:" % scene)
+
+warning_prompt, warning_summary, warning_bindings = (
+    chain._compile_scheduled_reference_prompt(
+        schedule(), 1, 14,
+        "Resolve @hero_face; preserve @missing and @missing.",
+        compliance_mode="soft"))
+assert warning_prompt == (
+    "Resolve <Picture 1>; preserve @missing and @missing.")
+assert len(warning_bindings["compliance_warnings"]) == 1
+assert "unknown scheduled reference tag @missing" in warning_summary
+compliance_options = (
+    chain.MiniMaxH3ScheduledReferenceToVideo.INPUT_TYPES()["optional"]
+    ["prompt_compliance"])
+assert compliance_options[0] == ["strict", "soft", "disabled"]
+assert compliance_options[1]["default"] == "strict"
+disabled_prompt, disabled_summary, disabled_bindings = (
+    chain._compile_scheduled_reference_prompt(
+        schedule(), 1, 14,
+        "Leave @hero_face and @missing entirely to the user.",
+        compliance_mode="disabled"))
+assert disabled_prompt == "Leave @hero_face and @missing entirely to the user."
+assert disabled_bindings["compliance_warnings"] == []
+assert disabled_bindings["compliance_mode"] == "disabled"
+assert "@tags passed unchanged" in disabled_summary
+assert chain._reference_compliance_mode(True) == "strict"
+assert chain._reference_compliance_mode(False) == "soft"
+assert chain.MiniMaxH3ScheduledReferenceToVideo.VALIDATE_INPUTS(True) is True
+assert chain.MiniMaxH3ScheduledReferenceToVideo.VALIDATE_INPUTS(False) is True
+assert "must be strict, soft, or disabled" in (
+    chain.MiniMaxH3ScheduledReferenceToVideo.VALIDATE_INPUTS("unknown"))
+
+disabled_graph = FakeDynamicPrompt({
+    "audio": {
+        "class_type": "MiniMaxH3ScheduledAudioReference", "inputs": {}},
+    "wrapper": {
+        "class_type": "MiniMaxH3ScheduledReferenceToVideo",
+        "inputs": {
+            "reference_schedule": ["audio", 0],
+            "prompt_compliance": "disabled",
+        },
+    },
+})
+skipped_schedule, skipped_fingerprint, skipped_status = (
+    chain.MiniMaxH3ScheduledAudioReference().add(
+        None, "song", "all", dynprompt=disabled_graph, unique_id="audio"))
+assert skipped_schedule["entries"] == []
+assert chain._generation_fingerprint_value(skipped_fingerprint)[0] == (
+    skipped_schedule["fingerprint"])
+assert "skipped because compliance is disabled" in skipped_status
+
+disabled_picture_graph = FakeDynamicPrompt({
+    "picture": {
+        "class_type": "MiniMaxH3ScheduledPictureReference", "inputs": {}},
+    "wrapper": disabled_graph.nodes["wrapper"] | {
+        "inputs": {
+            "reference_schedule": ["picture", 0],
+            "prompt_compliance": "disabled",
+        },
+    },
+})
+unchecked_picture = chain.MiniMaxH3ScheduledPictureReference().add(
+    chain.torch.zeros((1, 4, 4, 3)), "!!!", "not-a-selector",
+    dynprompt=disabled_picture_graph, unique_id="picture")[0]
+assert len(unchecked_picture["entries"]) == 1
+assert unchecked_picture["entries"][0]["tag"].startswith("reference_")
+assert unchecked_picture["entries"][0]["scenes"] == "all"
+
+too_many_audio = chain._make_reference_schedule([
+    {
+        "kind": "audio", "tag": "audio_%d" % index, "scenes": "all",
+        "ranges": (), "value": object(), "content_hash": str(index),
+    }
+    for index in range(4)
+])
+capacity_prompt, capacity_summary, capacity_bindings = (
+    chain._compile_scheduled_reference_prompt(
+        too_many_audio, 1, 1, "User-managed <Audio 1>.",
+        compliance_mode="disabled"))
+assert capacity_prompt == "User-managed <Audio 1>."
+assert len(capacity_bindings["audios"]) == 3
+assert "only the first 3 were kept" in capacity_summary
+
+malformed_prompt, malformed_summary, malformed_bindings = (
+    chain._compile_scheduled_reference_prompt(
+        {"version": -1, "entries": "broken"}, 99, 0,
+        "Entirely user-managed prompt.", compliance_mode="disabled"))
+assert malformed_prompt == "Entirely user-managed prompt."
+assert malformed_bindings["pictures"] == []
+assert "Reference schedule ignored" in malformed_summary
+
+soft_graph = FakeDynamicPrompt({
+    "audio": disabled_graph.nodes["audio"],
+    "wrapper": {
+        "class_type": "MiniMaxH3ScheduledReferenceToVideo",
+        "inputs": {
+            "reference_schedule": ["audio", 0],
+            "prompt_compliance": "soft",
+        },
+    },
+})
+try:
+    chain.MiniMaxH3ScheduledAudioReference().add(
+        None, "song", "all", dynprompt=soft_graph, unique_id="audio")
+except ValueError as exc:
+    assert "received no audio (None)" in str(exc)
+else:
+    raise AssertionError("soft compliance accepted missing scheduled audio")
+
+picture_inputs = chain.MiniMaxH3ScheduledPictureReference.INPUT_TYPES()[
+    "required"]
+video_inputs = chain.MiniMaxH3ScheduledVideoReference.INPUT_TYPES()["required"]
+audio_inputs = chain.MiniMaxH3ScheduledAudioReference.INPUT_TYPES()["required"]
+assert "declaration" not in picture_inputs
+assert "declaration" not in video_inputs
+assert "audio_declaration" not in video_inputs
+assert "declaration" not in audio_inputs
+
+lazy_audio = LazyAudio({
+    "waveform": chain.torch.zeros((1, 2, 8000), dtype=chain.torch.float32),
+    "sample_rate": 8000,
+})
+lazy_schedule, lazy_fingerprint, lazy_status = (
+    chain.MiniMaxH3ScheduledAudioReference().add(
+        lazy_audio, "lazy_voice", "1:2"))
+assert lazy_audio.reads > 0
+assert lazy_schedule["entries"][0]["value"] is lazy_audio
+assert len(lazy_schedule["entries"][0]["content_hash"]) == 64
+assert chain._generation_fingerprint_value(lazy_fingerprint)[0] == (
+    lazy_schedule["fingerprint"])
+assert "@lazy_voice audio on 1:2" in lazy_status
+try:
+    chain.MiniMaxH3ScheduledAudioReference().add(
+        None, "missing_voice", "1")
+except ValueError as exc:
+    message = str(exc)
+    assert "received no audio (None)" in message
+    assert "source_audio_slice" in message
+    assert "generated_audio" in message
+    assert "connect Load Audio directly" in message
+    assert "source_plus_timeline" in message
+    assert "muted or bypassed" in message
+    assert "playable browser preview" in message
+else:
+    raise AssertionError("missing scheduled audio was accepted")
+try:
+    chain.MiniMaxH3ScheduledAudioReference().add(
+        lambda: b"legacy VHS_AUDIO", "legacy", "1")
+except ValueError as exc:
+    assert "ComfyUI AUDIO" in str(exc)
+else:
+    raise AssertionError("legacy callable VHS_AUDIO was accepted")
+
+plan_inputs = chain.MiniMaxH3ChainPlan.INPUT_TYPES()["required"]
+plan_optional_inputs = chain.MiniMaxH3ChainPlan.INPUT_TYPES()["optional"]
+assert plan_optional_inputs["plan_json_input"][0] == "STRING"
+assert plan_optional_inputs["plan_json_input"][1]["forceInput"] is True
+assert "non-empty" in plan_optional_inputs[
+    "plan_json_input"][1]["tooltip"]
+audio_mode_help = plan_inputs["audio_mode"][1]["tooltip"]
+assert "does NOT enable or disable @voice/<Audio N> references" in audio_mode_help
+assert "finished prerecorded voice" in audio_mode_help
+assert "short @voice identity/timbre reference" in audio_mode_help
+assert "generated_audio" in audio_mode_help
+assert "experimental" in audio_mode_help
+assert "output/h3_chains" in plan_inputs["run_name"][1]["tooltip"]
+base_seed_help = plan_inputs["base_seed"][1]["tooltip"]
+assert "Reroll seed does NOT change base_seed" in base_seed_help
+assert "always-visible Scene seed" in base_seed_help
+assert "audio_tag" in video_inputs
+assert video_inputs["timeline_mode"][0] == [
+    "restart_each_scene", "sequential"]
+assert "state" in chain.MiniMaxH3ScheduledReferenceToVideo.INPUT_TYPES()[
+    "optional"]
+apply_arguments = (
+    chain.MiniMaxH3ScheduledReferenceToVideo.apply.__code__.co_varnames[
+        :chain.MiniMaxH3ScheduledReferenceToVideo.apply.__code__.co_argcount])
+assert "state" in apply_arguments and "prompt_compliance" in apply_arguments
+assert "timeline_mode" not in chain._reference_entry_contract({
+    "kind": "video", "tag": "motion", "scenes": "all",
+    "content_hash": "video", "timeline_mode": "restart_each_scene",
+})
+assert chain._reference_entry_contract({
+    "kind": "video", "tag": "motion", "scenes": "all",
+    "content_hash": "video", "timeline_mode": "sequential",
+})["timeline_mode"] == "sequential"
+
+lazy_restart_descriptor = {
+    "version": chain.LAZY_MOTION_SOURCE_VERSION,
+    "kind": "lazy_motion_path",
+    "path": "/virtual/reference.mp4",
+    "frame_count": 73,
+}
+lazy_restart_calls = []
+original_decode_lazy_video = chain._decode_lazy_motion_video
+original_decode_lazy_audio = chain._decode_lazy_motion_audio
+try:
+    chain._decode_lazy_motion_video = (
+        lambda descriptor, start, end:
+        lazy_restart_calls.append(("video", descriptor, start, end)) or
+        "full-reference-video")
+    chain._decode_lazy_motion_audio = (
+        lambda descriptor, start, end:
+        lazy_restart_calls.append(("audio", descriptor, start, end)) or
+        "full-reference-audio")
+    lazy_restart_video, lazy_restart_audio, lazy_restart_detail = (
+        chain._scheduled_video_reference_slice({
+            "tag": "walk",
+            "value": lazy_restart_descriptor,
+            "audio": lazy_restart_descriptor,
+            "timeline_mode": "restart_each_scene",
+        }, None, 1, 1, 243))
+    assert lazy_restart_video == "full-reference-video"
+    assert lazy_restart_audio == "full-reference-audio"
+    assert [(kind, start, end) for kind, _descriptor, start, end
+            in lazy_restart_calls] == [
+                ("video", 0, 73), ("audio", 0, 73)]
+    assert lazy_restart_detail == "@walk lazy restart frames 0:73"
+finally:
+    chain._decode_lazy_motion_video = original_decode_lazy_video
+    chain._decode_lazy_motion_audio = original_decode_lazy_audio
+
+source_restart_timeline = {"extent": {"frame_count": 91}}
+source_restart_calls = []
+original_is_source_timeline = chain._is_source_timeline
+original_source_timeline_video = chain._source_timeline_scene_video
+original_source_timeline_audio = chain._source_timeline_scene_audio
+try:
+    chain._is_source_timeline = (
+        lambda value: value is source_restart_timeline)
+    chain._source_timeline_scene_video = (
+        lambda timeline, start, end:
+        source_restart_calls.append(("video", timeline, start, end)) or
+        "full-source-video")
+    chain._source_timeline_scene_audio = (
+        lambda timeline, start, end:
+        source_restart_calls.append(("audio", timeline, start, end)) or
+        "full-source-audio")
+    source_restart_video, source_restart_audio, source_restart_detail = (
+        chain._scheduled_video_reference_slice({
+            "tag": "performance",
+            "value": source_restart_timeline,
+            "audio": source_restart_timeline,
+            "timeline_mode": "restart_each_scene",
+        }, None, 1, 1, 243))
+    assert source_restart_video == "full-source-video"
+    assert source_restart_audio == "full-source-audio"
+    assert [(kind, start, end) for kind, _timeline, start, end
+            in source_restart_calls] == [
+                ("video", 0, 91), ("audio", 0, 91)]
+    assert source_restart_detail == (
+        "@performance Source Timeline restart frames 0:91")
+finally:
+    chain._is_source_timeline = original_is_source_timeline
+    chain._source_timeline_scene_video = original_source_timeline_video
+    chain._source_timeline_scene_audio = original_source_timeline_audio
+
+sequential_video = chain.torch.arange(
+    700, dtype=chain.torch.float32).reshape(700, 1, 1, 1).expand(-1, 2, 2, 3)
+sequential_audio = {
+    "waveform": chain.torch.arange(
+        7000, dtype=chain.torch.float32).reshape(1, 1, 7000),
+    "sample_rate": 240,
+}
+sequential_schedule = chain.MiniMaxH3ScheduledVideoReference().add(
+    sequential_video, "motion", "", "motion_audio", "sequential",
+    audio=sequential_audio)[0]
+sequential_entry = sequential_schedule["entries"][0]
+assert sequential_entry["timeline_mode"] == "sequential"
+sequential_state = {
+    "index": 2,
+    "plan": {
+        "shots": [
+            {"raw_frames": 243, "generation_start_frame": 0},
+            {"raw_frames": 243, "generation_start_frame": 221},
+        ],
+    },
+}
+video_slice, audio_slice, slice_detail = (
+    chain._scheduled_video_reference_slice(
+        sequential_entry, sequential_state, 2, 2, 243))
+assert tuple(video_slice.shape) == (243, 2, 2, 3)
+assert float(video_slice[0, 0, 0, 0]) == 221
+assert float(video_slice[-1, 0, 0, 0]) == 463
+assert tuple(audio_slice["waveform"].shape) == (1, 1, 2430)
+assert float(audio_slice["waveform"][0, 0, 0]) == 2210
+assert slice_detail == "@motion sequential frames 221:464 (origin scene 1)"
+try:
+    chain._scheduled_video_reference_slice(
+        sequential_entry, None, 2, 2, 243)
+except ValueError as exc:
+    assert "Current Shot state" in str(exc)
+else:
+    raise AssertionError("sequential reference accepted missing state")
+
+tagged_picture_inputs = chain.MiniMaxH3TaggedPictureReference.INPUT_TYPES()[
+    "required"]
+tagged_video_inputs = chain.MiniMaxH3TaggedVideoReference.INPUT_TYPES()[
+    "required"]
+tagged_audio_inputs = chain.MiniMaxH3TaggedAudioReference.INPUT_TYPES()[
+    "required"]
+assert "scenes" not in tagged_picture_inputs
+assert "scenes" not in tagged_video_inputs
+assert "scenes" not in tagged_audio_inputs
+assert tagged_audio_inputs["timeline_mode"][0] == [
+    "standalone", "source_timeline"]
+tagged_picture = chain.torch.zeros((1, 4, 4, 3))
+tagged_audio = {
+    "waveform": chain.torch.zeros((1, 1, 8000)),
+    "sample_rate": 8000,
+}
+tagged = chain.MiniMaxH3TaggedPictureReference().add(
+    tagged_picture, "face")[0]
+tagged = chain.MiniMaxH3TaggedPictureReference().add(
+    tagged_picture, "look", previous=tagged)[0]
+tagged = chain.MiniMaxH3TaggedAudioReference().add(
+    tagged_audio, "voice", previous=tagged)[0]
+assert tagged["activation"] == "prompt"
+assert all(entry["activation"] == "prompt" for entry in tagged["entries"])
+tagged_compiled, tagged_summary, tagged_bindings = (
+    chain._compile_tagged_reference_prompt(
+        tagged, 2, 3,
+        "<Subject 1> @S1 uses @look and speaks with @voice; keep @custom."))
+assert tagged_compiled == (
+    "<Subject 1> @S1 uses <Picture 1> and speaks with <Audio 1>; "
+    "keep @custom.")
+assert tagged_summary == (
+    "scene 2/3: @look -> <Picture 1>; @voice -> <Audio 1>")
+assert [entry["tag"] for entry in tagged_bindings["pictures"]] == ["look"]
+assert "face" not in tagged_bindings["aliases"]
+
+# Dedicated semantic pictures are collected behind one bundle, centralize
+# scale/mode there, and never consume native H3 Picture capacity.
+semantic_draft = None
+for index in range(10):
+    semantic_draft = chain.MiniMaxH3SemanticPictureAnchor().add(
+        tagged_picture, "anchor_%d" % index,
+        previous=semantic_draft)[0]
+native_capacity = None
+for index in range(9):
+    native_capacity = chain.MiniMaxH3TaggedPictureReference().add(
+        tagged_picture, "native_%d" % index,
+        previous=native_capacity)[0]
+native_passthrough, combined_token, bundle_status = (
+    chain.MiniMaxH3SemanticAnchorBundle().bundle(
+        semantic_draft, "768", "picture_storyboard",
+        references=native_capacity))
+semantic_bundle = native_passthrough["semantic_anchors"]
+assert native_passthrough is not native_capacity
+assert native_passthrough["entries"] is native_capacity["entries"]
+assert native_passthrough["semantic_anchors"] is semantic_bundle
+assert semantic_bundle["kind"] == "bundle"
+assert semantic_bundle["semantic_anchor_size"] == "768"
+assert semantic_bundle["semantic_anchor_mode"] == "picture_storyboard"
+assert len(semantic_bundle["entries"]) == 10
+assert "10 semantic pictures" in bundle_status
+assert chain._generation_fingerprint_value(combined_token)[0] == (
+    semantic_bundle["combined_reference_fingerprint"])
+capacity_prompt = " ".join(
+    ["@native_%d" % index for index in range(9)] +
+    ["#anchor_%d[0.00s]" % index for index in range(10)])
+_capacity_compiled, _capacity_summary, capacity_bindings = (
+    chain._compile_tagged_reference_prompt(
+        native_passthrough, 1, 1, capacity_prompt,
+        semantic_anchor_bundle=native_passthrough["semantic_anchors"]))
+assert len(capacity_bindings["pictures"]) == 9
+assert len(capacity_bindings["semantic_anchors"]) == 10
+assert capacity_bindings["semantic_anchor_mode"] == "picture_storyboard"
+native_overflow = chain.MiniMaxH3TaggedPictureReference().add(
+    tagged_picture, "native_9", previous=native_capacity)[0]
+try:
+    chain._compile_tagged_reference_prompt(
+        native_overflow, 1, 1,
+        " ".join("@native_%d" % index for index in range(10)),
+        semantic_anchor_bundle=semantic_bundle)
+except ValueError as exc:
+    assert "stock H3 Ref2VA supports 9" in str(exc)
+else:
+    raise AssertionError("ten native pictures bypassed stock H3 capacity")
+
+semantic_compiled, semantic_summary, semantic_bindings = (
+    chain._compile_tagged_reference_prompt(
+        tagged, 1, 1,
+        "Use #face[0.00s], #face[2.50s], and #face[2.50s] while "
+        "@look remains native."))
+assert semantic_compiled == (
+    "Use <Video 1>, <Video 1>, and <Video 1> while <Picture 1> "
+    "remains native.")
+assert len(semantic_bindings["semantic_anchors"]) == 1
+semantic_face = semantic_bindings["semantic_anchors"][0]
+assert semantic_face["tag"] == "face"
+assert semantic_face["label"] == "<Video 1>"
+assert semantic_face["entry"]["value"] is tagged["entries"][0]["value"]
+assert semantic_face["timestamps"] == [
+    chain.Fraction("0.00"), chain.Fraction("2.50")]
+assert "#face[0s,2.5s] -> <Video 1> Qwen-only semantic anchors" in (
+    semantic_summary)
+
+mixed_semantic, mixed_summary, mixed_bindings = (
+    chain._compile_tagged_reference_prompt(
+        tagged, 1, 1,
+        "Use #face untimed and #face[2.50s] later while @look is native."))
+assert mixed_semantic == (
+    "Use <Picture 2> untimed and <Video 1> later while <Picture 1> is native.")
+assert [(item["label"], item["untimed"], item["timestamps"])
+        for item in mixed_bindings["semantic_anchors"]] == [
+    ("<Picture 2>", True, []),
+    ("<Video 1>", False, [chain.Fraction("2.50")]),
+]
+assert "#face -> <Picture 2> Qwen-only semantic picture" in mixed_summary
+assert "#face[2.5s] -> <Video 1> Qwen-only semantic anchors" in mixed_summary
+hybrid_mixed, hybrid_mixed_anchors = chain._compile_refmod_hybrid_prompt(
+    "Use #face untimed and #face[2.50s] later while @look is native.",
+    mixed_bindings, mixed_bindings["semantic_anchors"],
+    "timestamped_video")
+assert hybrid_mixed == (
+    "Use <Picture 1> untimed and <Video 1> later while look is native.")
+assert [item["hybrid_label"] for item in hybrid_mixed_anchors] == [
+    "<Picture 1>", "<Video 1>"]
+
+storyboard_compiled, storyboard_summary, storyboard_bindings = (
+    chain._compile_tagged_reference_prompt(
+        tagged, 1, 1,
+        "Use #face[0.00s] then #face[2.50s] while @look remains native.",
+        semantic_anchor_mode="picture_storyboard"))
+assert storyboard_compiled == (
+    "For the target video, around 0 seconds into this scene, <Picture 2> "
+    "is an approximate visual storyboard reference.\n"
+    "For the target video, around 2.5 seconds into this scene, <Picture 2> "
+    "is an approximate visual storyboard reference.\n\n"
+    "Use <Picture 2> then <Picture 2> while <Picture 1> remains native.")
+assert storyboard_bindings["semantic_anchor_mode"] == "picture_storyboard"
+assert storyboard_bindings["semantic_anchors"][0]["label"] == "<Picture 2>"
+assert (
+    "#face[0s,2.5s] -> <Picture 2> Qwen-only approximate storyboard picture"
+    in storyboard_summary)
+chronological_storyboard, _summary, _bindings = (
+    chain._compile_tagged_reference_prompt(
+        tagged, 1, 1,
+        "Use #face[2.50s] after #look[0.25s].",
+        semantic_anchor_mode="picture_storyboard"))
+assert chronological_storyboard.startswith(
+    "For the target video, around 0.25 seconds into this scene, <Picture 2> "
+    "is an approximate visual storyboard reference.\n"
+    "For the target video, around 2.5 seconds into this scene, <Picture 1> "
+    "is an approximate visual storyboard reference.\n\n")
+assert chain._semantic_anchor_specs(
+    "@look #face and #face[0.00s] and #face[2.50]") == [
+        {"tag": "face", "timestamp_seconds": None},
+        {"tag": "face", "timestamp_seconds": 0.0},
+        {"tag": "face", "timestamp_seconds": 2.5},
+    ]
+assert chain._prompt_reference_tags(
+    "@look #face") == {"look", "face"}
+
+try:
+    chain._compile_tagged_reference_prompt(
+        tagged, 1, 1, "Use #missing[1.00s].")
+except ValueError as exc:
+    assert "unknown semantic anchor #missing" in str(exc)
+else:
+    raise AssertionError("unknown semantic anchor was accepted in strict mode")
+
+soft_semantic, soft_semantic_summary, soft_semantic_bindings = (
+    chain._compile_tagged_reference_prompt(
+        tagged, 1, 1, "Keep #missing[1.00s].", compliance_mode="soft"))
+assert soft_semantic == "Keep #missing[1.00s]."
+assert soft_semantic_bindings["semantic_anchors"] == []
+assert "unknown semantic anchor #missing" in soft_semantic_summary
+
+disabled_semantic, disabled_semantic_summary, disabled_semantic_bindings = (
+    chain._compile_tagged_reference_prompt(
+        tagged, 1, 1, "Keep #face[1.00s].", compliance_mode="disabled"))
+assert disabled_semantic == "Keep #face[1.00s]."
+assert disabled_semantic_bindings["semantic_anchors"] == []
+assert "@tags and #anchors passed unchanged" in disabled_semantic_summary
+
+video_for_semantic = chain.MiniMaxH3TaggedVideoReference().add(
+    chain.torch.zeros((5, 4, 4, 3)), "motion", "", "restart_each_scene")[0]
+try:
+    chain._compile_tagged_reference_prompt(
+        video_for_semantic, 1, 1, "Use #motion[0.00s].")
+except ValueError as exc:
+    assert "must resolve to a Tagged Picture Ref" in str(exc)
+else:
+    raise AssertionError("semantic anchor accepted a tagged video")
+
+
+class FakeSemanticClip:
+    def __init__(self):
+        self.items = None
+        self.prompt = None
+
+    def tokenize(self, prompt, minimax_ref_items=None):
+        self.prompt = prompt
+        self.items = minimax_ref_items
+        return {"tokens": "semantic"}
+
+    def encode_from_tokens_scheduled(self, tokens):
+        assert tokens == {"tokens": "semantic"}
+        return [["semantic-conditioning", {
+            "minimax_token_tags": "semantic-tags",
+            "pooled_output": "semantic-pooled",
+        }]]
+
+
+original_resize = chain._resize
+chain._resize = lambda image, width, height, _crop: chain.torch.zeros(
+    (int(image.shape[0]), int(height), int(width), 3),
+    dtype=image.dtype)
+try:
+    semantic_clip = FakeSemanticClip()
+    base_conditioning = [["native-conditioning", {
+        "minimax_refs": ["native-ref-payload"],
+        "minimax_token_tags": "native-tags",
+    }]]
+    anchor_picture = chain.torch.zeros((1, 64, 32, 3))
+    native_picture = chain.torch.zeros((1, 32, 64, 3))
+    native_video = chain.torch.zeros((5, 32, 64, 3))
+    semantic_result, semantic_status = (
+        chain._replace_conditioning_presentation(
+            base_conditioning, semantic_clip, "compiled prompt", {
+                "version": chain.SEMANTIC_PRESENTATION_VERSION,
+                "width": 64,
+                "height": 32,
+                "length": 22,
+                "ref_image_size": "match",
+                "semantic_anchor_size": "384",
+                "pictures": [native_picture],
+                "videos": [{
+                    "video": native_video,
+                    "paired_audio": True,
+                }],
+                "standalone_audio_count": 1,
+                "anchors": [{
+                    "tag": "face",
+                    "image": anchor_picture,
+                    "timestamps": (
+                        chain.Fraction("0.00"), chain.Fraction("0.75")),
+                }],
+            }))
+    assert semantic_clip.prompt == "compiled prompt"
+    assert [item["type"] for item in semantic_clip.items] == [
+        "image", "audio", "video", "audio", "video"]
+    semantic_video = semantic_clip.items[-1]
+    assert tuple(semantic_video["data"].shape) == (4, 544, 256, 3)
+    assert semantic_video["timestamps"] == [0.0, 0.0, 0.75, 0.75]
+    assert semantic_result[0][0] == "semantic-conditioning"
+    assert semantic_result[0][1]["minimax_refs"] == ["native-ref-payload"]
+    assert semantic_result[0][1]["minimax_token_tags"] == "semantic-tags"
+    assert semantic_status == "2 semantic checkpoints across 1 tagged pictures"
+
+    untimed_clip = FakeSemanticClip()
+    _untimed_result, untimed_status = (
+        chain._replace_conditioning_presentation(
+            base_conditioning, untimed_clip, "untimed prompt", {
+                "version": chain.SEMANTIC_PRESENTATION_VERSION,
+                "width": 64,
+                "height": 32,
+                "length": 22,
+                "ref_image_size": "match",
+                "semantic_anchor_size": "384",
+                "semantic_anchor_mode": "timestamped_video",
+                "pictures": [],
+                "videos": [],
+                "standalone_audio_count": 0,
+                "anchors": [{
+                    "tag": "face",
+                    "image": anchor_picture,
+                    "timestamps": (),
+                    "untimed": True,
+                }],
+            }))
+    assert [item["type"] for item in untimed_clip.items] == ["image"]
+    assert "timestamps" not in untimed_clip.items[0]
+    assert untimed_status == (
+        "1 untimed semantic picture across 1 tagged pictures")
+
+    storyboard_clip = FakeSemanticClip()
+    storyboard_result, storyboard_status = (
+        chain._replace_conditioning_presentation(
+            base_conditioning, storyboard_clip, "storyboard prompt", {
+                "version": chain.SEMANTIC_PRESENTATION_VERSION,
+                "width": 64,
+                "height": 32,
+                "length": 22,
+                "ref_image_size": "match",
+                "semantic_anchor_size": "1024",
+                "semantic_anchor_mode": "picture_storyboard",
+                "pictures": [native_picture],
+                "videos": [{
+                    "video": native_video,
+                    "paired_audio": True,
+                }],
+                "standalone_audio_count": 1,
+                "anchors": [{
+                    "tag": "face",
+                    "image": anchor_picture,
+                    "timestamps": (
+                        chain.Fraction("0.00"), chain.Fraction("0.75")),
+                }],
+            }))
+    assert [item["type"] for item in storyboard_clip.items] == [
+        "image", "audio", "video", "audio", "image"]
+    storyboard_picture = storyboard_clip.items[-1]
+    assert tuple(storyboard_picture["data"].shape) == (1, 1440, 736, 3)
+    assert "timestamps" not in storyboard_picture
+    assert storyboard_result[0][1]["minimax_refs"] == [
+        "native-ref-payload"]
+    assert storyboard_status == (
+        "2 approximate storyboard cues across 1 tagged pictures")
+
+    hybrid_clip = FakeSemanticClip()
+    hybrid_result, hybrid_status = (
+        chain._replace_conditioning_presentation(
+            base_conditioning, hybrid_clip, "hybrid prompt", {
+                "version": chain.SEMANTIC_PRESENTATION_VERSION,
+                "width": 64,
+                "height": 32,
+                "length": 22,
+                "ref_image_size": "match",
+                "semantic_anchor_size": "384",
+                "semantic_anchor_mode": "timestamped_video",
+                "pictures": [],
+                "videos": [],
+                "standalone_audio_count": 0,
+                "anchors": [{
+                    "tag": "face",
+                    "image": anchor_picture,
+                    "timestamps": (chain.Fraction("0.00"),),
+                }],
+            }))
+    assert [item["type"] for item in hybrid_clip.items] == ["video"]
+    assert hybrid_clip.items[0]["timestamps"] == [0.0, 0.0]
+    assert hybrid_result[0][1]["minimax_refs"] == ["native-ref-payload"]
+    assert hybrid_status == "1 semantic checkpoints across 1 tagged pictures"
+
+    high_resolution = chain._h3_semantic_anchor_image(
+        anchor_picture, "1280")
+    assert tuple(high_resolution.shape) == (1, 1824, 896, 3)
+
+    try:
+        chain._semantic_presentation_items({
+            "version": chain.SEMANTIC_PRESENTATION_VERSION,
+            "width": 64,
+            "height": 32,
+            "length": 22,
+            "ref_image_size": "match",
+            "semantic_anchor_size": "384",
+            "pictures": [],
+            "videos": [],
+            "standalone_audio_count": 0,
+            "anchors": [{
+                "tag": "face",
+                "image": anchor_picture,
+                "timestamps": (chain.Fraction("1.00"),),
+            }],
+        })
+    except ValueError as exc:
+        assert "scene's 0.917s output duration" in str(exc)
+    else:
+        raise AssertionError("out-of-scene semantic timestamp was accepted")
+finally:
+    chain._resize = original_resize
+
+
+class FakeExpansionNode:
+    def __init__(self, class_type, name):
+        self.class_type = class_type
+        self.name = name
+        self.inputs = {}
+
+    def set_input(self, name, value):
+        self.inputs[name] = value
+
+    def out(self, index):
+        return [self.name, int(index)]
+
+
+class FakeExpansionGraph:
+    def __init__(self):
+        self.nodes = []
+
+    def node(self, class_type, name):
+        node = FakeExpansionNode(class_type, name)
+        self.nodes.append(node)
+        return node
+
+    def finalize(self):
+        return {
+            node.name: {
+                "class_type": node.class_type,
+                "inputs": node.inputs,
+            }
+            for node in self.nodes
+        }
+
+
+original_graph_builder = chain.GraphBuilder
+chain.GraphBuilder = FakeExpansionGraph
+try:
+    semantic_expansion = chain.MiniMaxH3TaggedReferenceToVideo().apply(
+        "clip", "video-vae", "audio-vae", tagged, 1, 1,
+        "Use @look natively and #face[0.00s] semantically.",
+        64, 32, 22, "match", semantic_anchor_size="384")
+    expanded = semantic_expansion["expand"]
+    assert set(expanded) == {"TaggedRef2VA", "SemanticAnchors"}
+    assert expanded["TaggedRef2VA"]["inputs"][
+        "ref_images.ref_image_0"] is tagged["entries"][1]["value"]
+    semantic_inputs = expanded["SemanticAnchors"]["inputs"]
+    assert semantic_inputs["positive"] == ["TaggedRef2VA", 0]
+    assert semantic_inputs["prompt"] == (
+        "Use <Picture 1> natively and <Video 1> semantically.")
+    assert semantic_inputs["presentation"]["anchors"][0]["tag"] == "face"
+    assert semantic_inputs["presentation"]["semantic_anchor_size"] == "384"
+    assert semantic_inputs["presentation"]["semantic_anchor_mode"] == (
+        "timestamped_video")
+    assert semantic_expansion["result"][0] == ["SemanticAnchors", 0]
+    assert semantic_expansion["result"][1] == ["TaggedRef2VA", 1]
+    assert semantic_expansion["result"][4] != tagged["fingerprint"]
+
+    refmod_expansion = chain.MiniMaxH3TaggedReferenceToVideo().apply(
+        "clip", "video-vae", "audio-vae", tagged, 1, 1,
+        "Use @look through the external RefMod path.",
+        64, 32, 22, "match", conditioning_backend="external_refmod")
+    refmod_graph = refmod_expansion["expand"]
+    assert set(refmod_graph) == {"TaggedRefModBase"}
+    assert refmod_graph["TaggedRefModBase"]["class_type"] == (
+        "MiniMaxH3ImageToVideo")
+    assert refmod_graph["TaggedRefModBase"]["inputs"] == {
+        "clip": "clip",
+        "vae": "video-vae",
+        "prompt": "Use look through the external RefMod path.",
+        "width": 64,
+        "height": 32,
+        "length": 22,
+    }
+    assert refmod_expansion["result"][0] == ["TaggedRefModBase", 0]
+    assert refmod_expansion["result"][1] == ["TaggedRefModBase", 1]
+    assert len(refmod_expansion["result"][5]) == 1
+    assert chain.torch.equal(
+        refmod_expansion["result"][5][0], tagged_picture)
+    assert "text-only conditioning" in refmod_expansion["result"][3]
+    assert chain._generation_fingerprint_value(
+        refmod_expansion["result"][4])[0] != tagged["fingerprint"]
+
+    hybrid_expansion = chain.MiniMaxH3TaggedReferenceToVideo().apply(
+        "clip", "video-vae", "audio-vae", tagged, 1, 1,
+        "Use @look through RefMod and #face[0.00s] semantically.",
+        64, 32, 22, "match", conditioning_backend="external_refmod",
+        semantic_anchor_size="384")
+    hybrid_graph = hybrid_expansion["expand"]
+    assert set(hybrid_graph) == {"TaggedRefModBase", "SemanticAnchors"}
+    hybrid_prompt = (
+        "Use look through RefMod and <Video 1> semantically.")
+    assert hybrid_graph["TaggedRefModBase"]["inputs"]["prompt"] == (
+        hybrid_prompt)
+    hybrid_inputs = hybrid_graph["SemanticAnchors"]["inputs"]
+    assert hybrid_inputs["positive"] == ["TaggedRefModBase", 0]
+    assert hybrid_inputs["prompt"] == hybrid_prompt
+    assert hybrid_inputs["presentation"]["pictures"] == []
+    assert hybrid_inputs["presentation"]["videos"] == []
+    assert hybrid_inputs["presentation"]["standalone_audio_count"] == 0
+    assert [item["tag"] for item in hybrid_inputs[
+        "presentation"]["anchors"]] == ["face"]
+    assert len(hybrid_expansion["result"][5]) == 1
+    assert chain.torch.equal(
+        hybrid_expansion["result"][5][0], tagged_picture)
+    assert hybrid_expansion["result"][2] == hybrid_prompt
+    assert "RefMod @look" in hybrid_expansion["result"][3]
+    assert "#face -> <Video 1>" in hybrid_expansion["result"][3]
+    assert "hybrid Qwen: 1 semantic anchor source(s) only" in (
+        hybrid_expansion["result"][3])
+
+    hybrid_storyboard = chain.MiniMaxH3TaggedReferenceToVideo().apply(
+        "clip", "video-vae", "audio-vae", tagged, 1, 1,
+        "Use @look and #face[0.00s].",
+        64, 32, 22, "match", conditioning_backend="external_refmod",
+        semantic_anchor_mode="picture_storyboard")
+    hybrid_storyboard_inputs = hybrid_storyboard["expand"][
+        "SemanticAnchors"]["inputs"]
+    assert hybrid_storyboard_inputs["prompt"] == (
+        "For the target video, around 0 seconds into this scene, <Picture 1> "
+        "is an approximate visual storyboard reference.\n\n"
+        "Use look and <Picture 1>.")
+    assert hybrid_storyboard_inputs["presentation"]["pictures"] == []
+    assert hybrid_storyboard_inputs["presentation"]["anchors"][0][
+        "tag"] == "face"
+
+    try:
+        chain.MiniMaxH3TaggedReferenceToVideo().apply(
+            "clip", "video-vae", "audio-vae", tagged, 1, 1,
+            "Use @voice through RefMod.", 64, 32, 22, "match",
+            conditioning_backend="external_refmod")
+    except ValueError as exc:
+        assert "visual-only" in str(exc)
+        assert "standalone tagged audio" in str(exc)
+    else:
+        raise AssertionError("external RefMod accepted active tagged audio")
+
+    storyboard_expansion = chain.MiniMaxH3TaggedReferenceToVideo().apply(
+        "clip", "video-vae", "audio-vae", tagged, 1, 1,
+        "Use @look natively and #face[0.00s] as a storyboard cue.",
+        64, 32, 22, "match", semantic_anchor_size="1024",
+        semantic_anchor_mode="picture_storyboard")
+    storyboard_inputs = storyboard_expansion["expand"][
+        "SemanticAnchors"]["inputs"]
+    assert storyboard_inputs["presentation"]["semantic_anchor_mode"] == (
+        "picture_storyboard")
+    assert storyboard_inputs["presentation"]["semantic_anchor_size"] == (
+        "1024")
+    assert storyboard_inputs["prompt"].startswith(
+        "For the target video, around 0 seconds into this scene, "
+        "<Picture 2> is an approximate visual storyboard reference.")
+    assert storyboard_expansion["result"][4] != semantic_expansion["result"][4]
+
+    dedicated_expansion = chain.MiniMaxH3TaggedReferenceToVideo().apply(
+        "clip", "video-vae", "audio-vae", native_passthrough, 1, 1,
+        "Use @native_0 and #anchor_0[0.00s].",
+        64, 32, 22, "match", semantic_anchor_size="384",
+        semantic_anchor_mode="timestamped_video")
+    dedicated_inputs = dedicated_expansion["expand"][
+        "SemanticAnchors"]["inputs"]
+    assert dedicated_inputs["presentation"]["semantic_anchor_size"] == "768"
+    assert dedicated_inputs["presentation"]["semantic_anchor_mode"] == (
+        "picture_storyboard")
+    assert dedicated_expansion["result"][4] == combined_token
+
+    inherited_passthrough = dict(native_passthrough)
+    inherited_passthrough["semantic_anchors"] = (
+        chain._make_semantic_anchor_bundle(
+            semantic_bundle["entries"], "inherit", "inherit"))
+    inherited_expansion = chain.MiniMaxH3TaggedReferenceToVideo().apply(
+        "clip", "video-vae", "audio-vae", inherited_passthrough, 1, 1,
+        "Use @native_0 and #anchor_0[0.00s].",
+        64, 32, 22, "match", semantic_anchor_size="384",
+        semantic_anchor_mode="timestamped_video")
+    inherited_inputs = inherited_expansion["expand"][
+        "SemanticAnchors"]["inputs"]
+    assert inherited_inputs["presentation"]["semantic_anchor_size"] == "384"
+    assert inherited_inputs["presentation"]["semantic_anchor_mode"] == (
+        "timestamped_video")
+    assert inherited_expansion["result"][4] != combined_token
+
+    partial_inherit = dict(native_passthrough)
+    partial_inherit["semantic_anchors"] = (
+        chain._make_semantic_anchor_bundle(
+            semantic_bundle["entries"], "inherit", "picture_storyboard"))
+    partial_expansion = chain.MiniMaxH3TaggedReferenceToVideo().apply(
+        "clip", "video-vae", "audio-vae", partial_inherit, 1, 1,
+        "Use @native_0 and #anchor_0[0.00s].",
+        64, 32, 22, "match", semantic_anchor_size="1024",
+        semantic_anchor_mode="timestamped_video")
+    partial_inputs = partial_expansion["expand"][
+        "SemanticAnchors"]["inputs"]
+    assert partial_inputs["presentation"]["semantic_anchor_size"] == "1024"
+    assert partial_inputs["presentation"]["semantic_anchor_mode"] == (
+        "picture_storyboard")
+    assert partial_expansion["result"][4] != inherited_expansion["result"][4]
+
+    modern_state = {
+        "index": 1,
+        "plan": {
+            "version": chain.PLAN_VERSION,
+            "shots": [{"id": "scene_01"}],
+        },
+    }
+    modern_options = chain.MiniMaxH3TaggedSceneOptions().options(
+        "max", "soft", "768", "picture_storyboard", False,
+        "external_refmod", True)[0]
+    merged = chain.MiniMaxH3CurrentTaggedReferenceScene().expand(
+        modern_state, "clip", "video-vae", "audio-vae", tagged,
+        modern_options)
+    merged_graph = merged["expand"]
+    assert set(merged_graph) == {"CurrentScene", "TaggedRef2VA", "SceneData"}
+    assert merged_graph["CurrentScene"]["class_type"] == (
+        "MiniMaxH3ChainCurrent")
+    assert merged_graph["CurrentScene"]["inputs"] == {
+        "state": modern_state,
+        "align_audio_reference": True,
+    }
+    assert "source_audio" not in merged_graph["CurrentScene"]["inputs"]
+    merged_tagged = merged_graph["TaggedRef2VA"]["inputs"]
+    assert merged_tagged["state"] == ["CurrentScene", 0]
+    assert merged_tagged["clip_index"] == ["CurrentScene", 1]
+    assert merged_tagged["prompt"] == ["CurrentScene", 4]
+    assert merged_tagged["length"] == ["CurrentScene", 6]
+    assert merged_tagged["ref_image_size"] == "max"
+    assert merged_tagged["reference_policy"] == "soft"
+    assert merged_tagged["semantic_anchor_size"] == "768"
+    assert merged_tagged["semantic_anchor_mode"] == "picture_storyboard"
+    assert merged_tagged["cache_for_upscale"] is False
+    assert merged_tagged["conditioning_backend"] == "external_refmod"
+    merged_pack = merged_graph["SceneData"]["inputs"]
+    assert merged_pack["source_audio_slice"] == ["CurrentScene", 12]
+    assert merged_pack["refmod_sources"] == ["TaggedRef2VA", 5]
+    assert merged["result"] == (
+        ["CurrentScene", 0], ["TaggedRef2VA", 0],
+        ["TaggedRef2VA", 1], ["SceneData", 0])
+finally:
+    chain.GraphBuilder = original_graph_builder
+
+timeline_audio = {
+    "waveform": chain.torch.arange(
+        1000, dtype=chain.torch.float32).reshape(1, 1, 1000),
+    "sample_rate": 100,
+}
+timeline_tagged = chain.MiniMaxH3TaggedAudioReference().add(
+    timeline_audio, "song", "source_timeline", False)[0]
+timeline_entry = timeline_tagged["entries"][0]
+assert timeline_entry["timeline_mode"] == "source_timeline"
+assert chain._reference_entry_contract(timeline_entry)[
+    "timeline_mode"] == "source_timeline"
+timeline_state = {
+    "index": 2,
+    "plan": {
+        "compatibility": {
+            "audio_mode": "source_track",
+            "source_audio_hash": chain._audio_fingerprint(timeline_audio),
+            "source_audio_silent_padding": False,
+        },
+        "shots": [
+            {"raw_frames": 22, "audio_start_seconds": 0.0,
+             "audio_duration_seconds": 22 / 24},
+            {"raw_frames": 22, "audio_start_seconds": 0.5,
+             "audio_duration_seconds": 22 / 24},
+        ],
+    },
+}
+timeline_slice, timeline_detail = chain._tagged_audio_reference_value(
+    timeline_entry, timeline_state, 2, 2, 22)
+assert int(timeline_slice["waveform"].shape[-1]) == 92
+assert float(timeline_slice["waveform"][0, 0, 0]) == 50
+assert "@song source timeline 0.500..1.417s" in timeline_detail
+
+# The shipped Source Timeline workflow connects one Load Audio output to both
+# Source Timeline and Tagged Audio. Loop Start records the timeline route
+# fingerprint, while Tagged Audio records the original waveform fingerprint;
+# both must validate as the same source without weakening mismatch detection.
+deferred_timeline = chain._make_source_timeline(
+    source_audio=timeline_audio, embedded_audio="ignore")
+timeline_route_state = {
+    **timeline_state,
+    "source_timeline": deferred_timeline,
+    "plan": {
+        **timeline_state["plan"],
+        "compatibility": {
+            **timeline_state["plan"]["compatibility"],
+            "source_audio_hash": deferred_timeline[
+                "fingerprints"]["audio"],
+            "source_timeline_fingerprint": deferred_timeline[
+                "fingerprints"]["timeline"],
+        },
+    },
+}
+timeline_route_slice, timeline_route_detail = (
+    chain._tagged_audio_reference_value(
+        timeline_entry, timeline_route_state, 2, 2, 22))
+assert chain.torch.equal(
+    timeline_route_slice["waveform"], timeline_slice["waveform"])
+assert "@song source timeline 0.500..1.417s" in timeline_route_detail
+different_route_audio = {
+    "waveform": timeline_audio["waveform"] + 1,
+    "sample_rate": timeline_audio["sample_rate"],
+}
+different_route_entry = chain.MiniMaxH3TaggedAudioReference().add(
+    different_route_audio, "song", "source_timeline", False)[0]["entries"][0]
+try:
+    chain._tagged_audio_reference_value(
+        different_route_entry, timeline_route_state, 2, 2, 22)
+except ValueError as exc:
+    assert "different full source track" in str(exc)
+else:
+    raise AssertionError(
+        "source-timeline route accepted different tagged audio content")
+different_timeline_state = {
+    **timeline_state,
+    "plan": {
+        **timeline_state["plan"],
+        "compatibility": {
+            **timeline_state["plan"]["compatibility"],
+            "source_audio_hash": "different-track",
+        },
+    },
+}
+try:
+    chain._tagged_audio_reference_value(
+        timeline_entry, different_timeline_state, 2, 2, 22)
+except ValueError as exc:
+    assert "different full source track" in str(exc)
+else:
+    raise AssertionError("source-timeline audio accepted a mismatched track")
+try:
+    chain._tagged_audio_reference_value(timeline_entry, None, 2, 2, 22)
+except ValueError as exc:
+    assert "fingerprint-to-Plan" in str(exc)
+    assert "source_audio_slice" in str(exc)
+else:
+    raise AssertionError("source-timeline audio accepted missing state")
+
+tagged_sequential = chain.MiniMaxH3TaggedVideoReference().add(
+    sequential_video, "motion", "motion_audio", "sequential",
+    audio=sequential_audio)[0]
+tagged_sequential_entry = tagged_sequential["entries"][0]
+tagged_state = {
+    "index": 3,
+    "plan": {"shots": [
+        {"raw_frames": 243, "generation_start_frame": 0,
+         "prompt": "Opening without a motion tag."},
+        {"raw_frames": 243, "generation_start_frame": 221,
+         "prompt": "Begin @motion."},
+        {"raw_frames": 243, "generation_start_frame": 442,
+         "prompt": "Continue @motion_audio."},
+    ]},
+}
+tagged_video_slice, tagged_audio_slice, tagged_detail = (
+    chain._scheduled_video_reference_slice(
+        tagged_sequential_entry, tagged_state, 3, 3, 243))
+assert float(tagged_video_slice[0, 0, 0, 0]) == 221
+assert float(tagged_audio_slice["waveform"][0, 0, 0]) == 2210
+assert tagged_detail.endswith("(origin scene 2)")
+
+tagged_motion_role = chain.MiniMaxH3TaggedMotionReference().add(
+    sequential_video, "performance", "<Subject 1> and <Subject 2>",
+    "the source performer's pose sequence and action timing", "384", "",
+    "restart_each_scene")[0]
+motion_role_prompt = (
+    "subject_definitions:\n"
+    "<Subject 1> is the target character.\n"
+    "<Subject 2> is the target partner.\n\n"
+    "detailed_description:\n"
+    "[Shot 1] <Subject 1> performs @performance.")
+motion_role_compiled, motion_role_summary, motion_role_bindings = (
+    chain._compile_tagged_reference_prompt(
+        tagged_motion_role, 1, 1, motion_role_prompt))
+assert "<Subject 3> is the reusable pose, action, and motion from " \
+       "<Video 1>" in motion_role_compiled
+assert "<Subject 1> performs <Subject 3>." in motion_role_compiled
+assert "without importing the source identity, wardrobe, setting, lighting, " \
+       "or composition" in motion_role_compiled
+assert motion_role_bindings["aliases"]["performance"] == "<Subject 3>"
+assert "@performance -> <Subject 3> motion from <Video 1>" in \
+       motion_role_summary
+motion_role_contract = chain._reference_entry_contract(
+    tagged_motion_role["entries"][0])
+assert motion_role_contract["semantic_role"] == "motion"
+assert motion_role_contract["motion_target"] == "<Subject 1> and <Subject 2>"
+assert motion_role_contract["motion_short_edge"] == "384"
+
+sequential_motion_role = chain.MiniMaxH3TaggedMotionReference().add(
+    sequential_video, "performance", "<Subject 1>",
+    "the source performer's pose sequence and action timing", "source",
+    "performance_audio", "sequential", audio=sequential_audio)[0]
+masked_motion_state = {
+    "index": 2,
+    "plan": {
+        "compatibility": {"continuation_mode": "masked_av"},
+        "shots": [
+            {"raw_frames": 362, "delivered_frames": 362,
+             "generation_start_frame": 0,
+             "prompt": "Begin @performance."},
+            {"raw_frames": 345, "delivered_frames": 306,
+             "generation_start_frame": 323,
+             "prompt": "Continue @performance."},
+        ],
+    },
+}
+masked_motion_video, masked_motion_audio, masked_motion_detail = (
+    chain._scheduled_video_reference_slice(
+        sequential_motion_role["entries"][0], masked_motion_state,
+        2, 2, 345))
+assert tuple(masked_motion_video.shape) == (306, 2, 2, 3)
+assert float(masked_motion_video[0, 0, 0, 0]) == 362
+assert float(masked_motion_video[-1, 0, 0, 0]) == 667
+assert tuple(masked_motion_audio["waveform"].shape) == (1, 1, 3450)
+assert float(masked_motion_audio["waveform"][0, 0, 0]) == 3230
+assert masked_motion_detail == (
+    "@performance sequential delivered video frames 362:668; paired audio "
+    "raw frames 323:668 (origin scene 1)")
+
+guide_motion_state = {
+    **masked_motion_state,
+    "plan": {
+        **masked_motion_state["plan"],
+        "compatibility": {"continuation_mode": "guide"},
+    },
+}
+guide_motion_video, guide_motion_audio, guide_motion_detail = (
+    chain._scheduled_video_reference_slice(
+        sequential_motion_role["entries"][0], guide_motion_state,
+        2, 2, 345))
+assert tuple(guide_motion_video.shape) == (345, 2, 2, 3)
+assert float(guide_motion_video[0, 0, 0, 0]) == 323
+assert float(guide_motion_audio["waveform"][0, 0, 0]) == 3230
+assert guide_motion_detail == (
+    "@performance sequential frames 323:668 (origin scene 1)")
+
+large_motion_video = chain.torch.zeros((5, 512, 640, 3))
+compact_motion = chain.MiniMaxH3TaggedMotionReference().add(
+    large_motion_video, "compact_motion", "<Subject 1>",
+    "coarse full-body motion", "384", "", "restart_each_scene")[0]
+assert tuple(compact_motion["entries"][0]["value"].shape) == (
+    5, 384, 480, 3)
+
+assert "references" in chain.MiniMaxH3TaggedReferenceToVideo.INPUT_TYPES()[
+    "required"]
+tagged_optional = chain.MiniMaxH3TaggedReferenceToVideo.INPUT_TYPES()["optional"]
+assert tagged_optional["semantic_anchor_mode"][0] == [
+    "timestamped_video", "picture_storyboard"]
+assert list(tagged_optional).index("semantic_anchor_size") < list(
+    tagged_optional).index("semantic_anchor_mode")
+assert chain.MiniMaxH3TaggedReferenceToVideo.VALIDATE_INPUTS(
+    semantic_anchor_mode="unsupported") == (
+        "Semantic anchor mode must be timestamped_video or "
+        "picture_storyboard; got 'unsupported'.")
+assert tagged_optional["semantic_anchor_size"][0] == [
+    "384", "512", "768", "1024", "1280", "source"]
+assert tagged_optional["conditioning_backend"][0] == [
+    "native_ref2va", "external_refmod"]
+assert tagged_optional["conditioning_backend"][1]["default"] == (
+    "native_ref2va")
+assert chain.MiniMaxH3TaggedReferenceToVideo.RETURN_NAMES[-1] == (
+    "refmod_sources")
+assert chain.MiniMaxH3TaggedReferenceToVideo.RETURN_TYPES[-1] == "H3_REF_LIST"
+assert chain.MiniMaxH3TaggedReferenceToVideo.VALIDATE_INPUTS(
+    conditioning_backend="unknown") == (
+        "Tagged conditioning backend must be native_ref2va or "
+        "external_refmod; got 'unknown'.")
+assert "reference_schedule" not in (
+    chain.MiniMaxH3TaggedReferenceToVideo.INPUT_TYPES()["required"])
+merged_schema = chain.MiniMaxH3CurrentTaggedReferenceScene.INPUT_TYPES()
+assert list(merged_schema["required"]) == [
+    "state", "clip", "vae", "audio_vae", "references"]
+assert list(merged_schema["optional"]) == ["options"]
+assert "source_audio" not in merged_schema["required"]
+assert "source_audio" not in merged_schema["optional"]
+assert chain.MiniMaxH3CurrentTaggedReferenceScene.RETURN_NAMES == (
+    "state", "positive", "latent", "scene_data")
+assert chain.MiniMaxH3CurrentTaggedReferenceScene.RETURN_TYPES[-1] == (
+    "H3_SCENE_DATA")
+assert chain.MiniMaxH3SceneDataExtract.RETURN_TYPES == ("*",)
+assert chain.MiniMaxH3SceneDataExtract.INPUT_TYPES()["required"]["field"][0][
+    0] == "RefMod sources"
+for modern_class in (
+        chain.MiniMaxH3TaggedSceneOptions,
+        chain.MiniMaxH3CurrentTaggedScenePack,
+        chain.MiniMaxH3CurrentTaggedReferenceScene,
+        chain.MiniMaxH3SceneDataExtract):
+    for section in ("required", "optional"):
+        for input_spec in modern_class.INPUT_TYPES().get(section, {}).values():
+            assert str(input_spec[1].get("tooltip") or "").strip()
+    assert len(modern_class.OUTPUT_TOOLTIPS) == len(modern_class.RETURN_TYPES)
+
+scene_data_state = {
+    "index": 1,
+    "plan": {
+        "version": chain.PLAN_VERSION,
+        "shots": [{"id": "scene_01"}],
+    },
+}
+scene_data = chain.MiniMaxH3CurrentTaggedScenePack().pack(
+    scene_data_state, 1, 2, "scene_01", "Scene prompt", 42, 124, 20,
+    1344, 768, 0.0, 5.0, None, "ready", "Compiled prompt",
+    "@look -> <Picture 1>", "fingerprint", ["visual"],
+    chain.MiniMaxH3TaggedSceneOptions().options()[0])[0]
+assert scene_data["version"] == chain.SCENE_DATA_VERSION
+assert scene_data["refmod_sources"] == ["visual"]
+assert scene_data["conditioning_backend"] == "native_ref2va"
+assert chain.MiniMaxH3SceneDataExtract().extract(
+    scene_data, "RefMod sources") == (["visual"],)
+assert chain.MiniMaxH3SceneDataExtract().extract(
+    scene_data, "Noise seed") == (42,)
+try:
+    chain.MiniMaxH3CurrentTaggedReferenceScene().expand(
+        {"index": 1, "plan": {"version": 1, "shots": [{}]}},
+        "clip", "video-vae", "audio-vae", tagged)
+except ValueError as exc:
+    assert "legacy 0.4" in str(exc)
+else:
+    raise AssertionError("merged scene node accepted a legacy Plan contract")
+conditioning = object()
+priority_result = chain.MiniMaxH3PatchPriority().claim(conditioning)
+assert priority_result == (conditioning, "test patch owner")
+
+original_output_root = chain._output_root
+original_launch_directory = chain._launch_directory
+try:
+    with tempfile.TemporaryDirectory() as output_root:
+        opened_paths = []
+        chain._output_root = lambda: output_root
+        chain._launch_directory = lambda path: (
+            opened_paths.append(path) or True, None)
+        folder_result = chain._open_run_output_directory("Project Name")
+        expected_folder = pathlib.Path(
+            output_root, "h3_chains", "Project_Name")
+        assert folder_result["opened"] is True
+        assert pathlib.Path(folder_result["path"]) == expected_folder
+        assert expected_folder.is_dir()
+        assert opened_paths == [str(expected_folder)]
+        chain._launch_directory = lambda _path: (False, "headless host")
+        fallback_result = chain._open_run_output_directory("Project Name")
+        assert fallback_result["opened"] is False
+        assert fallback_result["error"] == "headless host"
+        try:
+            chain._open_run_output_directory("../../")
+        except ValueError as exc:
+            assert "run_name" in str(exc)
+        else:
+            raise AssertionError("unsafe empty run_name was accepted")
+finally:
+    chain._output_root = original_output_root
+    chain._launch_directory = original_launch_directory
+
+i2va_workflow = json.loads((
+    ROOT / "example_workflows" / "Archive" /
+    "Looping Single Image I2VA 20s V2 - MiniMax H3.json"
+).read_text(encoding="utf-8"))
+i2va_plan_node = next(node for node in i2va_workflow["nodes"]
+                       if node.get("type") == "MiniMaxH3ChainPlan")
+context_choices = chain.MiniMaxH3ChainPlan.INPUT_TYPES()["required"][
+    "context_length"][0]
+assert context_choices == [
+    1, 5, 22, 39, 56, 73, 90, 107, 124,
+    141, 158, 175, 192, 209, 226, 243,
+]
+normalized = chain.MiniMaxH3ChainPlan().build(
+    *i2va_plan_node["widgets_values"])[0]
+assert [shot["raw_frames"] for shot in normalized["shots"]] == [243, 243]
+assert [shot["delivered_frames"] for shot in normalized["shots"]] == [243, 238]
+assert normalized["total_delivered_frames"] == 481
+assert normalized["total_delivered_frames"] / chain.FPS > 20
+assert normalized["compatibility"]["context_length"] == 5
+assert "<Picture 1>" in normalized["shots"][0]["scene_prompt"]
+assert "<Picture" not in normalized["shots"][1]["scene_prompt"]
+
+external_plan_json = json.dumps({
+    "prompt_prefix": "Externally directed continuity.",
+    "shots": [{
+        "id": "external_scene",
+        "prompt": "This scene came from the connected STRING input.",
+        "length": 124,
+        "seed": 987654321,
+    }],
+})
+external_normalized = chain.MiniMaxH3ChainPlan().build(
+    *i2va_plan_node["widgets_values"],
+    plan_json_input=external_plan_json,
+)[0]
+assert [shot["id"] for shot in external_normalized["shots"]] == [
+    "external_scene"]
+assert external_normalized["shots"][0]["seed"] == 987654321
+assert external_normalized["shots"][0]["prompt"].startswith(
+    "Externally directed continuity.")
+
+empty_external_fallback = chain.MiniMaxH3ChainPlan().build(
+    *i2va_plan_node["widgets_values"],
+    plan_json_input="  \n\t",
+)[0]
+assert empty_external_fallback["plan_hash"] == normalized["plan_hash"]
+try:
+    chain.MiniMaxH3ChainPlan().build(
+        *i2va_plan_node["widgets_values"],
+        plan_json_input="not valid JSON",
+    )
+except ValueError as exc:
+    assert "Plan JSON is invalid" in str(exc)
+else:
+    raise AssertionError("invalid external plan JSON bypassed Plan validation")
+
+gate_node = next(node for node in i2va_workflow["nodes"]
+                 if node.get("type") == "MiniMaxH3ChainFirstSceneImage")
+assert gate_node["inputs"][0]["name"] == "state"
+assert gate_node["inputs"][1]["name"] == "image"
+opening_image = object()
+gate = chain.MiniMaxH3ChainFirstSceneImage()
+first_result = gate.select({"index": 1}, opening_image)
+later_result = gate.select({"index": 2}, opening_image)
+assert first_result[:2] == (opening_image, True)
+assert later_result[:2] == (None, False)
+last_target = object()
+assert gate.select({"index": 1}, opening_image, last_target)[3] is last_target
+assert gate.select({"index": 2}, opening_image, last_target)[3] is last_target
+assert gate.INPUT_TYPES()["optional"]["last_frame"][0] == "IMAGE"
+assert gate.RETURN_NAMES[-1] == "last_frame"
+
+frame_a = object()
+frame_b = object()
+switch = chain.MiniMaxH3ChainFrameIndexSwitch()
+assert switch.select(1, frame_b, frame_2=frame_a)[:2] == (frame_b, 1)
+assert switch.select(2, frame_b, frame_2=frame_a)[:2] == (frame_a, 2)
+assert switch.select(3, frame_b, frame_2=frame_a)[:2] == (frame_b, 1)
+assert switch.INPUT_TYPES()["optional"]["frame_8"][0] == "IMAGE"
+
+links = {link[0]: link for link in i2va_workflow["links"]}
+nodes = {node["id"]: node for node in i2va_workflow["nodes"]}
+for node in nodes.values():
+    for slot, input_spec in enumerate(node.get("inputs", [])):
+        link_id = input_spec.get("link")
+        if link_id is None:
+            continue
+        assert link_id in links
+        assert links[link_id][3:5] == [node["id"], slot]
+    for slot, output_spec in enumerate(node.get("outputs", [])):
+        for link_id in output_spec.get("links") or []:
+            assert link_id in links
+            assert links[link_id][1:3] == [node["id"], slot]
+i2v_node = next(node for node in nodes.values()
+                 if node.get("type") == "MiniMaxH3ImageToVideo")
+assert next(item for item in i2v_node["inputs"]
+            if item["name"] == "first_frame")["link"] is not None
+assert next(item for item in i2v_node["inputs"]
+            if item["name"] == "last_frame")["link"] is None
+
+print("H3 scheduler: aliases, Plan guidance, and looping I2VA workflow pass")
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_reference_video_fade_unit_test.py b/ComfyUI-MiniMaxH3-Context-Loop/tests/_reference_video_fade_unit_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..ee0c08cdc3922a9b9537a6080e45eb2e9077f933
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_reference_video_fade_unit_test.py
@@ -0,0 +1,214 @@
+#!/usr/bin/env python3
+"""Focused CPU tests for schedule-aware native H3 video-reference fading."""
+
+import copy
+import importlib.util
+import pathlib
+import sys
+import types
+
+import torch
+
+
+ROOT = pathlib.Path(__file__).resolve().parents[1]
+PACKAGE_NAME = "h3_reference_video_fade_test_package"
+package = types.ModuleType(PACKAGE_NAME)
+package.__path__ = [str(ROOT)]
+sys.modules[PACKAGE_NAME] = package
+
+
+def load_module(name):
+    qualified = PACKAGE_NAME + "." + name
+    spec = importlib.util.spec_from_file_location(
+        qualified, ROOT / (name + ".py"))
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[qualified] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+fade = load_module("reference_video_fade")
+
+
+schedule = torch.tensor([1.0, 0.75, 0.5, 0.25, 0.0])
+assert fade.schedule_progress(1.0, schedule) == 0.0
+assert fade.schedule_progress(0.5, schedule) == 0.5
+assert fade.schedule_progress(0.375, schedule) == 0.625
+assert fade.schedule_progress(0.0, schedule) == 1.0
+assert fade.schedule_progress(float("nan"), schedule) is None
+
+assert fade.reference_strength(0.49, 0.5, 0.0) == 1.0
+assert abs(fade.reference_strength(0.75, 0.5, 0.0) - 0.5) < 1e-7
+assert fade.reference_strength(1.0, 0.5, 0.15) == 0.15
+assert fade.resolve_reference_video_fade_preset(
+    "balanced", 0.1, 0.1) == (0.67, 0.20)
+assert fade.resolve_reference_video_fade_preset(
+    "custom", 0.6, 0.3) == (0.6, 0.3)
+
+
+layout = types.SimpleNamespace(segments=(
+    (0, 2, "text"),
+    (2, 4, "ref_img"),       # native still picture: never faded
+    (4, 8, "ref_img"),       # native video
+    (8, 9, "ref_audio"),
+    (9, 12, "ref_img"),      # native video+audio
+    (12, 14, "ref_audio"),   # standalone reference audio
+    (14, 16, "audio"),       # target audio
+    (16, 22, "video"),       # target video
+))
+payload = {
+    "layout": layout,
+    "refs": (
+        {"kind": "image"},
+        {"kind": "video"},
+        {"kind": "video_audio"},
+        {"kind": "audio"},
+    ),
+}
+ranges, sequence_length = fade.reference_video_ranges(payload)
+assert ranges == ((4, 8), (9, 12))
+assert sequence_length == 22
+
+# Refuse an unknown row layout instead of accidentally fading a still picture
+# or a target stream.
+bad_payload = {
+    "layout": types.SimpleNamespace(segments=((0, 2, "text"),
+                                               (2, 4, "ref_img"),
+                                               (4, 8, "video"))),
+    "refs": ({"kind": "image"}, {"kind": "video"}),
+}
+assert fade.reference_video_ranges(bad_payload)[0] == ()
+
+# The full schedule keeps a split tail at global progress 0.75. A local tail
+# schedule [0.25, 0] would incorrectly call that progress 0 without override.
+state = fade._ReferenceVideoFadeState(
+    0.5, 0.0, schedule_override=schedule)
+captured_diffusion = {}
+
+
+def diffusion_executor(*args, **kwargs):
+    captured_diffusion.update(kwargs)
+    return "diffusion-ok"
+
+
+assert state.diffusion_model_wrapper(
+    diffusion_executor,
+    "x",
+    torch.tensor([250.0]),
+    "context",
+    transformer_options={"sample_sigmas": torch.tensor([0.25, 0.0])},
+    minimax_payload=payload,
+) == "diffusion-ok"
+assert abs(state.current_progress - 0.75) < 1e-7
+assert abs(state.current_strength - 0.5) < 1e-7
+assert state.reference_ranges == ((4, 8), (9, 12))
+assert captured_diffusion["minimax_payload"] is payload
+
+# Only the two video-reference V slices are attenuated. The prior optimized
+# attention override remains the executor, which is the SolAttn/CK composition
+# contract used by the real node.
+prior_capture = {}
+
+
+def prior_override(original, q, k, v, heads, **kwargs):
+    prior_capture["v"] = v.clone()
+    prior_capture["kwargs"] = kwargs
+    return "prior-ok"
+
+
+override = state.make_attention_override(prior_override)
+q = torch.ones((1, 2, 22, 3))
+k = torch.ones_like(q)
+v = torch.ones_like(q)
+assert override(
+    lambda *args, **kwargs: "dense-ok",
+    q, k, v, 2,
+    skip_reshape=True,
+    transformer_options={"test": True},
+) == "prior-ok"
+seen = prior_capture["v"]
+assert torch.equal(seen[..., :4, :], torch.ones_like(seen[..., :4, :]))
+assert torch.equal(
+    seen[..., 4:8, :], torch.full_like(seen[..., 4:8, :], 0.5))
+assert torch.equal(seen[..., 8:9, :], torch.ones_like(seen[..., 8:9, :]))
+assert torch.equal(
+    seen[..., 9:12, :], torch.full_like(seen[..., 9:12, :], 0.5))
+assert torch.equal(seen[..., 12:, :], torch.ones_like(seen[..., 12:, :]))
+assert state.gated_attention_calls == 1
+
+# The shorter text-token refiner attention must pass through untouched even
+# while the main packed-sequence gate is active.
+short_v = torch.ones((1, 2, 2, 3))
+assert override(
+    lambda *args, **kwargs: "dense-ok",
+    torch.ones_like(short_v), torch.ones_like(short_v), short_v, 2,
+    skip_reshape=True,
+) == "prior-ok"
+assert torch.equal(prior_capture["v"], torch.ones_like(short_v))
+assert state.gated_attention_calls == 1
+
+
+class ModelType:
+    name = "FLOW_AV"
+
+
+class InnerModel:
+    model_type = ModelType()
+
+
+class FakeModel:
+    def __init__(self):
+        self.model = InnerModel()
+        self.model_options = {"transformer_options": {
+            "optimized_attention_override": prior_override,
+        }}
+        self.wrappers = []
+
+    def clone(self):
+        cloned = FakeModel()
+        cloned.model_options = copy.copy(self.model_options)
+        cloned.model_options["transformer_options"] = copy.copy(
+            self.model_options.get("transformer_options", {}))
+        return cloned
+
+    def add_wrapper_with_key(self, wrapper_type, key, wrapper):
+        self.wrappers.append((wrapper_type, key, wrapper))
+
+
+comfy = types.ModuleType("comfy")
+patcher_extension = types.ModuleType("comfy.patcher_extension")
+
+
+class WrappersMP:
+    DIFFUSION_MODEL = "diffusion_model"
+
+
+patcher_extension.WrappersMP = WrappersMP
+comfy.patcher_extension = patcher_extension
+sys.modules["comfy"] = comfy
+sys.modules["comfy.patcher_extension"] = patcher_extension
+
+source = FakeModel()
+patched = fade.install_reference_video_fade_model(
+    source, 0.67, 0.20, schedule_override=schedule)
+assert patched is not source
+assert "h3_context_loop_reference_video_fade_recipe" not in (
+    source.model_options)
+recipe = patched.model_options[
+    "h3_context_loop_reference_video_fade_recipe"]
+assert recipe["fade_start"] == 0.67
+assert recipe["end_strength"] == 0.20
+assert recipe["full_schedule_values"] == 5
+assert len(patched.wrappers) == 1
+assert patched.wrappers[0][0:2] == (
+    "diffusion_model", "h3_context_loop_reference_video_fade")
+assert patched.model_options["transformer_options"][
+    "optimized_attention_override"] is not prior_override
+
+# Full is a true bypass: no clone, wrapper, or attention override is added.
+assert fade.install_reference_video_fade_model(source, 1.0, 1.0) is source
+
+node = fade.MiniMaxH3ReferenceVideoFadeModelPatch()
+assert node.patch(source, "full", 0.2, 0.0)[0] is source
+
+print("reference video fade unit test passed")
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_release_audit_async_js_test.mjs b/ComfyUI-MiniMaxH3-Context-Loop/tests/_release_audit_async_js_test.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..2406cc5c59578e02cd34eaf7787737c38b4bf1a9
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_release_audit_async_js_test.mjs
@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+// Run the real asynchronous handlers against deferred network responses.
+// No live canvas, generated media or project files are touched.
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import vm from "node:vm";
+import * as planCore from "../web/h3_chain_plan_core.mjs";
+import {applyAssetBinding} from "../web/h3_run_assets_core.mjs";
+
+const runSource = fs.readFileSync(new URL("../web/h3_chain_run_manager.js", import.meta.url), "utf8");
+const studioSource = fs.readFileSync(new URL("../web/h3_chain_plan_studio.js", import.meta.url), "utf8");
+const tick = async () => { for (let i = 0; i < 16; i++) await Promise.resolve(); };
+function handler(source, name, indent = "    ") {
+    const match = source.match(new RegExp(`^${indent}(?:async )?function ${name}\\([^]*?^${indent}}$`, "m"));
+    assert.ok(match, name);
+    return match[0];
+}
+
+function restoreFixture() {
+    const nodes = new Map();
+    const graph = {getNodeById:id => nodes.get(id), beforeChange() {}, afterChange() {}, setDirtyCanvas() {}};
+    const plan = {id:1, graph, widgets:[{name:"run_name", value:"original"}, {name:"plan_json", value:"original plan"}]};
+    const loader = {id:7, type:"LoadImage", graph, widgets:[{name:"image", value:"original.png"}], outputs:[{type:"IMAGE"}]};
+    const node = {id:9, graph};
+    for (const item of [plan, loader, node]) nodes.set(item.id, item);
+    const state = {busy:false, disposed:false, restoreEpoch:0, watchedSources:new Set()};
+    const requests = [];
+    const context = vm.createContext({
+        state, node, app:{graph}, URLSearchParams, applyAssetBinding,
+        plan, loader, currentPlan:plan, run:{run_name:"archived", asset_count:1},
+        selectedRun:() => context.run, upstreamPlanNode:() => context.currentPlan,
+        status:{}, window:{confirm:() => true, queueMicrotask:fn => fn()},
+        setBusy:value => { state.busy = value; }, renderSelection() {}, syncAssetBindings() {},
+        restoreConnectedPolicyInputs:() => ({unavailable:[]}), refreshRestoredPlanEditors() {},
+        jsonRequest:() => new Promise(resolve => requests.push(resolve)),
+        removed:null, sourceChanged() {},
+    });
+    vm.runInContext([
+        handler(runSource, "widgetByName", ""), handler(runSource, "applyPlanInputs", ""),
+        ...["captureRestoreOperation", "requireCurrentRestore", "loadRun"].map(name => handler(runSource, name)),
+        runSource.match(/^    const activeRunChanged = \(\) => {[^]*?^    };/m)[0],
+        runSource.match(/^    node.onRemoved = function \(\) {[^]*?^    };/m)[0],
+    ].join("\n"), context);
+    const response = {
+        plan_inputs:{run_name:"archived", plan_json:"archived plan"}, warnings:[],
+        assets:{bindings:[{binding_id:"saved-binding", node_id:7, node_type:"LoadImage", output_slot:0,
+            output_type:"IMAGE", widget_name:"image", restore_value:"archived.png"}]},
+    };
+    return {context, graph, nodes, plan, loader, node, state, requests, response};
+}
+
+for (const scenario of ["normal", "subgraph", "switch", "detach", "same-id", "rewire", "run-edit", "prompt-edit", "run-aba", "remove"]) {
+    const f = restoreFixture();
+    if (scenario === "subgraph") f.context.app.graph = {id:"root"};
+    const pending = f.context.loadRun();
+    assert.equal(f.requests.length, 1);
+    const foreignLoader = {id:7, type:"LoadImage", widgets:[{name:"image", value:"other-workflow.png"}], outputs:[{type:"IMAGE"}]};
+    const foreign = {getNodeById:id => id === 7 ? foreignLoader : null, _nodes:[foreignLoader]};
+    if (scenario === "switch" || scenario === "detach") f.context.app.graph = foreign;
+    if (scenario === "detach") { f.node.graph = null; f.plan.graph = null; }
+    if (scenario === "same-id") f.nodes.set(9, {id:9, graph:f.graph});
+    if (scenario === "rewire") f.context.currentPlan = {...f.plan};
+    if (scenario === "run-edit") f.plan.widgets[0].value = "another-run";
+    if (scenario === "prompt-edit") f.plan.widgets[1].value = "newer prompt";
+    if (scenario === "run-aba") {
+        f.plan.widgets[0].value = "temporary";
+        vm.runInContext("activeRunChanged()", f.context);
+        f.plan.widgets[0].value = "original";
+        vm.runInContext("activeRunChanged()", f.context);
+    }
+    if (scenario === "remove") f.node.onRemoved();
+    const before = JSON.stringify(f.plan.widgets);
+    f.requests[0](f.response);
+    await pending;
+    assert.equal(foreignLoader.widgets[0].value, "other-workflow.png", scenario);
+    if (scenario === "normal" || scenario === "subgraph") {
+        assert.equal(f.loader.widgets[0].value, "archived.png");
+        assert.equal(f.plan.widgets[1].value, "archived plan");
+    } else {
+        assert.equal(JSON.stringify(f.plan.widgets), before, scenario);
+        assert.equal(f.loader.widgets[0].value, "original.png", scenario);
+        assert.match(f.context.status.textContent, /load cancelled/, scenario);
+    }
+}
+
+function editorialFixture() {
+    const requests = [], timers = new Map(); let timerId = 0;
+    const state = {plan:{shots:[{id:"one", prompt:[], length:345}], chapters:[]},
+        editorial:{}, checkpoints:new Map()};
+    const context = vm.createContext({
+        ...planCore, state, structuredClone, node:{properties:{}}, alternateTakeWidget:null,
+        currentRun:"run_a", runName:() => context.currentRun,
+        dirty() {}, renderStatus() {}, cacheStudioPresentation() {}, flushHistoryDraft:async () => {},
+        console:{warn() {}}, projectMutationOptions:async (_node, _run, options) => options,
+        setTimeout:fn => { timers.set(++timerId, fn); return timerId; }, clearTimeout:id => timers.delete(id),
+        api:{fetchApi:(_route, options) => new Promise(resolve => requests.push({body:JSON.parse(options.body), resolve}))},
+    });
+    vm.runInContext(["normalizedEditorial", "editorialPayload", "applyEditorialPayload", "editorialSignature",
+        "syncAlternateTakeWidget", "persistEditorial", "scheduleEditorialSave", "flushProjectWrites"]
+        .map(name => handler(studioSource, name)).join("\n"), context);
+    const incoming = {run_name:"run_a", revision:"a".repeat(32), chapters:[], scene_order:[{scene:1, scene_id:"one"}],
+        placements:[], trims:[], locked_scene_ids:[], replacements:[], alternate_draft:null,
+        subtitles:{mode:"off", asset_id:"", offset_seconds:0}};
+    context.applyEditorialPayload(incoming);
+    return {context, state, requests, incoming,
+        edit(frame) { state.editorial.placements = [{scene:1, scene_id:"one", start_frame:frame}]; context.scheduleEditorialSave(); },
+        async fire() { const work = [...timers.values()]; timers.clear(); for (const fn of work) fn(); await tick(); },
+        async respond(index, revision, ok = true) {
+            requests[index].resolve({ok, status:ok ? 200 : 409, json:async () => ok
+                ? {editorial:{...requests[index].body, revision}}
+                : {error:"Newer editorial data was not overwritten."}});
+            await tick();
+        },
+    };
+}
+
+{
+    const f = editorialFixture();
+    f.edit(24); await f.fire();
+    f.edit(48); await f.fire();
+    assert.equal(f.requests.length, 1, "The second edit must wait for the first save");
+    assert.equal(f.requests[0].body.base_revision, "a".repeat(32));
+    await f.respond(0, "b".repeat(32));
+    assert.equal(f.requests.length, 2);
+    assert.equal(f.requests[1].body.base_revision, "b".repeat(32));
+    assert.equal(f.requests[1].body.placements[0].start_frame, 48);
+    await f.respond(1, "c".repeat(32));
+    assert.equal(f.state.editorial.placements[0].start_frame, 48);
+    assert.equal(f.state.editorial.revision, "c".repeat(32));
+}
+{
+    const f = editorialFixture();
+    f.edit(24);
+    const flush = f.context.flushProjectWrites("run_a");
+    await tick();
+    assert.equal(f.requests.length, 1, "Closing/switching flushes the debounced edit");
+    f.context.currentRun = "run_b";
+    f.state.editorialRun = "run_b";
+    f.state.editorial = {revision:"d".repeat(32)};
+    await f.respond(0, "b".repeat(32)); await flush;
+    assert.equal(f.requests[0].body.run_name, "run_a");
+    assert.equal(f.state.editorial.revision, "d".repeat(32), "Old response cannot alter new Run");
+    await f.fire();
+    assert.equal(f.requests.length, 1, "The cleared debounce cannot send twice");
+}
+{
+    const f = editorialFixture();
+    f.edit(24); await f.fire();
+    f.edit(48); await f.fire();
+    await f.respond(0, "", false);
+    assert.equal(f.requests[1].body.base_revision, "a".repeat(32), "A conflict must never advance the read revision");
+    await f.respond(1, "", false);
+    assert.equal(f.state.editorial.placements[0].start_frame, 48);
+    assert.equal(f.state.editorial.revision, "a".repeat(32));
+    assert.match(f.state.editorialSaveError, /not overwritten/);
+    assert.equal(f.context.applyEditorialPayload(f.incoming), false,
+        "Periodic refresh must not erase failed, unsaved edits");
+    assert.equal(f.state.editorial.placements[0].start_frame, 48);
+}
+{
+    const f = editorialFixture();
+    f.edit(24); await f.fire();
+    const getEpoch = f.state.editorialEditEpoch;
+    await f.respond(0, "b".repeat(32));
+    assert.equal(f.context.applyEditorialPayload(f.incoming, getEpoch), false,
+        "A GET started before the save committed must be ignored");
+    assert.equal(f.state.editorial.placements[0].start_frame, 24);
+}
+{
+    const f = editorialFixture();
+    f.edit(24); await f.fire();
+    f.edit(48);
+    const flush = f.context.flushProjectWrites("run_a");
+    await tick();
+    f.context.currentRun = "run_b";
+    f.state.editorialRun = "run_b";
+    f.state.editorial = {};
+    // Return to A before either old POST finishes (a fresh binding).
+    f.context.currentRun = "run_a";
+    f.state.editorialRun = "run_a";
+    f.state.editorial = {revision:"d".repeat(32)};
+    await f.respond(0, "b".repeat(32));
+    assert.equal(f.requests[1].body.run_name, "run_a");
+    assert.equal(f.requests[1].body.base_revision, "b".repeat(32),
+        "Queued old-Run saves inherit their own preceding commit, not the new view");
+    await f.respond(1, "c".repeat(32)); await flush;
+    assert.equal(f.state.editorial.revision, "d".repeat(32),
+        "An ABA Run switch must not adopt an old view's revision");
+}
+console.log("Release audit: archive restore isolation, editorial ordering, flush and revision conflicts pass");
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_review_length_unit_test.py b/ComfyUI-MiniMaxH3-Context-Loop/tests/_review_length_unit_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..fc65f65d75240bf10d28ccf317f4e46141542550
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_review_length_unit_test.py
@@ -0,0 +1,703 @@
+#!/usr/bin/env python3
+"""Review retry duration updates the complete prepared Plan timeline."""
+
+import asyncio
+import importlib.util
+import json
+import pathlib
+import sys
+import types
+from contextlib import nullcontext
+
+import torch
+
+
+ROOT = pathlib.Path(__file__).resolve().parents[1]
+PACKAGE = "h3_review_length_unit"
+
+folder_paths = types.ModuleType("folder_paths")
+folder_paths.get_output_directory = lambda: str(ROOT)
+folder_paths.get_temp_directory = lambda: str(ROOT)
+folder_paths.get_input_directory = lambda: str(ROOT)
+folder_paths.get_annotated_filepath = lambda value: str(value)
+sys.modules["folder_paths"] = folder_paths
+
+server = types.ModuleType("server")
+server.PromptServer = type("PromptServer", (), {"instance": None})
+sys.modules["server"] = server
+
+package = types.ModuleType(PACKAGE)
+package.__path__ = [str(ROOT)]
+sys.modules[PACKAGE] = package
+
+shared_nodes = types.ModuleType(PACKAGE + ".nodes")
+shared_nodes.MiniMaxH3MotionContext = object
+shared_nodes._claim_inline_patch_ownership = lambda _conditioning=None: "test patch owner"
+shared_nodes._prepare_native_guide_conditioning = lambda *args: None
+shared_nodes._resize = lambda *args: None
+shared_nodes._streams_from_latent = lambda *args: None
+sys.modules[shared_nodes.__name__] = shared_nodes
+
+spec = importlib.util.spec_from_file_location(
+    PACKAGE + ".chain_nodes", ROOT / "chain_nodes.py")
+chain = importlib.util.module_from_spec(spec)
+sys.modules[spec.name] = chain
+spec.loader.exec_module(chain)
+
+
+def shot(index, raw_frames, delivered_frames, start):
+    prompt = "Scene %d." % index
+    return {
+        "index": index,
+        "id": "scene_%d" % index,
+        "scene_prompt": prompt,
+        "prompt": prompt,
+        "prompt_hash": "prompt-%d" % index,
+        "seed": index,
+        "steps": 20,
+        "raw_frames": raw_frames,
+        "delivered_frames": delivered_frames,
+        "generation_start_frame": start,
+        "audio_start_seconds": start / 24,
+        "audio_duration_seconds": raw_frames / 24,
+    }
+
+
+plan = {
+    "version": 1,
+    "run_name": "review_length",
+    "prompt_prefix": "",
+    "shots": [shot(1, 39, 39, 0), shot(2, 56, 34, 17),
+              shot(3, 39, 17, 51)],
+    "compatibility": {
+        "fps": 24,
+        "width": 960,
+        "height": 544,
+        "context_length": 22,
+        "anchor_mode": "head",
+        "audio_mode": "generated_audio",
+        "source_audio_hash": "none",
+    },
+    "total_delivered_frames": 90,
+    "plan_hash": "prepared-hash",
+    "base_plan_hash": "base-hash",
+}
+
+revised = chain._plan_with_review_revision(
+    plan, 2, "Longer second scene.", 999, 73)
+
+assert revised["shots"][0]["raw_frames"] == 39
+assert revised["shots"][1]["raw_frames"] == 73
+assert revised["shots"][1]["delivered_frames"] == 51
+assert revised["shots"][1]["generation_start_frame"] == 17
+assert revised["shots"][2]["generation_start_frame"] == 68
+assert revised["shots"][2]["audio_start_seconds"] == 68 / 24
+assert revised["total_delivered_frames"] == 107
+assert revised["review_overrides"]["2"]["raw_frames"] == 73
+assert revised["base_plan_hash"] == plan["base_plan_hash"]
+assert chain._history_hash(revised, 1) == chain._history_hash(plan, 1)
+assert chain._history_hash(revised, 2) != chain._history_hash(plan, 2)
+
+external = {
+    **plan,
+    "shots": [shot(1, 56, 34, -22), shot(2, 39, 17, 12)],
+    "compatibility": {
+        **plan["compatibility"],
+        "external_context_frames": 22,
+        "external_context_hash": "external-hash",
+    },
+    "total_delivered_frames": 51,
+}
+external["shots"][0]["external_context_frames"] = 22
+external_revision = chain._plan_with_review_revision(
+    external, 1, "Longer imported-video continuation.", 777, 73)
+assert external_revision["shots"][0]["generation_start_frame"] == -22
+assert external_revision["shots"][0]["delivered_frames"] == 51
+assert external_revision["shots"][1]["generation_start_frame"] == 29
+assert external_revision["total_delivered_frames"] == 68
+
+try:
+    chain._plan_with_review_revision(plan, 2, "Too short.", 999, 22)
+except ValueError as exc:
+    assert "17k+5" in str(exc) or "continuation overlap" in str(exc)
+else:
+    raise AssertionError("Review retry accepted an invalid H3 length")
+
+
+class RetryRequest:
+    def __init__(self, token, length):
+        self.token = token
+        self.length = length
+
+    async def json(self):
+        return {
+            "token": self.token,
+            "action": "retry",
+            "scene_prompt": "Route retry.",
+            "seed": "123",
+            "length": self.length,
+        }
+
+
+async def check_route_validation():
+    token = "review-length-test"
+    loop = asyncio.get_running_loop()
+    future = loop.create_future()
+    chain._PENDING_REVIEWS[token] = {
+        "future": future,
+        "loop": loop,
+        "plan": plan,
+        "public": {"clip_index": 2, "prompt_prefix": ""},
+        "current_seed": 2,
+        "current_length": 56,
+    }
+    try:
+        rejected = await chain._submit_review_decision(
+            RetryRequest(token, 39))
+        assert rejected.status == 400
+        assert "next clip requires" in json.loads(rejected.text)["error"]
+        assert not future.done()
+
+        accepted = await chain._submit_review_decision(
+            RetryRequest(token, 73))
+        assert accepted.status == 200
+        accepted_body = json.loads(accepted.text)
+        assert accepted_body["length"] == 73
+        assert accepted_body["scene_prompt"] == "Route retry."
+        await asyncio.sleep(0)
+        assert future.result()["raw_frames"] == 73
+        assert future.result()["scene_prompt"] == "Route retry."
+    finally:
+        chain._PENDING_REVIEWS.pop(token, None)
+
+
+asyncio.run(check_route_validation())
+
+
+assert chain._review_candidate_target(1) == 1
+assert chain._review_candidate_target("10") == 10
+try:
+    chain._review_candidate_target(21)
+except ValueError as exc:
+    assert "between 1 and 20" in str(exc)
+else:
+    raise AssertionError("Review Gate accepted too many candidates")
+
+
+def candidate_segment(revision, seed):
+    selected_plan = chain._plan_with_review_revision(
+        plan, 2, "Scene 2.", seed, 56)
+    return {
+        "index": 2,
+        "id": "scene_2",
+        "revision": revision,
+        "segment": "segments/%s.mp4" % revision,
+        "checkpoint": "checkpoints/%s.safetensors" % revision,
+        "metadata": "checkpoints/clip_0002.json",
+        "revision_metadata": "checkpoints/%s.json" % revision,
+        "raw_frames": 56,
+        "delivered_frames": 34,
+        "scene_prompt": "Scene 2.",
+        "prompt": "Scene 2.",
+        "prompt_hash": selected_plan["shots"][1]["prompt_hash"],
+        "history_hash": chain._history_hash(selected_plan, 2),
+        "seed": str(seed),
+        "steps": 20,
+        "checkpoint_sha256": revision,
+    }
+
+
+async def check_candidate_batch():
+    sent = []
+
+    class BatchServerInstance:
+        client_id = "candidate-client"
+
+        def send_sync(self, event, payload, client_id=None):
+            sent.append((event, payload, client_id))
+
+    original_server = chain.PromptServer
+    original_review_video = chain._review_video
+    original_load_revision = chain._load_checkpoint_revision
+    original_prune_candidates = chain._prune_review_candidates
+    original_select_candidate = chain._select_review_candidate
+    original_resume_revisions = chain._review_candidate_resume_revisions
+    original_write_archives = chain._write_run_archives
+    cleanup_calls = []
+    archive_calls = []
+    chain.PromptServer = type(
+        "BatchServer", (), {"instance": BatchServerInstance()})
+    chain._review_video = lambda _plan, segment, _audio, retain_previous=False: (
+        {"filename": "%s.mp4" % segment["revision"],
+         "subfolder": "candidates", "type": "output"}, True, "")
+    chain._prune_review_candidates = (
+        lambda candidate_plan, scene, candidates, kept: (
+            cleanup_calls.append((candidate_plan, scene, candidates, kept)) or {
+                "kept": list(kept),
+                "deleted": [],
+                "reclaimed_bytes": 0,
+                "warnings": [],
+            }))
+    chain._review_candidate_resume_revisions = (
+        lambda _run_name, scene, revision: [
+            {"scene": number,
+             "revision": revision if number == scene else "%032x" % number}
+            for number in range(1, scene + 1)])
+    chain._write_run_archives = lambda selected_plan: archive_calls.append(
+        selected_plan)
+    automatic = candidate_segment("d" * 32, 2)
+    automatic_result = await asyncio.wait_for(
+        chain.MiniMaxH3ChainReview().review(
+            {"plan": plan, "index": 2,
+             "segments": [{"revision": "parent"}]},
+            automatic, True, False, 0.0, False, False, "none",
+            candidate_count=2, unique_id="review-node"),
+        timeout=2.0)
+    assert not chain._PENDING_REVIEWS
+    automatic_decision = automatic_result["result"][0][
+        "_h3_review_decision"]
+    assert automatic_decision["action"] == "retry"
+    assert automatic_decision["candidate_batch"]["target"] == 2
+    assert len(automatic_decision["candidate_batch"]["candidates"]) == 1
+    assert automatic_decision["candidate_batch"]["kept_revisions"] == []
+    automatic_token = automatic_decision["candidate_batch"]["batch_token"]
+    assert automatic_token in chain._ACTIVE_CANDIDATE_BATCHES
+    progress = chain._ACTIVE_CANDIDATE_BATCHES[automatic_token]["public"]
+    assert progress["candidate_batch_active"] is True
+    assert progress["pending_decision"] is False
+    assert progress["candidate_index"] == 1
+    assert progress["end_clip"] == len(plan["shots"])
+    assert [item["revision"] for item in progress["candidates"]] == [
+        automatic["revision"]]
+    assert "automatically generating candidate 2" in automatic_result[
+        "result"][1]
+
+    class KeepAutomaticCandidate:
+        async def json(self):
+            return {
+                "token": automatic_token,
+                "action": "update",
+                "candidate_revisions": [automatic["revision"]],
+            }
+
+    keep_response = await chain._submit_candidate_batch_command(
+        KeepAutomaticCandidate())
+    assert keep_response.status == 200
+    assert chain._ACTIVE_CANDIDATE_BATCHES[automatic_token][
+        "kept_revisions"] == [automatic["revision"]]
+
+    class PauseAutomaticBatch:
+        async def json(self):
+            return {
+                "token": automatic_token,
+                "action": "pause",
+                "candidate_revisions": [automatic["revision"]],
+            }
+
+    pause_response = await chain._submit_candidate_batch_command(
+        PauseAutomaticBatch())
+    assert pause_response.status == 200
+    assert chain._ACTIVE_CANDIDATE_BATCHES[automatic_token]["command"] == {
+        "action": "pause",
+        "candidate_revision": "",
+        "kept_revisions": [automatic["revision"]],
+    }
+    chain._ACTIVE_CANDIDATE_BATCHES.clear()
+
+    early_automatic = candidate_segment("e" * 32, 2)
+    early_automatic_result = await chain.MiniMaxH3ChainReview().review(
+        {"plan": plan, "index": 2,
+         "segments": [{"revision": "parent"}]},
+        early_automatic, True, False, 0.0, False, False, "none",
+        candidate_count=2, unique_id="review-node")
+    early_decision = early_automatic_result["result"][0][
+        "_h3_review_decision"]
+    early_token = early_decision["candidate_batch"]["batch_token"]
+
+    class AcceptAutomaticBatch:
+        async def json(self):
+            return {
+                "token": early_token,
+                "action": "accept",
+                "candidate_revision": early_automatic["revision"],
+                "candidate_revisions": [],
+            }
+
+    accept_response = await chain._submit_candidate_batch_command(
+        AcceptAutomaticBatch())
+    assert accept_response.status == 200
+    accept_body = json.loads(accept_response.text)
+    assert accept_body["resume_scene"] == 3
+    assert accept_body["resume_revisions"][-1] == {
+        "scene": 2, "revision": early_automatic["revision"]}
+    next_plan = chain._plan_with_review_revision(
+        plan, 2, "Scene 2.", early_decision["seed"], 56)
+    next_candidate = candidate_segment("f" * 32, early_decision["seed"])
+
+    def select_automatic(selected_state, current_segment, decision):
+        assert current_segment == next_candidate
+        assert decision["candidate_revision"] == early_automatic["revision"]
+        accepted_state = dict(selected_state)
+        accepted_state["plan"] = chain._plan_with_review_revision(
+            plan, 2, "Scene 2.", 2, 56)
+        accepted_state.pop("candidate_batch", None)
+        return early_automatic, accepted_state
+
+    chain._select_review_candidate = select_automatic
+    accepted_early_result = await asyncio.wait_for(
+        chain.MiniMaxH3ChainReview().review(
+            {"plan": next_plan, "index": 2,
+             "segments": [{"revision": "parent"}],
+             "candidate_batch": early_decision["candidate_batch"]},
+            next_candidate, True, False, 0.0, False, False, "none",
+            candidate_count=2, unique_id="review-node"),
+        timeout=2.0)
+    assert accepted_early_result["result"][0]["revision"] == (
+        early_automatic["revision"])
+    assert not chain._PENDING_REVIEWS
+    assert early_token not in chain._ACTIVE_CANDIDATE_BATCHES
+    assert any(
+        event == "minimax_h3_context_loop_review_resolved"
+        and payload.get("action") == "candidate_batch_approve"
+        for event, payload, _client in sent)
+    chain._select_review_candidate = original_select_candidate
+
+    first = candidate_segment("a" * 32, 2)
+    try:
+        first_task = asyncio.create_task(chain.MiniMaxH3ChainReview().review(
+            {"plan": plan, "index": 2, "segments": [{"revision": "parent"}]},
+            first, True, False, 0.0, False, False, "none",
+            candidate_count=2, review_each_candidate=True,
+            unique_id="review-node"))
+        for _ in range(100):
+            if chain._PENDING_REVIEWS:
+                break
+            await asyncio.sleep(0.01)
+        assert chain._PENDING_REVIEWS
+        first_public = next(iter(chain._PENDING_REVIEWS.values()))["public"]
+        assert first_public["candidate_index"] == 1
+        assert first_public["candidate_generation_complete"] is False
+        assert first_public["candidate_remaining"] == 1
+        assert [item["revision"] for item in first_public["candidates"]] == [
+            first["revision"]]
+
+        class GenerateNext:
+            async def json(self):
+                return {
+                    "token": first_public["token"],
+                    "action": "next_candidate",
+                    "candidate_revisions": [first["revision"]],
+                }
+
+        next_response = await chain._submit_review_decision(GenerateNext())
+        next_body = json.loads(next_response.text)
+        assert next_response.status == 200
+        assert next_body["action"] == "next_candidate"
+        assert next_body["kept_candidate_count"] == 1
+        first_result = await asyncio.wait_for(first_task, timeout=2.0)
+        decision = first_result["result"][0]["_h3_review_decision"]
+        assert decision["action"] == "retry"
+        assert decision["candidate_batch"]["target"] == 2
+        assert len(decision["candidate_batch"]["candidates"]) == 1
+        assert decision["candidate_batch"]["kept_revisions"] == [
+            first["revision"]]
+        assert decision["seed"] != 2
+
+        second_plan = chain._plan_with_review_revision(
+            plan, 2, "Scene 2.", decision["seed"], 56)
+        second = candidate_segment("b" * 32, decision["seed"])
+        state = {
+            "plan": second_plan,
+            "index": 2,
+            "segments": [{"revision": "parent"}],
+            "candidate_batch": decision["candidate_batch"],
+        }
+        chain._load_checkpoint_revision = lambda _run, _scene, revision: (
+            {"segment": first if revision == first["revision"] else second},
+            "candidate.json")
+        task = asyncio.create_task(chain.MiniMaxH3ChainReview().review(
+            state, second, True, False, 0.0, False, False, "none",
+            candidate_count=2, unique_id="review-node"))
+        for _ in range(100):
+            if chain._PENDING_REVIEWS:
+                break
+            await asyncio.sleep(0.01)
+        assert chain._PENDING_REVIEWS
+        public = next(iter(chain._PENDING_REVIEWS.values()))["public"]
+        assert public["candidate_count"] == 2
+        assert public["candidate_generation_complete"] is True
+        assert public["kept_candidate_revisions"] == [first["revision"]]
+        assert [item["revision"] for item in public["candidates"]] == [
+            first["revision"], second["revision"]]
+        token = public["token"]
+
+        class ChooseCurrent:
+            async def json(self):
+                return {"token": token, "action": "approve",
+                        "candidate_revision": second["revision"],
+                        "candidate_revisions": [first["revision"]]}
+
+        response = await chain._submit_review_decision(ChooseCurrent())
+        body = json.loads(response.text)
+        assert response.status == 200
+        assert body["candidate_number"] == 2
+        assert body["kept_candidate_count"] == 2
+        result = await asyncio.wait_for(task, timeout=2.0)
+        assert result["result"][0]["revision"] == second["revision"]
+        assert "selected candidate 2/2" in result["result"][1]
+        assert cleanup_calls
+        assert cleanup_calls[-1][3] == [first["revision"], second["revision"]]
+
+        early = candidate_segment("c" * 32, 2)
+        early_task = asyncio.create_task(chain.MiniMaxH3ChainReview().review(
+            {"plan": plan, "index": 2, "segments": [{"revision": "parent"}]},
+            early, True, False, 0.0, False, False, "none",
+            candidate_count=3, review_each_candidate=True,
+            unique_id="review-node"))
+        for _ in range(100):
+            if chain._PENDING_REVIEWS:
+                break
+            await asyncio.sleep(0.01)
+        early_public = next(iter(chain._PENDING_REVIEWS.values()))["public"]
+        assert early_public["candidate_generation_complete"] is False
+
+        class AcceptEarly:
+            async def json(self):
+                return {
+                    "token": early_public["token"],
+                    "action": "approve",
+                    "candidate_revision": early["revision"],
+                    "candidate_revisions": [],
+                }
+
+        early_response = await chain._submit_review_decision(AcceptEarly())
+        assert early_response.status == 200
+        early_body = json.loads(early_response.text)
+        assert early_body["candidate_number"] == 1
+        assert early_body["candidate_count"] == 3
+        assert early_body["candidate_generated_count"] == 1
+        assert early_body["kept_candidate_count"] == 1
+        early_result = await asyncio.wait_for(early_task, timeout=2.0)
+        assert early_result["result"][0]["revision"] == early["revision"]
+        assert cleanup_calls[-1][3] == [early["revision"]]
+
+        finalize_token = "1" * 32
+        finalize_candidate = candidate_segment("9" * 32, 29)
+        chain._ACTIVE_CANDIDATE_BATCHES[finalize_token] = {
+            "run_name": plan["run_name"],
+            "scene": 2,
+            "target": 3,
+            "plan": plan,
+            "candidates": [{"segment": finalize_candidate}],
+            "kept_revisions": [finalize_candidate["revision"]],
+            "command": {
+                "action": "accept",
+                "candidate_revision": finalize_candidate["revision"],
+                "kept_revisions": [finalize_candidate["revision"]],
+            },
+        }
+
+        class FinalizeAutomaticBatch:
+            async def json(self):
+                return {
+                    "token": finalize_token,
+                    "action": "finalize",
+                    "candidate_revision": finalize_candidate["revision"],
+                }
+
+        finalize_response = await chain._submit_candidate_batch_command(
+            FinalizeAutomaticBatch())
+        assert finalize_response.status == 200
+        assert finalize_token not in chain._ACTIVE_CANDIDATE_BATCHES
+        assert archive_calls[-1]["shots"][1]["seed"] == 29
+        assert cleanup_calls[-1][3] == [finalize_candidate["revision"]]
+    finally:
+        chain._PENDING_REVIEWS.clear()
+        chain._ACTIVE_CANDIDATE_BATCHES.clear()
+        chain.PromptServer = original_server
+        chain._review_video = original_review_video
+        chain._load_checkpoint_revision = original_load_revision
+        chain._prune_review_candidates = original_prune_candidates
+        chain._select_review_candidate = original_select_candidate
+        chain._review_candidate_resume_revisions = original_resume_revisions
+        chain._write_run_archives = original_write_archives
+
+
+asyncio.run(check_candidate_batch())
+
+
+def check_candidate_resume_lineage():
+    original_load = chain._load_checkpoint_revision
+    revisions = {
+        (1, "1" * 32): {
+            "segment": {
+                "index": 1,
+                "revision": "1" * 32,
+                "checkpoint_sha256": "hash-one",
+            },
+        },
+        (2, "2" * 32): {
+            "segment": {
+                "index": 2,
+                "revision": "2" * 32,
+                "checkpoint_sha256": "hash-two",
+                "predecessor_revision": "1" * 32,
+                "predecessor_checkpoint_sha256": "hash-one",
+            },
+        },
+    }
+    chain._load_checkpoint_revision = (
+        lambda _run_name, scene, revision: (
+            revisions[(scene, revision)], "metadata.json"))
+    try:
+        assert chain._review_candidate_resume_revisions(
+            "run", 2, "2" * 32) == [
+                {"scene": 1, "revision": "1" * 32},
+                {"scene": 2, "revision": "2" * 32},
+            ]
+        revisions[(2, "2" * 32)]["segment"][
+            "predecessor_checkpoint_sha256"] = "wrong"
+        try:
+            chain._review_candidate_resume_revisions("run", 2, "2" * 32)
+            raise AssertionError("candidate lineage hash mismatch was accepted")
+        except ValueError as exc:
+            assert "different scene 1 checkpoint" in str(exc)
+    finally:
+        chain._load_checkpoint_revision = original_load
+
+
+check_candidate_resume_lineage()
+
+
+def check_candidate_cleanup():
+    original_manager = chain.CheckpointGraphManager
+    deleted = []
+
+    class FakeManager:
+        def __init__(self, _root):
+            pass
+
+        def deletion_preview(self, run_name, scene, revision):
+            assert run_name == plan["run_name"]
+            assert scene == 2
+            return {"allowed": True, "snapshot": "snapshot-" + revision}
+
+        def delete(self, run_name, scene, revision, snapshot):
+            deleted.append((run_name, scene, revision, snapshot))
+            return {"reclaimed_bytes": 123}
+
+    chain.CheckpointGraphManager = FakeManager
+    try:
+        candidates = [
+            {"segment": candidate_segment("a" * 32, 1)},
+            {"segment": candidate_segment("b" * 32, 2)},
+            {"segment": candidate_segment("c" * 32, 3)},
+        ]
+        cleanup = chain._prune_review_candidates(
+            plan, 2, candidates, ["a" * 32, "c" * 32])
+        assert cleanup["kept"] == ["a" * 32, "c" * 32]
+        assert cleanup["deleted"] == ["b" * 32]
+        assert cleanup["reclaimed_bytes"] == 123
+        assert deleted == [(
+            plan["run_name"], 2, "b" * 32, "snapshot-" + "b" * 32)]
+    finally:
+        chain.CheckpointGraphManager = original_manager
+
+
+check_candidate_cleanup()
+
+
+def check_exact_candidate_selection():
+    current_plan = chain._plan_with_review_revision(
+        plan, 2, "Scene 2.", 999, 56)
+    selected = candidate_segment("c" * 32, 2)
+    metadata = {
+        "compatibility": plan["compatibility"],
+        "segment": selected,
+    }
+    original_load_revision = chain._load_checkpoint_revision
+    original_st_load = chain._st_load
+    original_atomic_json = chain._atomic_json
+    original_lock = chain.checkpoint_run_lock
+    original_promote = chain._promote_checkpoint_run_archives
+    promotions = []
+    writes = []
+    chain._load_checkpoint_revision = lambda *_args: (metadata, "selected.json")
+    chain._st_load = lambda _path: {
+        "context_frames": torch.zeros((22, 2, 2, 3)),
+        "video": torch.zeros((1, 2, 2)),
+        "audio": torch.zeros((1, 2, 2)),
+    }
+    chain._atomic_json = lambda path, value: writes.append((path, value))
+    chain.checkpoint_run_lock = lambda *_args: nullcontext()
+    chain._promote_checkpoint_run_archives = lambda plan, metadata: promotions.append((plan, metadata))
+    try:
+        accepted, selected_state = chain._select_review_candidate({
+            "plan": current_plan,
+            "index": 2,
+            "segments": [{"revision": "parent"}],
+            "candidate_batch": {"scene": 2},
+        }, candidate_segment("d" * 32, 999), {
+            "candidate_revision": selected["revision"],
+        })
+        choice = accepted["_h3_review_decision"]
+        assert choice["action"] == "candidate_selected"
+        assert choice["plan"]["shots"][1]["seed"] == 2
+        assert choice["context_frames"].shape[0] == 22
+        assert selected_state["plan"]["shots"][1]["seed"] == 2
+        assert "candidate_batch" not in selected_state
+        assert writes and writes[0][1] is metadata
+        assert promotions == [(selected_state["plan"], metadata)]
+    finally:
+        chain._load_checkpoint_revision = original_load_revision
+        chain._st_load = original_st_load
+        chain._atomic_json = original_atomic_json
+        chain.checkpoint_run_lock = original_lock
+        chain._promote_checkpoint_run_archives = original_promote
+
+
+check_exact_candidate_selection()
+
+
+class FakePromptServerInstance:
+    def __init__(self):
+        self.client_id = "current-client"
+        self.sent = []
+
+    def send_sync(self, event, payload, client_id=None):
+        self.sent.append((event, payload, client_id))
+
+
+fake_prompt_server = FakePromptServerInstance()
+chain.PromptServer.instance = fake_prompt_server
+final_manifest = {
+    "format": "h3_chain_manifest_v3",
+    "run_name": "review_length",
+    "plan_hash": "prepared-hash",
+}
+final_key = chain._final_review_preview_key(final_manifest)
+chain._PENDING_FINAL_REVIEW_PREVIEWS[final_key] = {
+    "token": "final-token",
+    "node_id": "review-node",
+    "client_id": "originating-client",
+}
+chain._publish_final_review_preview(
+    final_manifest, str(ROOT / "final.mp4"), "assembled final")
+assert final_key not in chain._PENDING_FINAL_REVIEW_PREVIEWS
+assert fake_prompt_server.sent == [(
+    "minimax_h3_context_loop_review_resolved",
+    {
+        "token": "final-token",
+        "node_id": "review-node",
+        "action": "final",
+        "status": "assembled final",
+        "final_video": {
+            "filename": "final.mp4",
+            "subfolder": "",
+            "type": "output",
+        },
+    },
+    "originating-client",
+)]
+
+print("H3 Review length and final preview handoff: pass")
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_rich_scene_prompt_editor_js_test.mjs b/ComfyUI-MiniMaxH3-Context-Loop/tests/_rich_scene_prompt_editor_js_test.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..acb0e475c7ac4e27cc53792b8c7c7ef3a55bfc53
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_rich_scene_prompt_editor_js_test.mjs
@@ -0,0 +1,228 @@
+#!/usr/bin/env node
+
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import {
+    PromptUndoHistory,
+    RICH_PROMPT_GUIDES,
+    normalizeRichGuide,
+    optimizerSource,
+    promptUndoDirection,
+    richGenerationMode,
+    richGuideInstruction,
+    tokenizeRichPrompt,
+} from "../web/h3_rich_prompt_editor_core.mjs";
+
+const undo = new PromptUndoHistory("A", {coalesceMs:750});
+assert.equal(undo.record("AB", {inputType:"insertText", now:100}), true);
+assert.equal(undo.record("ABC", {inputType:"insertText", now:200}), true);
+assert.equal(undo.undo(), "A");
+assert.equal(undo.redo(), "ABC");
+undo.record("ABC pasted", {inputType:"insertFromPaste", now:250});
+assert.equal(undo.undo(), "ABC");
+undo.record("AB changed", {inputType:"insertReplacementText", now:300});
+assert.equal(undo.redo(), null);
+assert.equal(undo.align("External"), true);
+assert.equal(undo.undo(), null);
+assert.equal(promptUndoDirection({ctrlKey:true, key:"z"}), "undo");
+assert.equal(promptUndoDirection({metaKey:true, shiftKey:true, key:"Z"}), "redo");
+assert.equal(promptUndoDirection({ctrlKey:true, key:"y"}), "redo");
+assert.equal(promptUndoDirection({ctrlKey:true, altKey:true, key:"z"}), null);
+const synchronizedUndo = new PromptUndoHistory("Before");
+synchronizedUndo.record("After", {inputType:"insertReplacementText", now:400});
+assert.equal(synchronizedUndo.align("After"), false);
+assert.equal(synchronizedUndo.undo(), "Before");
+
+const records = [
+    {kind:"picture", token:"@hero", label:"<Picture 1>", active:true},
+    {kind:"audio", token:"@voice", label:"<Audio 1>", active:true},
+];
+const tokens = tokenizeRichPrompt(
+    "<Subject 1> uses @hero and <Audio 1>. <d>Hello.</d> @missing",
+    records,
+);
+assert.deepEqual(
+    tokens.filter((item) => item.type !== "text").map((item) => [item.type, item.kind, item.text, item.unresolved]),
+    [
+        ["subject", undefined, "<Subject 1>", undefined],
+        ["reference", "picture", "@hero", false],
+        ["reference", "audio", "<Audio 1>", false],
+        ["dialogue", undefined, "<d>", undefined],
+        ["dialogue", undefined, "</d>", undefined],
+        ["reference", "unknown", "@missing", true],
+    ],
+);
+const punctuated = tokenizeRichPrompt(
+    "Keep @hero. Then use @voice, without absorbing punctuation.",
+    records,
+);
+assert.deepEqual(
+    punctuated.filter((item) => item.type !== "text").map((item) => item.text),
+    ["@hero", "@voice"],
+);
+assert.equal(punctuated.map((item) => item.text).join(""),
+    "Keep @hero. Then use @voice, without absorbing punctuation.");
+const caseSensitiveRecords = [
+    {kind:"picture", tag:"Maison", token:"@Maison", active:true},
+    {kind:"picture", tag:"maison", token:"@maison", active:true},
+];
+const caseSensitiveTokens = tokenizeRichPrompt(
+    "Use @Maison and @maison, but not @MAISON. Keep #Maison distinct from #maison.",
+    caseSensitiveRecords,
+).filter((item) => item.type === "reference");
+assert.equal(caseSensitiveTokens[0].record, caseSensitiveRecords[0]);
+assert.equal(caseSensitiveTokens[1].record, caseSensitiveRecords[1]);
+assert.equal(caseSensitiveTokens[2].record, null);
+assert.equal(caseSensitiveTokens[2].unresolved, true);
+assert.equal(caseSensitiveTokens[3].record, caseSensitiveRecords[0]);
+assert.equal(caseSensitiveTokens[4].record, caseSensitiveRecords[1]);
+const schemaTokens = tokenizeRichPrompt(
+    "summary:\n[reference generation]\n<d>[English] (S1) Continue <scenetrans> now.<cutoff></d>",
+    records,
+).filter((item) => item.type !== "text");
+assert.deepEqual(schemaTokens.map((item) => [item.type, item.text]), [
+    ["section", "summary:"],
+    ["dialogue", "<d>"],
+    ["speaker", "(S1)"],
+    ["flow", "<scenetrans>"],
+    ["flow", "<cutoff>"],
+    ["dialogue", "</d>"],
+]);
+assert.equal(richGenerationMode("scheduled"), "Ref2VA");
+assert.equal(richGenerationMode("tagged"), "Ref2VA");
+assert.equal(richGenerationMode("native_keyframes"), "I2VA/FL2VA");
+assert.equal(normalizeRichGuide("bogus"), "auto");
+assert.ok(RICH_PROMPT_GUIDES.some((item) => item.id === "music_video"));
+const guidedRefRewrite = richGuideInstruction("music_video", "Ref2VA");
+assert.match(guidedRefRewrite, /subject_definitions/);
+assert.match(guidedRefRewrite, /lyrics/);
+assert.match(guidedRefRewrite, /only when the user explicitly asks for a full H3 rewrite/);
+assert.match(guidedRefRewrite, /change only what the request requires/);
+assert.match(guidedRefRewrite, /Connected references prove only/);
+assert.match(guidedRefRewrite, /Do not invent image content, motion, lyrics, voice, timbre/);
+assert.match(guidedRefRewrite, /inside the supplied scene duration/);
+const compactRewrite = richGuideInstruction("general", "I2VA/FL2VA");
+assert.match(compactRewrite, /keyframe-alignment sentence only when/);
+assert.match(compactRewrite, /do not force headings onto a compact prompt/);
+assert.equal(optimizerSource("AI result", {source:"Original", result:"AI result"}), "Original");
+assert.equal(optimizerSource("Manual edit", {source:"Original", result:"AI result"}), "Manual edit");
+
+const source = fs.readFileSync(
+    new URL("../web/h3_chain_rich_scene_prompt_editor.js", import.meta.url),
+    "utf8",
+);
+assert.match(source, /MiniMaxH3ChainRichScenePromptEditor/);
+assert.match(source, /edits only the selected scene prompt/i);
+assert.match(source, /contentEditable = "true"/);
+assert.match(source, /"keydown", "keyup", "keypress", "copy", "cut", "paste"/);
+assert.match(source, /stopPropagation deliberately preserves the browser's default/);
+assert.match(source, /selectedEditorPlainText/);
+assert.match(source, /data-token value/);
+assert.match(source, /setData\("text\/plain", text\)/);
+assert.match(source, /editor\.addEventListener\("copy"/);
+assert.match(source, /editor\.addEventListener\("cut"/);
+assert.match(source, /shared text-level undo survives later tag decoration/);
+assert.match(source, /PromptUndoHistory/);
+assert.match(source, /promptUndoDirection/);
+assert.match(source, /applyPromptUndo/);
+assert.match(source, /activeSceneIndexAfterRefresh/);
+assert.match(source, /ownsPromptHistoryTarget/);
+assert.match(source, /stopImmediatePropagation\(\)/);
+assert.match(source, /recordPromptReplacement/);
+assert.match(source, /promptUndoForScene\(shotId, text, \{external:true\}\)/);
+assert.match(source, /tokenizeRichPrompt/);
+assert.match(source, /h3rp-token-picture/);
+assert.match(source, /h3rp-token-audio/);
+assert.match(source, /h3rp-token-thumb/);
+assert.match(source, /function referenceMediaPreview\(record, kind\)/);
+assert.match(source, /url: api\.apiURL\(record\.previewUrl\)/);
+assert.doesNotMatch(source, /record\.previewUrl\s*\?\s*api\.apiURL/);
+assert.match(source, /--h3rp-accent:color-mix\(in srgb,var\(--h3rp-text\)/);
+assert.match(source, /--h3rp-token-subject:color-mix/);
+assert.match(source, /color:var\(--h3rp-token-subject\)/);
+assert.doesNotMatch(source, /h3rp-token-subject \{ color:#8ed7a4/);
+assert.match(source, /h3rp-popover audio/);
+assert.match(source, /mediaElement\.controls = true/);
+assert.match(source, /Audio never autoplays/);
+assert.match(source, /pointerdown.*preventDefault/);
+assert.match(source, /createPromptCompletionController/);
+assert.match(source, /createH3PromptSchemaController/);
+assert.match(source, /h3_rich_scene_prompt_editor/);
+assert.match(source, /getMode:\(\) => state\.schema/);
+assert.match(source, /h3rp-token-section/);
+assert.match(source, /h3rp-token-flow/);
+assert.match(source, /h3rp-token-speaker/);
+assert.match(source, /PRESENTATION_PROPERTY/);
+assert.match(source, /state\.decorated \? "Rich text" : "Plain text"/);
+assert.match(source, /state\.completion\?\.handleKeydown/);
+assert.match(source, /restoreTextSelection/);
+assert.match(source, /editingSemanticTime/);
+assert.match(source, /convertTaggedPictureReference/);
+assert.match(source, /replacePromptReferenceOccurrence/);
+assert.match(source, /click to replace or edit/);
+assert.match(source, /Time \(sec\)/);
+assert.match(source, /makeToken\(part, partStart, partEnd\)/);
+assert.match(source, /popoverPinned/);
+assert.match(source, /taggedPictureReferenceMode/);
+assert.match(source, /h3rp-ref-mode/);
+assert.match(source, /Use untimed Qwen-only #tag/);
+assert.match(source, /refsButton\.addEventListener\("pointerdown", rememberPromptSelection\)/);
+assert.match(source, /document\.activeElement === state\.editor/);
+assert.match(source, /current\.slice\(0, insertionStart\)/);
+assert.match(source, /if \(record\.semanticOnly\) return "semantic"/);
+assert.match(source, /maxItems:40/);
+assert.match(source, /Type @, #, <, or \[/);
+assert.match(source, /Ctrl\/Cmd\+Space for all H3 completions/);
+assert.doesNotMatch(source, /event\.key === "@"/);
+assert.match(source, /RICH_PROMPT_GUIDES/);
+assert.match(source, /richGuideInstruction/);
+assert.match(source, /PromptAssistantClient/);
+assert.match(source, /prompt_assist_ready/);
+assert.match(source, /optimizerProviders/);
+assert.match(source, /promptOptimizerBackend/);
+assert.match(source, /makeDirectPromptOptimizeRequest/);
+assert.match(source, /openPromptOptimizerSettings/);
+assert.doesNotMatch(source, /h3rp-provider/);
+assert.match(source, /rebaseActivePromptOntoLivePlan/);
+assert.match(source, /publishCompanionScene/);
+assert.doesNotMatch(source, /state\.provider === "hermes"/);
+assert.match(source, /Optimize/);
+assert.match(source, /Apply changed result/);
+assert.match(source, /scheduleHistoryDraft/);
+assert.match(source, /flushHistoryDraft/);
+assert.match(source, /promptRevisionTree/);
+assert.match(source, /mutateHistoryRevision\(\s*"label"/);
+assert.match(source, /mutateHistoryRevision\(\s*"archive"/);
+assert.match(source, /mutateHistoryRevision\(\s*"delete"/);
+assert.match(source, /parent → child progression/);
+assert.match(source, /Delete unexecuted leaf/);
+assert.match(source, /serialize:false/);
+assert.match(source, /PROJECT_ASSET_CATALOG_CHANGED_EVENT/);
+assert.match(source, /function refreshReferenceState/);
+assert.match(source, /refreshReferenceState\(editorPlainText\(state\.editor\)\)/);
+assert.match(source, /onProjectAssetCatalogChanged/);
+assert.match(source, /removeEventListener\?\.\(\s*PROJECT_ASSET_CATALOG_CHANGED_EVENT/);
+assert.match(source, /const scrollTop = state\.editor\.scrollTop/);
+assert.match(source, /state\.editor\.scrollTop = scrollTop/);
+assert.match(source, /editor\.focus\(\{preventScroll:true\}\)/);
+assert.match(source, /const PROMPT_SYNC_DELAY_MS = 140/);
+assert.match(source, /const PROMPT_ANALYSIS_DELAY_MS = 90/);
+assert.match(source, /writePlan\("Saved to connected Plan", \{deferEffects:true\}\)/);
+assert.match(source, /function flushPlanEffects\(\)/);
+assert.match(source, /state\.planWidget\.value = value/);
+assert.match(source, /window\.setTimeout\(\s*flushPlanEffects, PROMPT_SYNC_DELAY_MS/);
+assert.match(source, /liveValue !== state\.lastValue && !rebaseActivePromptOntoLivePlan\(\)/);
+assert.match(source, /editor\.addEventListener\("blur", \(\) => \{\s*flushPlanEffects\(\)/);
+assert.match(source, /schedulePromptAnalysis\(\)/);
+const teardown = source.slice(
+    source.indexOf("node.onRemoved = function ()"),
+    source.indexOf("node._h3PromptCompanionSetActiveScene"),
+);
+assert.match(teardown, /state\.disposed = true/);
+assert.match(teardown, /state\.planSyncPending = null/);
+assert.match(teardown, /state\.history\.pendingDraft = null/);
+assert.doesNotMatch(teardown, /flushPlanEffects\(\)/);
+assert.doesNotMatch(teardown, /flushPromptAnalysis\(\)/);
+assert.doesNotMatch(teardown, /flushHistoryDraft\(\)/);
+
+console.log("H3 Rich Scene Prompt Editor: tokens, guides, previews, optimizer, and history pass");
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_run_assets_js_test.mjs b/ComfyUI-MiniMaxH3-Context-Loop/tests/_run_assets_js_test.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..e4c4b8a12329414d3b87caf2e095b4944fdeaefd
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_run_assets_js_test.mjs
@@ -0,0 +1,144 @@
+#!/usr/bin/env node
+
+import assert from "node:assert/strict";
+import {
+    applyAssetBinding,
+    collectAssetBindings,
+    findAssetTarget,
+    inferAssetRole,
+} from "../web/h3_run_assets_core.mjs";
+
+function loader(id, type, outputType, widgetName, value) {
+    return {
+        id,
+        type,
+        title: `${type} ${id}`,
+        properties: {},
+        outputs: [{type: outputType}],
+        widgets: [{name: widgetName, value, options: {values: [value]}}],
+    };
+}
+
+const image = loader(911, "LoadImage", "IMAGE", "image", "hero.png");
+const audio = loader(940, "LoadAudio", "AUDIO", "audio", "voice.wav");
+const nodes = [image, audio];
+const graph = {
+    _nodes: nodes,
+    links: {
+        1: {origin_id: 911, origin_slot: 0},
+        2: {origin_id: 940, origin_slot: 0},
+    },
+    getNodeById(id) {
+        return nodes.find((node) => String(node.id) === String(id));
+    },
+};
+const manager = {
+    graph,
+    properties: {},
+    inputs: [
+        {name: "plan", link: 9},
+        {name: "asset_0", link: 1},
+        {name: "asset_1", link: 2},
+        {name: "asset_2", link: null},
+    ],
+};
+let ordinal = 0;
+const bindings = collectAssetBindings(manager, () => `binding-${++ordinal}`);
+assert.equal(bindings.length, 2);
+assert.equal(bindings[0].node_id, "911");
+assert.equal(bindings[0].role, "picture");
+assert.equal(bindings[1].role, "audio_reference");
+assert.equal(inferAssetRole("VIDEO", "LoadVideo"), "video");
+
+const lazyMotion = loader(
+    950, "MiniMaxH3LazyMotionAVLoader", "VIDEO", "video_path",
+    "/media/lazy-motion.mkv");
+nodes.push(lazyMotion);
+graph.links[3] = {origin_id: 950, origin_slot: 0};
+const lazyBindings = collectAssetBindings({
+    graph, properties: {}, inputs: [{name: "asset_0", link: 3}],
+}, () => "lazy-motion-binding");
+assert.equal(lazyBindings[0].role, "video");
+assert.equal(lazyBindings[0].widget_name, "video_path");
+assert.equal(lazyBindings[0].original_value, "/media/lazy-motion.mkv");
+
+// A loader may expose media on more than one output. Each output needs its
+// own persistent identity so video and audio roles cannot overwrite one another.
+image.outputs.push({type: "AUDIO"});
+manager.inputs.push({name: "asset_2", link: 12});
+graph.links[12] = {origin_id: 911, origin_slot: 1};
+const multiOutput = collectAssetBindings(manager, () => `binding-${++ordinal}`);
+assert.notEqual(multiOutput[0].binding_id, multiOutput[2].binding_id);
+assert.equal(multiOutput[2].role, "audio_reference");
+manager.inputs.pop();
+delete graph.links[12];
+
+manager.properties.h3_asset_roles[bindings[1].binding_id] = "source_track";
+assert.equal(collectAssetBindings(manager)[1].role, "source_track");
+
+// Any number of semantic loaders can live behind one dedicated Run Manager
+// socket. The persisted bindings still point to the real loader widgets.
+const semanticImageA = loader(
+    960, "LoadImage", "IMAGE", "image", "beat-a.png");
+const semanticImageB = loader(
+    961, "LoadImage", "IMAGE", "image", "beat-b.png");
+const semanticA = {
+    id: 970,
+    type: "MiniMaxH3SemanticPictureAnchor",
+    title: "Semantic A",
+    inputs: [{name: "image", link: 13}, {name: "previous", link: null}],
+    outputs: [{type: "H3_SEMANTIC_ANCHOR_DRAFT"}],
+    widgets: [{name: "tag", value: "beat_a"}],
+};
+const semanticB = {
+    id: 971,
+    type: "MiniMaxH3SemanticPictureAnchor",
+    title: "Semantic B",
+    inputs: [{name: "image", link: 14}, {name: "previous", link: 15}],
+    outputs: [{type: "H3_SEMANTIC_ANCHOR_DRAFT"}],
+    widgets: [{name: "tag", value: "beat_b"}],
+};
+const semanticBundle = {
+    id: 972,
+    type: "MiniMaxH3SemanticAnchorBundle",
+    title: "Semantic Bundle",
+    inputs: [{name: "anchors", link: 16}],
+    outputs: [{type: "H3_TAGGED_REFERENCES"}],
+};
+nodes.push(semanticImageA, semanticImageB, semanticA, semanticB, semanticBundle);
+for (const item of [semanticA, semanticB, semanticBundle]) item.graph = graph;
+graph.links[13] = {origin_id: 960, origin_slot: 0};
+graph.links[14] = {origin_id: 961, origin_slot: 0};
+graph.links[15] = {origin_id: 970, origin_slot: 0};
+graph.links[16] = {origin_id: 971, origin_slot: 0};
+graph.links[17] = {origin_id: 972, origin_slot: 0};
+const semanticManager = {
+    graph,
+    properties: {},
+    inputs: [{name: "tagged_references", link: 17}],
+};
+const semanticBindings = collectAssetBindings(
+    semanticManager, () => `semantic-${++ordinal}`);
+assert.equal(semanticBindings.length, 2);
+assert.deepEqual(semanticBindings.map((item) => item.original_value), [
+    "beat-a.png", "beat-b.png"]);
+assert.deepEqual(semanticBindings.map((item) => item.label.split(" · ")[0]), [
+    "#beat_a", "#beat_b"]);
+assert(semanticBindings.every((item) => item.role === "picture"));
+assert.equal(semanticManager.inputs.length, 1);
+
+const archived = {
+    ...bindings[0],
+    restore_value: "h3_project_hash_hero.png",
+    restore_source: "archived_fallback",
+};
+assert.equal(findAssetTarget(graph, archived).match, "binding");
+const restored = applyAssetBinding(graph, archived);
+assert(restored.applied);
+assert.equal(image.widgets[0].value, archived.restore_value);
+assert(image.widgets[0].options.values.includes(archived.restore_value));
+
+const missing = applyAssetBinding(graph, {...archived, restore_value: ""});
+assert.equal(missing.reason, "media_missing");
+
+console.log("H3 run asset bindings: capture, roles, matching and loader restore pass");
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_run_manager_js_test.mjs b/ComfyUI-MiniMaxH3-Context-Loop/tests/_run_manager_js_test.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..851bbb1df9ffd44a31890fd290d8d2710b99013e
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_run_manager_js_test.mjs
@@ -0,0 +1,76 @@
+#!/usr/bin/env node
+
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import {
+    runArchiveOptionLabel,
+    runManagerIdentity,
+} from "../web/h3_run_manager_core.mjs";
+
+const different = runManagerIdentity("active_project", {
+    run_name: "saved_project",
+});
+assert.equal(different.same, false);
+assert.equal(different.activeLabel, "Active Plan: active_project");
+assert.equal(
+    different.selectedLabel,
+    "Selected archive: saved_project (not loaded)",
+);
+assert.equal(different.loadLabel, "Load selected archive into Plan");
+assert.match(different.saveLabel, /active_project/);
+
+const same = runManagerIdentity("saved_project", {run_name: "saved_project"});
+assert.equal(same.same, true);
+assert.equal(same.loadLabel, "Reload selected archive");
+assert.match(runArchiveOptionLabel({
+    run_name: "saved_project", scene_count: 2, restorable: true,
+}, "saved_project"), /2 scenes · ACTIVE PLAN$/);
+assert.match(runArchiveOptionLabel({
+    run_name: "asset_project", scene_count: null, restorable: false,
+}, ""), /assets only$/);
+
+const source = fs.readFileSync(
+    new URL("../web/h3_chain_run_manager.js", import.meta.url), "utf8",
+);
+
+assert.match(source, /MiniMaxH3ChainRunManager/);
+assert.match(source, /MiniMaxH3ChainPlan/);
+assert.match(source, /\/minimax_h3_context_loop\/runs/);
+assert.match(source, /\/minimax_h3_context_loop\/run\?/);
+assert.match(source, /\/minimax_h3_context_loop\/run-assets/);
+assert.match(source, /window\.confirm\(message\)/);
+assert.match(source, /This replaces all active scene prompts, archived Plan settings, and connected 0\.5 policies/);
+assert.match(source, /function applyPlanInputs/);
+assert.match(source, /planNode, policyInputs, inputs/);
+assert.match(source, /payload\.policy_inputs/);
+assert.match(source, /refreshRestoredPlanEditors\(planNode\)/);
+assert.match(source, /left === "plan_json"/);
+assert.match(source, /widget\.callback\?\.\(inputs\[name\]\)/);
+assert.match(source, /refreshRestoredPlanEditors\(planNode\)/);
+assert.match(source, /output\/h3_chains/);
+assert.match(source, /Open selected folder/);
+assert.match(source, /navigator\.clipboard\.writeText\(payload\.path\)/);
+assert.match(source, /collectAssetBindings\(node\)/);
+assert.match(source, /applyAssetBinding\(graph, binding\)/);
+assert.match(source, /Connect loader asset/);
+assert.match(source, /Archive video/);
+assert.match(source, /Reference assets →/);
+assert.match(source, /_h3RunManagerWatchers/);
+assert.match(source, /refreshRuns\(savedRunName\)/);
+assert.match(source, /Saved \$\{payload\.asset_count\} bindings to/);
+assert.match(source, /Active Plan is now/);
+assert.match(source, /selectedIdentity\.textContent = runIdentity\.selectedLabel/);
+assert.doesNotMatch(source, /option\.disabled = !run\.restorable/);
+assert.match(source, /removeLegacyStatusOutput/);
+assert.match(source, /output\.name === "asset_status"/);
+assert.match(source, /widget\.hidden = true/);
+assert.match(source, /widget\.draw = \(\) => \{\}/);
+assert.match(source, /pointer-events[^\n]+none[^\n]+important/);
+assert.match(source, /widget\.onRemove\(\)/);
+const backend = fs.readFileSync(
+    new URL("../chain_nodes.py", import.meta.url), "utf8",
+);
+assert.match(backend, /"rawLink": True/);
+assert.match(backend, /"lazy": True/);
+
+console.log("H3 Run Manager frontend: discovery, confirmation and Plan restore wiring pass");
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_run_manager_unit_test.py b/ComfyUI-MiniMaxH3-Context-Loop/tests/_run_manager_unit_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..e3935fded39ae809ad9c682ab1d8f8a82962d731
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_run_manager_unit_test.py
@@ -0,0 +1,245 @@
+#!/usr/bin/env python3
+"""Standalone H3 run discovery and Plan restoration checks."""
+
+import json
+import pathlib
+import tempfile
+
+from run_manager import (
+    RunArchiveManager,
+    _workflow_inputs,
+    archive_policy_inputs,
+)
+
+
+def write(path, value):
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(value), encoding="utf-8")
+
+
+def main():
+    locked_policy = archive_policy_inputs({
+        "compatibility": {
+            "audio_policy": {
+                "version": "h3_audio_policy_v1",
+                "final_audio": "source",
+                "source_reference": "off",
+                "generated_continuity": "off",
+                "source_audio_target": "locked",
+            },
+        },
+    })["audio_policy"]
+    assert locked_policy == {
+        "final_audio": "source",
+        "source_reference": "off",
+        "generated_continuity": "off",
+        "source_audio_target": "locked",
+    }
+
+    old_widgets = [
+        '{"shots":[{"prompt":"old"}]}', "old_run", "", 960, 544,
+        22, "video", "head", "disabled", "source_track", 22, 15.0,
+        20, 0, 18,
+    ]
+    old_restore = _workflow_inputs({
+        "nodes": [{"type": "MiniMaxH3ChainPlan",
+                   "widgets_values": old_widgets}],
+    }, "old_run")
+    assert old_restore["segment_crf"] == 18
+    assert old_restore["video_blend_frames"] == 0
+    assert old_restore["continuation_mode"] == "guide"
+
+    tapered_widgets = old_widgets + [0, "tapered_guide"]
+    tapered_restore = _workflow_inputs({
+        "nodes": [{"type": "MiniMaxH3ChainPlan",
+                   "widgets_values": tapered_widgets}],
+    }, "old_run")
+    assert tapered_restore["continuation_mode"] == "tapered_guide"
+
+    drift_widgets = old_widgets + [0, "drift_control_av"]
+    drift_restore = _workflow_inputs({
+        "nodes": [{"type": "MiniMaxH3ChainPlan",
+                   "widgets_values": drift_widgets}],
+    }, "old_run")
+    assert drift_restore["continuation_mode"] == "drift_control_av"
+
+    modern_widgets = [
+        '{"shots":[{"prompt":"modern"}]}', "modern_run", "models-v4",
+        1280, 704, "video", "center", 10.0, 30,
+        "18446744073709551615", 17, 5,
+    ]
+    modern_restore = _workflow_inputs({
+        "nodes": [{"type": "MiniMaxH3ChainPlanModern",
+                   "widgets_values": modern_widgets}],
+    }, "modern_run")
+    assert json.loads(modern_restore.pop("plan_json")) == {
+        "shots": [{"prompt": "modern"}],
+    }
+    assert modern_restore == {
+        "run_name": "modern_run",
+        "generation_fingerprint": "models-v4",
+        "width": 1280,
+        "height": 704,
+        "encode_mode": "video",
+        "crop": "center",
+        "default_duration_seconds": 10.0,
+        "default_steps": 30,
+        "base_seed": "18446744073709551615",
+        "segment_crf": 17,
+        "video_blend_frames": 5,
+    }
+
+    with tempfile.TemporaryDirectory() as temporary:
+        root = pathlib.Path(temporary)
+        exact = root / "h3_chains" / "variant_exact"
+        editor_plan = {
+            "prompt_prefix": "Shared.",
+            "shots": [{"id": "one", "prompt": "Archived prompt.", "length": 22}],
+        }
+        write(exact / "plan.json", {
+            "format": "h3_chain_plan_archive_v1",
+            "run_name": "variant_exact",
+            "editor_plan": editor_plan,
+            "compatibility": {
+                "width": 960, "height": 544, "context_length": 22,
+                "generation_fingerprint": "",
+                "audio_policy": {
+                    "version": "h3_audio_policy_v1",
+                    "final_audio": "source",
+                    "source_reference": "on",
+                    "generated_continuity": "off",
+                },
+                "transition_policy": {
+                    "version": "h3_transition_policy_v1",
+                    "preset": "soft_av",
+                    "continuation_mode": "feathered_av",
+                    "context_length": 39,
+                    "expert_override": True,
+                },
+            },
+        })
+        exact_inputs = {
+            "plan_json": json.dumps(editor_plan),
+            "run_name": "variant_exact",
+            "generation_fingerprint": "models-v3",
+            "width": 1280,
+            "height": 704,
+            "context_length": 39,
+            "encode_mode": "video",
+            "anchor_mode": "head",
+            "crop": "center",
+            "audio_mode": "generated_audio",
+            "audio_context_length": 22,
+            "default_duration_seconds": 10.0,
+            "default_steps": 30,
+            "base_seed": "18446744073709551615",
+            "segment_crf": 17,
+            "video_blend_frames": 22,
+            "continuation_mode": "masked_av",
+        }
+        write(exact / "api_prompt.json", {
+            "12": {"class_type": "MiniMaxH3ChainPlan", "inputs": exact_inputs},
+        })
+        write(exact / "checkpoints" / "clip_0001.json", {"segment": {}})
+
+        fallback = root / "h3_chains" / "variant_fallback"
+        write(fallback / "plan.json", {
+            "format": "h3_chain_plan_archive_v1",
+            "run_name": "variant_fallback",
+            "prompt_prefix": "Fallback shared.",
+            "shots": [{
+                "id": "fallback", "scene_prompt": "Fallback prompt.",
+                "raw_frames": 39, "steps": 20, "seed": 9,
+                "context_length": 0,
+                "audio_context_length": 33,
+                "lora_route": "C",
+            }],
+            "compatibility": {
+                "width": 768, "height": 448, "context_length": 5,
+                "encode_mode": "frames", "anchor_mode": "before",
+                "crop": "disabled", "audio_mode": "source_track",
+                "audio_context_length": 5, "generation_fingerprint": "old",
+            },
+            "segment_crf": 19,
+        })
+
+        manager = RunArchiveManager(temporary)
+        runs = manager.list_runs()
+        assert {item["run_name"] for item in runs} == {
+            "variant_exact", "variant_fallback"}
+        exact_summary = next(item for item in runs if item["run_name"] == "variant_exact")
+        assert exact_summary["scene_count"] == 1
+        assert exact_summary["checkpoint_count"] == 1
+        assert exact_summary["restorable"]
+
+        loaded = manager.load_run("variant_exact")
+        assert json.loads(loaded["plan_inputs"]["plan_json"]) == editor_plan
+        assert {key: value for key, value in loaded["plan_inputs"].items()
+                if key != "plan_json"} == {
+                    key: value for key, value in exact_inputs.items()
+                    if key != "plan_json"}
+        assert loaded["scene_count"] == 1
+        assert loaded["policy_inputs"] == {
+            "audio_policy": {
+                "final_audio": "source",
+                "source_reference": "on",
+                "generated_continuity": "off",
+            },
+            "transition_policy": {
+                "preset": "soft_av",
+                "expert_override": True,
+                "expert_continuation_mode": "feathered_av",
+                "expert_context_length": 39,
+            },
+        }
+        assert loaded["sources"][-1] == "api_prompt.json"
+        plan_only = manager.load_plan("variant_exact")
+        assert plan_only["plan_inputs"] == loaded["plan_inputs"]
+        assert plan_only["policy_inputs"] == loaded["policy_inputs"]
+        assert "assets" not in plan_only
+
+        # Connected API inputs are skipped, leaving the effective archived
+        # fallback value intact instead of replacing a graph connection.
+        linked = dict(exact_inputs)
+        linked["generation_fingerprint"] = [99, 0]
+        linked["base_seed"] = 18446744073709551615
+        write(exact / "api_prompt.json", {
+            "12": {"class_type": "MiniMaxH3ChainPlan", "inputs": linked},
+        })
+        linked_restore = manager.load_run("variant_exact")["plan_inputs"]
+        assert linked_restore["generation_fingerprint"] == ""
+        assert linked_restore["base_seed"] == "18446744073709551615"
+
+        fallback_payload = manager.load_run("variant_fallback")
+        restored = fallback_payload["plan_inputs"]
+        assert restored["run_name"] == "variant_fallback"
+        assert restored["width"] == 768
+        assert restored["anchor_mode"] == "before"
+        assert restored["segment_crf"] == 19
+        assert restored["video_blend_frames"] == 0
+        assert restored["continuation_mode"] == "guide"
+        restored_plan = json.loads(restored["plan_json"])
+        assert restored_plan["shots"][0]["prompt"] == "Fallback prompt."
+        assert restored_plan["shots"][0]["seed"] == "9"
+        assert restored_plan["shots"][0]["context_length"] == 0
+        assert restored_plan["shots"][0]["audio_context_length"] == 33
+        assert restored_plan["shots"][0]["lora_route"] == "c"
+        assert fallback_payload["policy_inputs"] == {
+            "audio_policy": {
+                "final_audio": "source",
+                "source_reference": "on",
+                "generated_continuity": "off",
+            },
+            "transition_policy": {
+                "preset": "guide",
+                "expert_override": True,
+                "expert_continuation_mode": "guide",
+                "expert_context_length": 5,
+            },
+        }
+
+    print("H3 Run Manager: discovery, exact API restoration and Plan fallback pass")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_run_switch_safety_js_test.mjs b/ComfyUI-MiniMaxH3-Context-Loop/tests/_run_switch_safety_js_test.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..620c4483d891c76c5a2c17fc433143bb61cb430f
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_run_switch_safety_js_test.mjs
@@ -0,0 +1,196 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import vm from "node:vm";
+import * as core from "../web/h3_chain_plan_core.mjs";
+
+const carousel = fs.readFileSync(new URL("../web/h3_project_asset_manager.js", import.meta.url), "utf8");
+const studio = fs.readFileSync(new URL("../web/h3_chain_plan_studio.js", import.meta.url), "utf8");
+function handler(source, name) {
+    const match = source.match(new RegExp(`^    (?:async )?function ${name}\\([^]*?^    }$`, "m"));
+    assert.ok(match, name);
+    return match[0];
+}
+
+// Exercise the real handlers, including their await boundaries (not regex-only checks).
+function carouselContext() {
+    const requests = [];
+    const runNameWidget = {value:"run_a"};
+    const context = vm.createContext({
+        state:{catalog:{project:"run_a"}, selected:"keep", uploading:false},
+        runNameWidget, runNameInput:{value:"run_a"}, catalogWidget:{},
+        node:{graph:{setDirtyCanvas(){}}}, project:() => runNameWidget.value,
+        ownership:{runName:"run_a", async select(run) { this.runName = run; }},
+        projectMutationOptions:async (_node, _run, options) => options,
+        jsonRequest:(route, options) => new Promise((resolve, reject) => requests.push({route, options, resolve, reject})),
+        syncDownstreamPlan:(_node, run) => { context.planRun = run; },
+        publishProjectAssetCatalogChanged(){}, render(){}, setStatus(){},
+        promptTag:asset => asset.tag, window:{confirm:() => true},
+        FormData:class { constructor() { this.fields = {}; } append(key, value) { this.fields[key] = value; } },
+    });
+    vm.runInContext("let projectEpoch = 0; let projectDisposed = false;\n" + [
+        "captureProjectOperation", "isCurrentProjectOperation", "requireCurrentProjectOperation",
+        "mutationRequest", "persistCatalog", "importAsset", "uploadFiles",
+        "updateAsset", "reorderAssets", "deleteAsset", "duplicateAsset", "folderRequest",
+    ].map(name => handler(carousel, name)).join("\n"), context);
+    return {context, requests, switchRun(run) {
+        vm.runInContext("projectEpoch += 1", context);
+        runNameWidget.value = run; context.runNameInput.value = run; context.planRun = run;
+    }};
+}
+const tick = async () => { for (let i = 0; i < 8; i++) await Promise.resolve(); };
+const result = {catalog:{project:"run_a", assets:[]}, asset:{id:"late", tag:"ref", role:"picture"}};
+for (const returnToA of [false, true]) {
+    for (const method of ["importAsset", "updateAsset", "reorderAssets", "deleteAsset", "duplicateAsset", "folderRequest"]) {
+        const fixture = carouselContext();
+        const pending = fixture.context[method]({id:"asset", tag:"ref"}, {});
+        // importAsset intentionally lets its dialog handle errors.
+        const settled = Promise.resolve(pending).catch(error => assert.equal(error.staleProject, true));
+        await tick();
+        assert.equal(fixture.requests.length, 1);
+        fixture.switchRun("run_b");
+        if (returnToA) fixture.switchRun("run_a");
+        fixture.requests[0].resolve(result);
+        await settled;
+        assert.equal(fixture.context.state.selected, "keep", method);
+        assert.equal(fixture.context.planRun, returnToA ? "run_a" : "run_b", method);
+        assert.equal(fixture.context.state.catalog.assets, undefined, method);
+    }
+}
+{
+    const fixture = carouselContext();
+    const pending = fixture.context.uploadFiles([{name:"one.png"}, {name:"two.png"}]);
+    await tick();
+    assert.equal(fixture.requests[0].options.body.fields.project, "run_a");
+    fixture.switchRun("run_b");
+    fixture.requests[0].resolve(result);
+    await pending;
+    assert.equal(fixture.requests.length, 1, "remaining files must not leak into B");
+    assert.equal(fixture.context.state.uploading, false);
+    assert.equal(fixture.context.planRun, "run_b");
+}
+{
+    const fixture = carouselContext();
+    const pending = fixture.context.importAsset({source:"input"});
+    await tick(); fixture.requests[0].resolve(result); await pending;
+    assert.equal(fixture.context.state.selected, "late", "current-run import still applies");
+    const token = fixture.context.captureProjectOperation();
+    fixture.switchRun("run_b");
+    await assert.rejects(fixture.context.mutationRequest("unused", {}, token), /Run changed/);
+    assert.equal(fixture.requests.length, 1, "stale dialogs must not send a mutation");
+    vm.runInContext("projectDisposed = true", fixture.context);
+    await assert.rejects(fixture.context.importAsset({}), /Run changed/);
+}
+
+function studioContext() {
+    const timers = new Map(); const writes = []; let id = 0;
+    const context = vm.createContext({
+        ...core, console, structuredClone,
+        state:{plan:{shots:[{id:"scene_a", prompt:["A"], length:345}], chapters:[]},
+            editorial:{}, checkpoints:new Map()},
+        node:{properties:{}}, alternateTakeWidget:{value:"stale"},
+        runName:() => "run_b", cacheStudioPresentation(){}, dirty(){}, renderStatus(){},
+        setTimeout:fn => { timers.set(++id, fn); return id; }, clearTimeout:key => timers.delete(key),
+        projectMutationOptions:async (_node, _run, options) => options,
+        api:{fetchApi:async (_route, options) => {
+            writes.push(JSON.parse(options.body));
+            return {ok:true, json:async () => ({editorial:{revision:"c".repeat(32)}})};
+        }},
+    });
+    const names = ["normalizedEditorial", "editorialPayload", "applyEditorialPayload", "syncAlternateTakeWidget", "scheduleEditorialSave"];
+    if (studio.includes("function editorialSignature(")) names.push("editorialSignature", "persistEditorial");
+    vm.runInContext(names.map(name => handler(studio, name)).join("\n"), context);
+    return {context, writes, async flush() {
+        for (const fn of timers.values()) await fn(); timers.clear();
+        await context.state.editorialSavePromise;
+    }};
+}
+const incoming = {
+    format:"h3_chain_editorial_v1", run_name:"run_b", revision:"b".repeat(32),
+    chapters:[{id:"b_chapter", title:"Saved B", start_scene:1, start_scene_id:"scene_b"}],
+    scene_order:[{scene:1, scene_id:"scene_b"}],
+    placements:[{scene:1, scene_id:"scene_b", start_frame:48}],
+    trims:[{scene:1, scene_id:"scene_b", out_frame:90}], locked_scene_ids:["scene_b"],
+    subtitles:{mode:"off", asset_id:"", offset_seconds:0}, alternate_draft:null, replacements:[],
+};
+{
+    const fixture = studioContext();
+    fixture.context.applyEditorialPayload(incoming);
+    await fixture.flush();
+    assert.equal(fixture.writes.length, 0, "GET must never POST destination editorial");
+    assert.match(fixture.context.state.editorialBindingError, /matching Plan/);
+    fixture.context.scheduleEditorialSave(); await fixture.flush();
+    assert.equal(fixture.writes.length, 0, "mismatched Plan must not rewrite B after an unrelated edit");
+    assert.equal(fixture.context.alternateTakeWidget.value, "null", "hidden widget still synchronizes");
+}
+{
+    const fixture = studioContext();
+    fixture.context.state.plan.shots[0].id = "scene_b";
+    fixture.context.applyEditorialPayload(incoming);
+    fixture.context.state.plan.shots[0].seed = 42;
+    fixture.context.scheduleEditorialSave(); await fixture.flush();
+    assert.equal(fixture.writes.length, 0, "seed edit must not overwrite saved chapters");
+    fixture.context.state.editorial.trims[0].out_frame = 81;
+    fixture.context.scheduleEditorialSave();
+    fixture.context.applyEditorialPayload(incoming);
+    assert.equal(fixture.context.state.editorial.trims[0].out_frame, 81, "refresh must not clobber pending edits");
+    await fixture.flush();
+    assert.equal(fixture.writes.length, 1);
+    assert.equal(fixture.writes[0].trims[0].out_frame, 81);
+    assert.deepEqual(fixture.writes[0].chapters, incoming.chapters);
+    assert.deepEqual(fixture.writes[0].placements, incoming.placements);
+    fixture.context.applyEditorialPayload(incoming, 0);
+    assert.equal(fixture.context.state.editorial.trims[0].out_frame, 81,
+        "a GET started before the edit must not clobber it after POST completes");
+}
+assert.doesNotMatch(handler(studio, "loadPlan"), /scheduleEditorialSave\(/);
+
+// A removed/renamed empty placeholder is not evidence of a different Run.
+// Only a fresh backend inventory may establish that it has no saved renders.
+const placeholderEditorial = {
+    ...incoming, chapters:[], placements:[], trims:[], locked_scene_ids:[],
+    scene_order:[{scene:1, scene_id:"scene_a"}, {scene:2, scene_id:"old_empty"}],
+};
+{
+    const fixture = studioContext();
+    fixture.context.state.plan.shots.push({id:"new_empty", prompt:[], length:306});
+    fixture.context.applyEditorialPayload(placeholderEditorial, 0, ["old_empty"]);
+    assert.equal(fixture.context.state.editorialBindingError, "");
+    fixture.context.scheduleEditorialSave(); await fixture.flush();
+    assert.equal(fixture.writes.length, 0, "hydration/seed edits must not reconcile on disk");
+    fixture.context.state.editorial.placements.push({scene_id:"new_empty", start_frame:400});
+    fixture.context.scheduleEditorialSave(); await fixture.flush();
+    assert.equal(fixture.writes.length, 1);
+    assert.deepEqual(fixture.writes[0].scene_order, [
+        {scene:1, scene_id:"scene_a"}, {scene:2, scene_id:"new_empty"},
+    ], "an explicit edit reconciles only verified unused entries");
+    assert.deepEqual(placeholderEditorial.scene_order[1], {scene:2, scene_id:"old_empty"},
+        "the fetched document is never mutated");
+}
+for (const proof of [undefined, []]) {
+    const fixture = studioContext();
+    fixture.context.applyEditorialPayload(placeholderEditorial, 0, proof);
+    assert.match(fixture.context.state.editorialBindingError, /old_empty/,
+        "missing proof or a rendered missing scene remains protected");
+}
+for (const protectedField of [
+    {chapters:[{id:"chapter", start_scene:2, start_scene_id:"old_empty"}]},
+    {placements:[{scene:2, scene_id:"old_empty", start_frame:400}]},
+    {trims:[{scene:2, scene_id:"old_empty", out_frame:90}]},
+    {locked_scene_ids:["old_empty"]},
+    {replacements:[{scene:2, scene_id:"old_empty"}]},
+    {alternate_draft:{scene:2, scene_id:"old_empty"}},
+]) {
+    const fixture = studioContext();
+    fixture.context.applyEditorialPayload({...placeholderEditorial, ...protectedField}, 0, ["old_empty"]);
+    assert.match(fixture.context.state.editorialBindingError, /old_empty/);
+    fixture.context.scheduleEditorialSave(); await fixture.flush();
+    assert.equal(fixture.writes.length, 0, "saved edits are never considered an unused placeholder");
+}
+{
+    const fixture = studioContext();
+    fixture.context.applyEditorialPayload(placeholderEditorial, 0, ["old_empty"]);
+    fixture.context.applyEditorialPayload(placeholderEditorial, 0, []);
+    assert.match(fixture.context.state.editorialBindingError, /old_empty/,
+        "a later checkpoint inventory must revoke the unused-scene allowance");
+}
+console.log("Run-switch safety: hydration, explicit saves, stale mutations, ABA, batches and disposal passed");
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_scene_data_extract_js_test.mjs b/ComfyUI-MiniMaxH3-Context-Loop/tests/_scene_data_extract_js_test.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..af75d5e1ee3b38ff140ca83fede34286569d76ed
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_scene_data_extract_js_test.mjs
@@ -0,0 +1,34 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import path from "node:path";
+import {fileURLToPath} from "node:url";
+
+import {
+    SCENE_DATA_FIELDS,
+    sceneDataFieldPresentation,
+} from "../web/h3_scene_data_core.mjs";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const extensionSource = fs.readFileSync(
+    path.join(HERE, "..", "web", "h3_scene_data_extract.js"), "utf8");
+
+assert.deepEqual(sceneDataFieldPresentation("RefMod sources"), {
+    name: "refmod_sources",
+    type: "H3_REF_LIST",
+});
+assert.deepEqual(sceneDataFieldPresentation("Noise seed"), {
+    name: "noise_seed",
+    type: "INT",
+});
+assert.deepEqual(sceneDataFieldPresentation("Source audio slice"), {
+    name: "source_audio_slice",
+    type: "AUDIO",
+});
+assert.deepEqual(sceneDataFieldPresentation("unknown"),
+    SCENE_DATA_FIELDS["RefMod sources"]);
+assert.match(extensionSource, /output\.type = presentation\.type/);
+assert.match(extensionSource, /output\.name = presentation\.name/);
+assert.match(extensionSource, /widget\.callback/);
+assert.match(extensionSource, /onConfigure/);
+
+console.log("H3 scene data extractor: dropdown socket presentation passes");
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_scene_dependency_unit_test.py b/ComfyUI-MiniMaxH3-Context-Loop/tests/_scene_dependency_unit_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..57cf45c61e5da467cf578f89cc33edb626c4615b
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_scene_dependency_unit_test.py
@@ -0,0 +1,1506 @@
+#!/usr/bin/env python3
+"""Structured scene dependencies isolate generation and assembly changes."""
+
+import importlib.util
+import json
+import pathlib
+import sys
+import tempfile
+import types
+
+import torch
+
+
+ROOT = pathlib.Path(__file__).resolve().parents[1]
+PACKAGE = "h3_scene_dependency_unit"
+
+folder_paths = types.ModuleType("folder_paths")
+folder_paths.get_output_directory = lambda: str(ROOT)
+folder_paths.get_temp_directory = lambda: str(ROOT)
+folder_paths.get_input_directory = lambda: str(ROOT)
+folder_paths.get_annotated_filepath = lambda value: str(value)
+sys.modules["folder_paths"] = folder_paths
+
+package = types.ModuleType(PACKAGE)
+package.__path__ = [str(ROOT)]
+sys.modules[PACKAGE] = package
+nodes = types.ModuleType(PACKAGE + ".nodes")
+nodes.MiniMaxH3MotionContext = object
+nodes._claim_inline_patch_ownership = lambda _conditioning=None: "test"
+nodes._prepare_native_guide_conditioning = lambda value: value
+nodes._resize = lambda *args: None
+nodes._streams_from_latent = lambda *args: None
+sys.modules[nodes.__name__] = nodes
+
+spec = importlib.util.spec_from_file_location(
+    PACKAGE + ".chain_nodes", ROOT / "chain_nodes.py")
+chain = importlib.util.module_from_spec(spec)
+sys.modules[spec.name] = chain
+spec.loader.exec_module(chain)
+
+
+def make_plan(context=5):
+    return chain._normalize_plan(
+        json.dumps({"shots": [
+            {"id": "one", "prompt": "@actor opens.", "length": 39},
+            {"id": "two", "prompt": "@actor continues.", "length": 39},
+        ]}),
+        "dependency-test", 64, 64, context, "video", "head", "disabled",
+        "source_track", context, 1.0, 8, 11, 18, "body:auto:v1", 0,
+        "guide")
+
+
+def audio(values):
+    return {"waveform": values.reshape(1, 1, -1), "sample_rate": 48000}
+
+
+plan = make_plan(5)
+assert chain._resume_context_predecessors(plan, 3) == {
+    "visual": None, "audio": None, "scenes": []}
+try:
+    chain._resume_context_predecessors(plan, 4)
+except ValueError as exc:
+    assert "exceeds the 2-scene plan" in str(exc)
+else:
+    raise AssertionError("resume accepted a target beyond the complete sentinel")
+
+# Reference registries are incremental. Appending an unused prompt reference
+# must not invalidate an already-rendered predecessor, including checkpoints
+# saved before lineage metadata existed.
+registry_v1 = chain._append_tagged_reference(
+    None, kind="picture", tag="actor", value="actor-v1",
+    content_hash="actor-hash-v1")
+registry_v2 = chain._append_tagged_reference(
+    registry_v1, kind="picture", tag="later", value="later-v1",
+    content_hash="later-hash-v1")
+token_v1 = chain._reference_fingerprint_output(registry_v1)
+token_v2 = chain._reference_fingerprint_output(registry_v2)
+
+# Prompt-driven tags define identity. Rewiring the same tag→asset registry in
+# another node order must not change its fingerprint or native packing order.
+registry_reordered = chain._append_tagged_reference(
+    None, kind="picture", tag="later", value="later-v1",
+    content_hash="later-hash-v1")
+registry_reordered = chain._append_tagged_reference(
+    registry_reordered, kind="picture", tag="actor", value="actor-v1",
+    content_hash="actor-hash-v1")
+assert registry_reordered["fingerprint"] == registry_v2["fingerprint"]
+_compiled, _summary, ordered_bindings = (
+    chain._compile_tagged_reference_prompt(
+        registry_v2, 1, 1, "@later watches @actor."))
+_compiled, _summary, reordered_bindings = (
+    chain._compile_tagged_reference_prompt(
+        registry_reordered, 1, 1, "@later watches @actor."))
+assert [entry["tag"] for entry in ordered_bindings["pictures"]] == [
+    "actor", "later"]
+assert [entry["tag"] for entry in reordered_bindings["pictures"]] == [
+    "actor", "later"]
+assert ordered_bindings["aliases"] == reordered_bindings["aliases"]
+
+
+def reference_plan(token, first_prompt="@actor opens."):
+    return chain._normalize_plan(
+        json.dumps({"shots": [
+            {"id": "one", "prompt": first_prompt, "length": 39},
+            {"id": "two", "prompt": "@actor continues.", "length": 39},
+        ]}),
+        "reference-lineage-test", 64, 64, 5, "video", "head",
+        "disabled", "generated_audio", 5, 1.0, 8, 11, 18, token,
+        0, "guide")
+
+
+wrapped_token_v1 = chain._plan_studio_generation_fingerprint(
+    "model-stack:v2", registry_v1)
+wrapped_token_v2 = chain._plan_studio_generation_fingerprint(
+    "model-stack:v2", registry_v2)
+assert chain._scene_dependency_diffs(
+    chain._scene_dependency_record(reference_plan(wrapped_token_v1), 1, None),
+    chain._scene_dependency_record(reference_plan(wrapped_token_v2), 1, None),
+) == []
+
+
+old_reference_dependency = chain._scene_dependency_record(
+    reference_plan(token_v1), 1, None)
+new_reference_dependency = chain._scene_dependency_record(
+    reference_plan(token_v2), 1, None)
+assert old_reference_dependency["scopes"]["global_generation"][
+    "generation_fingerprint"] == registry_v1["fingerprint"]
+assert chain._scene_dependency_diffs(
+    old_reference_dependency, new_reference_dependency) == []
+legacy_reference_dependency = json.loads(json.dumps(old_reference_dependency))
+legacy_reference_dependency.pop("generation_fingerprint_lineage", None)
+assert chain._scene_dependency_diffs(
+    legacy_reference_dependency, new_reference_dependency) == []
+
+# New nodes may be inserted at the beginning or middle of a ComfyUI reference
+# chain. Their position must not invalidate old scenes when their tags are
+# inactive; the unchanged old registry is still present as an ordered subset.
+registry_inserted = chain._append_tagged_reference(
+    None, kind="picture", tag="actor", value="actor-v1",
+    content_hash="actor-hash-v1")
+registry_inserted = chain._append_tagged_reference(
+    registry_inserted, kind="picture", tag="stairs", value="stairs-v1",
+    content_hash="stairs-hash-v1")
+registry_inserted = chain._append_tagged_reference(
+    registry_inserted, kind="picture", tag="later", value="later-v1",
+    content_hash="later-hash-v1")
+inserted_dependency = chain._scene_dependency_record(
+    reference_plan(chain._reference_fingerprint_output(registry_inserted)),
+    1, None)
+assert chain._scene_dependency_diffs(
+    new_reference_dependency, inserted_dependency) == []
+legacy_v2_dependency = json.loads(json.dumps(new_reference_dependency))
+legacy_v2_dependency.pop("generation_fingerprint_lineage", None)
+assert chain._scene_dependency_diffs(
+    legacy_v2_dependency, inserted_dependency) == []
+legacy_reordered_fingerprint = chain._make_reference_schedule(
+    registry_reordered["entries"])["fingerprint"]
+assert legacy_reordered_fingerprint != registry_reordered["fingerprint"]
+legacy_reordered_dependency = chain._scene_dependency_record(
+    reference_plan(legacy_reordered_fingerprint), 1, None)
+assert chain._scene_dependency_diffs(
+    legacy_reordered_dependency, inserted_dependency) == []
+inserted_active_dependency = chain._scene_dependency_record(
+    reference_plan(
+        chain._reference_fingerprint_output(registry_inserted),
+        "@actor enters @stairs."), 1, None)
+assert any(item["field"] == "generation_fingerprint"
+           for item in chain._scene_dependency_diffs(
+               new_reference_dependency, inserted_active_dependency))
+
+# The same append is generation-significant when the old scene prompt activates
+# the newly registered tag.
+active_old_dependency = chain._scene_dependency_record(
+    reference_plan(token_v1, "@actor meets @later."), 1, None)
+active_new_dependency = chain._scene_dependency_record(
+    reference_plan(token_v2, "@actor meets @later."), 1, None)
+active_append_diffs = chain._scene_dependency_diffs(
+    active_old_dependency, active_new_dependency)
+assert any(item["scope"] == "global_generation"
+           and item["field"] == "generation_fingerprint"
+           for item in active_append_diffs)
+
+# Replacing an existing reference is not append-compatible and remains blocked.
+changed_registry = chain._append_tagged_reference(
+    None, kind="picture", tag="actor", value="actor-v2",
+    content_hash="actor-hash-v2")
+changed_registry = chain._append_tagged_reference(
+    changed_registry, kind="picture", tag="later", value="later-v1",
+    content_hash="later-hash-v1")
+changed_dependency = chain._scene_dependency_record(
+    reference_plan(chain._reference_fingerprint_output(changed_registry)),
+    1, None)
+assert any(item["field"] == "generation_fingerprint"
+           for item in chain._scene_dependency_diffs(
+               old_reference_dependency, changed_dependency))
+
+# Replacing an image which this completed scene never used is also neutral.
+# Unlike append-only growth, this proof uses the saved and current lineage
+# entries to compare the scene's effective tag->asset contracts directly.
+changed_inactive_registry = chain._append_tagged_reference(
+    None, kind="picture", tag="actor", value="actor-v1",
+    content_hash="actor-hash-v1")
+changed_inactive_registry = chain._append_tagged_reference(
+    changed_inactive_registry, kind="picture", tag="later",
+    value="later-v2", content_hash="later-hash-v2")
+changed_inactive_dependency = chain._scene_dependency_record(
+    reference_plan(chain._reference_fingerprint_output(
+        changed_inactive_registry)), 1, None)
+assert chain._scene_dependency_diffs(
+    new_reference_dependency, changed_inactive_dependency) == []
+changed_inactive_active_dependency = chain._scene_dependency_record(
+    reference_plan(
+        chain._reference_fingerprint_output(changed_inactive_registry),
+        "@actor meets @later."), 1, None)
+assert any(item["field"] == "generation_fingerprint"
+           for item in chain._scene_dependency_diffs(
+               active_new_dependency,
+               changed_inactive_active_dependency))
+
+# Dedicated Qwen-only semantic anchors share the incremental Plan fingerprint
+# without becoming native Ref2VA entries. Adding an unused #anchor must remain
+# resume-neutral; activating it in the old scene makes the change significant.
+semantic_entry = {
+    "kind": "semantic_anchor", "tag": "future_beat",
+    "activation": "prompt", "value": "semantic-v1",
+    "content_hash": "semantic-hash-v1",
+}
+semantic_bundle = chain._make_semantic_anchor_bundle(
+    [semantic_entry], "512", "timestamped_video")
+semantic_registry = chain._combined_reference_registry(
+    registry_v1, semantic_bundle)
+semantic_token = chain._reference_fingerprint_output(semantic_registry)
+semantic_inactive_dependency = chain._scene_dependency_record(
+    reference_plan(semantic_token), 1, None)
+assert chain._scene_dependency_diffs(
+    old_reference_dependency, semantic_inactive_dependency) == []
+semantic_active_dependency = chain._scene_dependency_record(
+    reference_plan(
+        semantic_token, "@actor reaches #future_beat[0.50s]."), 1, None)
+assert any(item["field"] == "generation_fingerprint"
+           for item in chain._scene_dependency_diffs(
+               old_reference_dependency, semantic_active_dependency))
+
+# A real migration may have several native refs plus several new semantic
+# anchors. Check every direct inactive subset before trying legacy-order
+# permutations, whose factorial search can otherwise exhaust the safety cap
+# before it reaches the unchanged native-only registry.
+large_native_registry = None
+for tag in ("actor", "wardrobe", "prop", "later_actor"):
+    large_native_registry = chain._append_tagged_reference(
+        large_native_registry, kind="picture", tag=tag, value=tag,
+        content_hash=tag + "-hash")
+large_native_registry = chain._append_tagged_reference(
+    large_native_registry, kind="audio", tag="later_audio", value="audio",
+    content_hash="later-audio-hash", timeline_mode="source_timeline",
+    align_audio_reference=True)
+legacy_large_fingerprint = chain._make_reference_schedule(
+    large_native_registry["entries"])["fingerprint"]
+large_semantic_entries = [{
+    "kind": "semantic_anchor", "tag": tag,
+    "activation": "prompt", "value": tag,
+    "content_hash": tag + "-hash",
+} for tag in ("future_a", "future_b", "future_c")]
+large_semantic_bundle = chain._make_semantic_anchor_bundle(
+    large_semantic_entries, "512", "timestamped_video")
+large_combined_registry = chain._combined_reference_registry(
+    large_native_registry, large_semantic_bundle)
+legacy_large_dependency = chain._scene_dependency_record(
+    reference_plan(
+        legacy_large_fingerprint,
+        "@actor wears @wardrobe and carries @prop."), 1, None)
+large_combined_dependency = chain._scene_dependency_record(
+    reference_plan(
+        chain._reference_fingerprint_output(large_combined_registry),
+        "@actor wears @wardrobe and carries @prop."), 1, None)
+assert chain._scene_dependency_diffs(
+    legacy_large_dependency, large_combined_dependency) == []
+
+# Legacy scheduled references use their scene selectors rather than prompt tags.
+scheduled_v1 = chain._append_scheduled_reference(
+    None, kind="picture", tag="actor", scenes="all", value="actor",
+    content_hash="actor-hash")
+scheduled_future = chain._append_scheduled_reference(
+    scheduled_v1, kind="picture", tag="future", scenes="3:6",
+    value="future", content_hash="future-hash")
+scheduled_active = chain._append_scheduled_reference(
+    scheduled_v1, kind="picture", tag="now", scenes="1",
+    value="now", content_hash="now-hash")
+scheduled_old_dependency = chain._scene_dependency_record(
+    reference_plan(chain._reference_fingerprint_output(scheduled_v1)), 1,
+    None)
+scheduled_future_dependency = chain._scene_dependency_record(
+    reference_plan(chain._reference_fingerprint_output(scheduled_future)), 1,
+    None)
+scheduled_active_dependency = chain._scene_dependency_record(
+    reference_plan(chain._reference_fingerprint_output(scheduled_active)), 1,
+    None)
+assert chain._scene_dependency_diffs(
+    scheduled_old_dependency, scheduled_future_dependency) == []
+assert any(item["field"] == "generation_fingerprint"
+           for item in chain._scene_dependency_diffs(
+               scheduled_old_dependency, scheduled_active_dependency))
+
+samples = round(plan["total_delivered_frames"] / 24 * 48000)
+base = torch.linspace(-0.8, 0.8, samples)
+changed = base.clone()
+# Scene 1 consumes frames 0:39. Scene 2 consumes 34:73; change only after 39.
+changed[39 * 2000:] *= -1
+audio_a = audio(base)
+audio_b = audio(changed)
+prepared_a = chain._plan_with_source_audio(plan, audio_a)
+prepared_b = chain._plan_with_source_audio(plan, audio_b)
+
+scene1_a = chain._scene_dependency_record(
+    prepared_a, 1, chain._canonical_source_reference_dependency(
+        prepared_a, 1, None, audio_a))
+scene1_b = chain._scene_dependency_record(
+    prepared_b, 1, chain._canonical_source_reference_dependency(
+        prepared_b, 1, None, audio_b))
+assert chain._scene_dependency_diffs(scene1_a, scene1_b) == []
+
+scene2_a = chain._scene_dependency_record(
+    prepared_a, 2, chain._canonical_source_reference_dependency(
+        prepared_a, 2, None, audio_a))
+scene2_b = chain._scene_dependency_record(
+    prepared_b, 2, chain._canonical_source_reference_dependency(
+        prepared_b, 2, None, audio_b))
+audio_diffs = chain._scene_dependency_diffs(scene2_a, scene2_b)
+assert any(item["scope"] == "scene_generation"
+           and item["field"].endswith("pcm_sha256")
+           for item in audio_diffs)
+assert all(item["scene"] == 2 and item["regeneration_required"]
+           for item in audio_diffs)
+
+locked_policy = chain._contract_compose_chain_policy(
+    chain._contract_audio_policy("source", "on", "on", "locked"),
+    chain._contract_transition_policy("guide"),
+    audio_context_length=22)
+locked_plan = chain._normalize_plan(
+    json.dumps({"shots": [
+        {"id": "one", "prompt": "@actor opens.", "length": 39},
+        {"id": "two", "prompt": "@actor continues.", "length": 39},
+    ]}),
+    "locked-dependency-test", 64, 64, 5, "video", "head", "disabled",
+    "generated_audio", 5, 1.0, 8, 11, 18, "body:auto:v1", 0,
+    "guide", locked_policy)
+locked_prepared = chain._plan_with_source_audio(locked_plan, audio_a)
+locked_source_dependency = chain._canonical_source_reference_dependency(
+    locked_prepared, 1, None, audio_a)
+assert locked_source_dependency is not None
+locked_dependency = chain._scene_dependency_record(
+    locked_prepared, 1, locked_source_dependency)
+assert locked_dependency["scopes"]["global_generation"][
+    "source_audio_target"] == "locked"
+assert locked_dependency["scopes"]["scene_generation"][
+    "source_reference_window"]["pcm_sha256"]
+
+# Final mux choice and whole-source identity are assembly-only.
+assembly_changed = json.loads(json.dumps(scene1_a))
+assembly_changed["scopes"]["assembly_only"]["final_audio"] = "generated"
+assembly_changed["scopes"]["assembly_only"]["source_audio_fingerprint"] = "x"
+assert chain._scene_dependency_diffs(scene1_a, assembly_changed) == []
+
+# A scene's selected pre-patched MODEL route remains routing/provenance only.
+# It must not invalidate completed predecessors, and the default Base spelling
+# remains absent for old checkpoint compatibility.
+assert "lora_route" not in scene1_a["scopes"]["scene_generation"]
+routed_plan = json.loads(json.dumps(prepared_a))
+routed_plan["shots"][0]["lora_route"] = "a"
+routed_dependency = chain._scene_dependency_record(
+    routed_plan, 1,
+    scene1_a["scopes"]["scene_generation"]["source_reference_window"])
+route_diffs = chain._scene_dependency_diffs(scene1_a, routed_dependency)
+assert route_diffs == []
+assert "lora_route" not in chain._history_contract(
+    routed_plan, 1)["shots"][0]
+
+# A later incoming context does not retroactively redefine scene 1.
+long_context = make_plan(22)
+prepared_long = chain._plan_with_source_audio(long_context, audio_a)
+long_scene1 = chain._scene_dependency_record(
+    prepared_long, 1, chain._canonical_source_reference_dependency(
+        prepared_long, 1, None, audio_a))
+assert chain._scene_dependency_diffs(scene1_a, long_scene1) == []
+long_scene2 = chain._scene_dependency_record(
+    prepared_long, 2, chain._canonical_source_reference_dependency(
+        prepared_long, 2, None, audio_a))
+boundary_diffs = chain._scene_dependency_diffs(scene2_a, long_scene2)
+assert any(item["scope"] == "incoming_boundary"
+           and item["field"] == "context_length"
+           for item in boundary_diffs)
+assert chain._resume_context_predecessor(make_plan(5), 2) == 1
+independent_start_plan = make_plan(5)
+independent_start_plan["shots"][1]["context_length"] = 0
+independent_start_plan["shots"][1]["audio_context_length"] = 0
+assert chain._resume_context_predecessor(independent_start_plan, 2) is None
+
+# Visual and generated-audio continuity are independent edges. Scene 5 can
+# consume scene 3's saved picture state while retaining scene 4's audio latent.
+nonlinear_plan = chain._normalize_plan(
+    json.dumps({"shots": [
+        {"id": name, "prompt": name, "length": 90,
+         **({"visual_context_source": "three",
+             "video_blend_frames": 0} if name == "five" else {})}
+        for name in ("one", "two", "three", "four", "five")
+    ]}),
+    "nonlinear-context-test", 64, 64, 5, "video", "head", "disabled",
+    "generated_audio", 5, 1.0, 8, 11, 18, "body:auto:v1", 0,
+    "guide")
+assert nonlinear_plan["shots"][4]["visual_context_source"] == "three"
+assert chain._shot_visual_context_source(nonlinear_plan, 5) == 3
+linear_spelling = json.loads(json.dumps(nonlinear_plan))
+linear_spelling["shots"][4]["visual_context_source"] = "four"
+assert chain._shot_visual_context_source(linear_spelling, 5) == 4
+nonlinear_sources = chain._resume_context_predecessors(nonlinear_plan, 5)
+assert nonlinear_sources == {"visual": 3, "audio": 4, "scenes": [3, 4]}
+nonlinear_dependency = chain._scene_dependency_record(
+    nonlinear_plan, 5, None)
+assert nonlinear_dependency["scopes"]["incoming_boundary"][
+    "visual_context_source_scene"] == 3
+assert nonlinear_dependency["scopes"]["incoming_boundary"][
+    "visual_context_source_id"] == "three"
+
+windowed_plan_source = json.loads(json.dumps({"shots": [
+    {"id": name, "prompt": name, "length": 90,
+     **({"visual_context_source": "three",
+         "visual_context_start_frame": 12,
+         "video_blend_frames": 0} if name == "five" else {})}
+    for name in ("one", "two", "three", "four", "five")
+]}))
+windowed_plan = chain._normalize_plan(
+    json.dumps(windowed_plan_source),
+    "windowed-context-test", 64, 64, 5, "video", "head", "disabled",
+    "generated_audio", 5, 1.0, 8, 11, 18, "body:auto:v1", 0,
+    "latent_guide")
+assert windowed_plan["shots"][4]["visual_context_start_frame"] == 12
+windowed_boundary = chain._scene_dependency_record(
+    windowed_plan, 5, None)["scopes"]["incoming_boundary"]
+assert windowed_boundary["visual_context_start_frame"] == 12
+
+# Explicitly spelling the historical tail canonicalizes back to absence.
+tail_plan_source = json.loads(json.dumps(windowed_plan_source))
+tail_plan_source["shots"][4]["visual_context_start_frame"] = 80
+tail_plan = chain._normalize_plan(
+    json.dumps(tail_plan_source),
+    "tail-context-test", 64, 64, 5, "video", "head", "disabled",
+    "generated_audio", 5, 1.0, 8, 11, 18, "body:auto:v1", 0,
+    "latent_guide")
+assert "visual_context_start_frame" not in tail_plan["shots"][4]
+
+source_frames = torch.full((5, 2, 2, 3), 3.0)
+source_video = torch.full((1, 24, 2, 2, 2), 30.0)
+immediate_video = torch.full((1, 24, 2, 2, 2), 40.0)
+immediate_audio = torch.full((1, 32, 2), 44.0)
+original_loader = chain._st_load
+original_streams = chain._streams_from_latent
+chain._st_load = lambda _path: {
+    "context_frames": source_frames, "video": source_video,
+}
+chain._streams_from_latent = lambda value: value["samples"]
+try:
+    nonlinear_state = {
+        "plan": nonlinear_plan, "index": 5,
+        "previous_frames": torch.full((5, 2, 2, 3), 4.0),
+        "previous_latent": {
+            "samples": [immediate_video, immediate_audio]},
+        "segments": [
+            {"index": scene, "id": nonlinear_plan["shots"][scene - 1]["id"],
+             "checkpoint": "scene_%d.safetensors" % scene,
+             "revision": "r%d" % scene,
+             "checkpoint_sha256": "h%d" % scene}
+            for scene in range(1, 5)
+        ],
+    }
+    selected_state = chain._visual_context_state(nonlinear_state)
+    assert selected_state is not nonlinear_state
+    assert selected_state["previous_frames"] is source_frames
+    assert selected_state["previous_latent"]["samples"][0] is source_video
+    assert selected_state["previous_latent"]["samples"][1] is immediate_audio
+    assert [item["index"] for item in selected_state["segments"]] == [1, 2, 3]
+    assert nonlinear_state["previous_latent"]["samples"][0] is immediate_video
+    assert chain._visual_context_state(nonlinear_state) is selected_state
+finally:
+    chain._st_load = original_loader
+    chain._streams_from_latent = original_streams
+
+class WindowVAE:
+    def __init__(self):
+        self.decoded = None
+
+    def decode(self, video):
+        self.decoded = video.detach().clone()
+        values = torch.arange(5, dtype=torch.float32).reshape(5, 1, 1, 1)
+        return values.expand(5, 2, 2, 3).clone()
+
+    def encode(self, _frames):
+        raise AssertionError("native context selection must not re-encode RGB")
+
+window_vae = WindowVAE()
+chain._st_load = lambda _path: {
+    "context_frames": torch.arange(
+        85, 90, dtype=torch.float32,
+    ).reshape(5, 1, 1, 1).expand(5, 2, 2, 3).clone(),
+    "video": torch.arange(27, dtype=torch.float32).reshape(
+        1, 1, 27, 1, 1).expand(1, 24, 27, 2, 2).clone(),
+}
+chain._streams_from_latent = lambda value: value["samples"]
+try:
+    windowed_state = chain._visual_context_state({
+        "plan": windowed_plan, "index": 5,
+        "previous_frames": torch.full((5, 2, 2, 3), 4.0),
+        "previous_latent": {
+            "samples": [immediate_video, immediate_audio]},
+        "segments": [
+            {"index": scene,
+             "id": windowed_plan["shots"][scene - 1]["id"],
+             "checkpoint": "scene_%d.safetensors" % scene,
+             "revision": "r%d" % scene,
+             "checkpoint_sha256": "h%d" % scene,
+             "raw_frames": 90,
+             "delivered_frames": 90 if scene == 1 else 85}
+            for scene in range(1, 5)
+        ],
+    }, vae=window_vae)
+    assert windowed_state["_visual_context_resolved_start_frame"] == 12
+    assert windowed_state["previous_frames"].shape[0] == 0
+    selected_video = windowed_state["previous_latent"]["samples"][0]
+    assert selected_video.shape[2] == 2
+    assert torch.all(selected_video[:, :, 0] == 5.0)
+    assert torch.all(selected_video[:, :, 1] == 6.0)
+    recovered = chain._previous_context_frames(windowed_state, window_vae, 5)
+    assert recovered.shape[0] == 5
+    assert torch.equal(window_vae.decoded, selected_video)
+    assert windowed_state["previous_latent"]["samples"][1] is immediate_audio
+finally:
+    chain._st_load = original_loader
+    chain._streams_from_latent = original_streams
+
+# Two independent saved picture tails can form one H3-phase-safe prefix. The
+# first block may come from a chronologically newer scene than the second;
+# their explicit order in the Plan is what matters. Audio stays the complete
+# immediate-predecessor latent and is never spliced at the visual seam.
+composed_plan = chain._normalize_plan(
+    json.dumps({"shots": [
+        {"id": name, "prompt": name, "length": 90,
+         **({"visual_context_source": "three",
+             "visual_context_lead_source": "four",
+             "visual_context_lead_frames": 5,
+             "video_blend_frames": 0} if name == "five" else {})}
+        for name in ("one", "two", "three", "four", "five")
+    ]}),
+    "composed-context-test", 64, 64, 39, "video", "head", "disabled",
+    "generated_audio", 39, 1.0, 8, 11, 18, "body:auto:v1", 0,
+    "masked_av")
+assert composed_plan["shots"][4]["visual_context_source"] == "three"
+assert composed_plan["shots"][4]["visual_context_lead_source"] == "four"
+assert composed_plan["shots"][4]["visual_context_lead_frames"] == 5
+assert chain._resume_context_predecessors(composed_plan, 5) == {
+    "visual": 3, "audio": 4, "scenes": [3, 4], "visual_lead": 4,
+}
+composed_boundary = chain._scene_dependency_record(
+    composed_plan, 5, None)["scopes"]["incoming_boundary"]
+assert composed_boundary["visual_context_source_scene"] == 3
+assert composed_boundary["visual_context_lead_source_scene"] == 4
+assert composed_boundary["visual_context_lead_source_id"] == "four"
+assert composed_boundary["visual_context_lead_frames"] == 5
+composed_revision = chain._checkpoint_plan_revision({
+    "index": 5, "id": "five", "revision": "r5",
+    "seed": "5", "steps": 8, "raw_frames": 90,
+    "segment": "scene_5.mp4",
+    "visual_context_source_id": "three",
+    "visual_context_start_frame": 8,
+    "visual_context_lead_source_id": "four",
+    "visual_context_lead_frames": 5,
+    "visual_context_lead_start_frame": 9,
+    "audio_context_unlocked": True,
+    "audio_context_source_id": "two",
+    "audio_context_start_frame": 7,
+    "audio_context_lead_source_id": "three",
+    "audio_context_lead_frames": 17,
+    "audio_context_lead_start_frame": 11,
+})
+assert composed_revision["visual_context_source"] == "three"
+assert composed_revision["visual_context_start_frame"] == 8
+assert composed_revision["visual_context_lead_source"] == "four"
+assert composed_revision["visual_context_lead_frames"] == 5
+assert composed_revision["visual_context_lead_start_frame"] == 9
+assert composed_revision["audio_context_unlocked"] is True
+assert composed_revision["audio_context_source"] == "two"
+assert composed_revision["audio_context_start_frame"] == 7
+assert composed_revision["audio_context_lead_source"] == "three"
+assert composed_revision["audio_context_lead_frames"] == 17
+assert composed_revision["audio_context_lead_start_frame"] == 11
+
+# The two native-aligned blocks may also select independent windows from the
+# same saved scene. A 5+34 composition remains one direct 39-frame latent
+# prefix; only generated audio continues to come from the timeline predecessor.
+same_scene_plan = chain._normalize_plan(
+    json.dumps({"shots": [
+        {"id": name, "prompt": name, "length": 90,
+         **({"visual_context_source": "three",
+             "visual_context_start_frame": 0,
+             "visual_context_lead_source": "three",
+             "visual_context_lead_frames": 5,
+             "visual_context_lead_start_frame": 12,
+             "video_blend_frames": 0} if name == "five" else {})}
+        for name in ("one", "two", "three", "four", "five")
+    ]}),
+    "same-scene-composed-context-test", 64, 64, 39, "video", "head",
+    "disabled", "generated_audio", 39, 1.0, 8, 11, 18,
+    "body:auto:v1", 0, "masked_av")
+assert same_scene_plan["shots"][4]["visual_context_source"] == "three"
+assert same_scene_plan["shots"][4]["visual_context_lead_source"] == "three"
+assert chain._resume_context_predecessors(same_scene_plan, 5) == {
+    "visual": 3, "audio": 4, "scenes": [3, 4], "visual_lead": 3,
+}
+
+# The nightly builder accepts any ordered number of phase-safe picture
+# blocks. Sources may repeat, and every source remains an explicit resume
+# dependency while generated audio stays on the immediate predecessor.
+builder_plan = chain._normalize_plan(
+    json.dumps({"shots": [
+        {"id": name, "prompt": name, "length": 90,
+         **({"visual_context_blocks": [
+             {"source": "three", "frames": 5},
+             {"source": "four", "frames": 12},
+             {"source": "three", "frames": 22},
+         ], "video_blend_frames": 0} if name == "five" else {})}
+        for name in ("one", "two", "three", "four", "five")
+    ]}),
+    "visual-context-builder-test", 64, 64, 39, "video", "head",
+    "disabled", "generated_audio", 39, 1.0, 8, 11, 18,
+    "body:auto:v1", 0, "masked_av")
+assert builder_plan["shots"][4]["visual_context_blocks"] == [
+    {"source": "three", "frames": 5},
+    {"source": "four", "frames": 12},
+    {"source": "three", "frames": 22},
+]
+assert chain._resume_context_predecessors(builder_plan, 5) == {
+    "visual": 3, "audio": 4, "scenes": [3, 4],
+    "visual_blocks": [3, 4, 3],
+}
+builder_boundary = chain._scene_dependency_record(
+    builder_plan, 5, None)["scopes"]["incoming_boundary"]
+assert builder_boundary["visual_context_blocks"] == [
+    {"source_scene": 3, "source_id": "three", "frames": 5},
+    {"source_scene": 4, "source_id": "four", "frames": 12},
+    {"source_scene": 3, "source_id": "three", "frames": 22},
+]
+builder_revision = chain._checkpoint_plan_revision({
+    "index": 5, "id": "five", "revision": "r5", "seed": "5",
+    "steps": 8, "raw_frames": 90, "segment": "scene_5.mp4",
+    "visual_context_blocks": [
+        {"source_id": "three", "frames": 5,
+         "resolved_start_frame": 46},
+        {"source_id": "four", "frames": 12, "start_frame": 0,
+         "resolved_start_frame": 0},
+        {"source_id": "three", "frames": 22,
+         "resolved_start_frame": 29},
+    ],
+})
+assert builder_revision["visual_context_blocks"] == [
+    {"source": "three", "frames": 5},
+    {"source": "four", "frames": 12, "start_frame": 0},
+    {"source": "three", "frames": 22},
+]
+
+invalid_builder = {"shots": [
+    {"id": name, "prompt": name, "length": 90,
+     **({"visual_context_blocks": [
+         {"source": "three", "frames": 6},
+         {"source": "four", "frames": 33},
+     ]} if name == "five" else {})}
+    for name in ("one", "two", "three", "four", "five")
+]}
+try:
+    chain._normalize_plan(
+        json.dumps(invalid_builder), "invalid-visual-builder", 64, 64, 39,
+        "video", "head", "disabled", "generated_audio", 39, 1.0, 8,
+        11, 18, "body:auto:v1", 0, "masked_av")
+except ValueError as exc:
+    assert "not an H3 latent boundary" in str(exc)
+else:
+    raise AssertionError("invalid three-block visual partition was accepted")
+
+# Audio stays on the immediate predecessor unless the Context planner is
+# explicitly unlocked. Once unlocked, one or two exact 40 Hz latent windows
+# may be selected independently from the picture composition.
+independent_audio_plan = chain._normalize_plan(
+    json.dumps({"shots": [
+        {"id": name, "prompt": name, "length": 90,
+         **({"visual_context_source": "three",
+             "visual_context_lead_source": "four",
+             "visual_context_lead_frames": 5,
+             "video_blend_frames": 0,
+             "audio_context_unlocked": True,
+             "audio_context_source": "three",
+             "audio_context_start_frame": 0,
+             "audio_context_lead_source": "four",
+             "audio_context_lead_frames": 5,
+             "audio_context_lead_start_frame": 12}
+            if name == "five" else {})}
+        for name in ("one", "two", "three", "four", "five")
+    ]}),
+    "independent-audio-context-test", 64, 64, 39, "video", "head",
+    "disabled", "generated_audio", 39, 1.0, 8, 11, 18,
+    "body:auto:v1", 0, "masked_av")
+assert independent_audio_plan["shots"][4]["audio_context_unlocked"] is True
+assert independent_audio_plan["shots"][4]["audio_context_source"] == "three"
+assert independent_audio_plan["shots"][4]["audio_context_lead_source"] == "four"
+assert independent_audio_plan["shots"][4]["audio_context_lead_frames"] == 5
+assert chain._resume_context_predecessors(independent_audio_plan, 5) == {
+    "visual": 3, "audio": 3, "scenes": [3, 4],
+    "visual_lead": 4, "audio_lead": 4,
+}
+independent_audio_boundary = chain._scene_dependency_record(
+    independent_audio_plan, 5, None)["scopes"]["incoming_boundary"]
+assert independent_audio_boundary["audio_context_unlocked"] is True
+assert independent_audio_boundary["audio_context_source_scene"] == 3
+assert independent_audio_boundary["audio_context_lead_source_scene"] == 4
+assert independent_audio_boundary["audio_context_lead_frames"] == 5
+
+for audio_mode, scene_patch, expected in (
+        ("source_track", {}, "generated continuity is disabled"),
+        ("generated_audio", {"source_audio_target": "locked"},
+         "Lip-sync to source audio")):
+    invalid_audio_shots = [
+        {"id": name, "prompt": name, "length": 90,
+         **({"audio_context_unlocked": True, **scene_patch}
+            if name == "five" else {})}
+        for name in ("one", "two", "three", "four", "five")
+    ]
+    try:
+        chain._normalize_plan(
+            json.dumps({"shots": invalid_audio_shots}),
+            "invalid-independent-audio", 64, 64, 39, "video", "head",
+            "disabled", audio_mode, 39, 1.0, 8, 11, 18,
+            "body:auto:v1", 0, "masked_av")
+    except ValueError as exc:
+        assert expected in str(exc)
+    else:
+        raise AssertionError(
+            "independent audio was accepted without generated continuity")
+
+scene_two_same_source_plan = chain._normalize_plan(
+    json.dumps({"shots": [
+        {"id": "one", "prompt": "one", "length": 90},
+        {"id": "two", "prompt": "two", "length": 90,
+         "visual_context_start_frame": 5,
+         "visual_context_lead_source": "one",
+         "visual_context_lead_frames": 5,
+         "visual_context_lead_start_frame": 0,
+         "video_blend_frames": 0},
+    ]}),
+    "scene-two-same-source-test", 64, 64, 39, "video", "head",
+    "disabled", "generated_audio", 39, 1.0, 8, 11, 18,
+    "body:auto:v1", 0, "masked_av")
+assert chain._resume_context_predecessors(scene_two_same_source_plan, 2) == {
+    "visual": 1, "audio": 1, "scenes": [1], "visual_lead": 1,
+}
+
+scene3_frames = torch.full((39, 2, 2, 3), 3.0)
+scene4_frames = torch.full((39, 2, 2, 3), 4.0)
+scene3_video = (30.0 + torch.arange(27, dtype=torch.float32)).reshape(
+    1, 1, 27, 1, 1).expand(1, 24, 27, 2, 2).clone()
+scene4_video = (40.0 + torch.arange(27, dtype=torch.float32)).reshape(
+    1, 1, 27, 1, 1).expand(1, 24, 27, 2, 2).clone()
+full_immediate_audio = torch.full((1, 32, 2, 80), 44.0)
+
+def composed_loader(path):
+    scene = 4 if "scene_4" in str(path) else 3
+    return {
+        "context_frames": scene4_frames if scene == 4 else scene3_frames,
+        "video": scene4_video if scene == 4 else scene3_video,
+    }
+
+chain._st_load = composed_loader
+chain._streams_from_latent = lambda value: value["samples"]
+try:
+    composed_state = {
+        "plan": composed_plan, "index": 5,
+        "previous_frames": scene4_frames,
+        "previous_latent": {
+            "samples": [scene4_video, full_immediate_audio]},
+        "segments": [
+            {"index": scene, "id": composed_plan["shots"][scene - 1]["id"],
+             "checkpoint": "scene_%d.safetensors" % scene,
+             "revision": "r%d" % scene,
+             "checkpoint_sha256": "h%d" % scene}
+            for scene in range(1, 5)
+        ],
+    }
+    composed_state = chain._visual_context_state(composed_state)
+    frames = composed_state["previous_frames"]
+    video, audio_latent = composed_state["previous_latent"]["samples"]
+    assert frames.shape[0] == 39
+    assert torch.all(frames[:5] == 4.0)
+    assert torch.all(frames[5:] == 3.0)
+    assert video.shape[2] == 12
+    assert torch.all(video[:, :, 0] == 65.0)
+    assert torch.all(video[:, :, 1] == 66.0)
+    assert torch.all(video[:, :, 2] == 47.0)
+    assert torch.all(video[:, :, -1] == 56.0)
+    assert audio_latent is full_immediate_audio
+    assert composed_state["visual_context_source_segment"]["index"] == 3
+    assert composed_state["visual_context_lead_segment"]["index"] == 4
+
+    builder_loads = {3: 0, 4: 0}
+    def builder_loader(path):
+        scene = 4 if "scene_4" in str(path) else 3
+        builder_loads[scene] += 1
+        return composed_loader(path)
+
+    chain._st_load = builder_loader
+    builder_state = chain._visual_context_state({
+        "plan": builder_plan, "index": 5,
+        "previous_frames": scene4_frames,
+        "previous_latent": {
+            "samples": [scene4_video, full_immediate_audio]},
+        "segments": [
+            {"index": scene,
+             "id": builder_plan["shots"][scene - 1]["id"],
+             "checkpoint": "scene_%d.safetensors" % scene,
+             "revision": "r%d" % scene,
+             "checkpoint_sha256": "h%d" % scene}
+            for scene in range(1, 5)
+        ],
+    })
+    builder_frames = builder_state["previous_frames"]
+    builder_video, builder_audio = builder_state[
+        "previous_latent"]["samples"]
+    assert builder_frames.shape[0] == 39
+    assert torch.all(builder_frames[:5] == 3.0)
+    assert torch.all(builder_frames[5:17] == 4.0)
+    assert torch.all(builder_frames[17:] == 3.0)
+    assert builder_video.shape[2] == 12
+    assert builder_audio is full_immediate_audio
+    assert builder_loads == {3: 1, 4: 1}
+    assert [block["source"] for block in builder_state[
+        "visual_context_block_segments"]] == [3, 4, 3]
+    assert [item["index"] for item in builder_state["segments"]] == [
+        1, 2, 3, 4]
+    chain._st_load = composed_loader
+
+    same_scene_state = chain._visual_context_state({
+        "plan": same_scene_plan, "index": 5,
+        "previous_frames": scene4_frames,
+        "previous_latent": {
+            "samples": [scene4_video, full_immediate_audio]},
+        "segments": [
+            {"index": scene,
+             "id": same_scene_plan["shots"][scene - 1]["id"],
+             "checkpoint": "scene_%d.safetensors" % scene,
+             "revision": "r%d" % scene,
+             "checkpoint_sha256": "h%d" % scene}
+            for scene in range(1, 5)
+        ],
+    })
+    same_scene_video, same_scene_audio = same_scene_state[
+        "previous_latent"]["samples"]
+    assert same_scene_state["previous_frames"].shape[0] == 0
+    assert same_scene_video.shape[2] == 12
+    assert torch.all(same_scene_video[:, :, 0] == 45.0)
+    assert torch.all(same_scene_video[:, :, 1] == 46.0)
+    assert torch.all(same_scene_video[:, :, 2] == 42.0)
+    assert torch.all(same_scene_video[:, :, -1] == 51.0)
+    assert same_scene_audio is full_immediate_audio
+    assert same_scene_state["visual_context_source_segment"]["index"] == 3
+    assert same_scene_state["visual_context_lead_segment"]["index"] == 3
+
+    # Each side of an addition can independently select a native latent crop.
+    # An unavailable RGB mirror is decoded from the assembled crop, never
+    # re-encoded into a replacement latent.
+    windowed_composed_plan = json.loads(json.dumps(composed_plan))
+    windowed_composed_plan["shots"][4]["visual_context_start_frame"] = 0
+    windowed_composed_plan["shots"][4][
+        "visual_context_lead_start_frame"] = 12
+
+    class WindowedCompositionVAE:
+        def __init__(self):
+            self.decoded = None
+
+        def decode(self, video):
+            self.decoded = video.detach().clone()
+            return torch.full((39, 2, 2, 3), 8.0)
+
+        def encode(self, _frames):
+            raise AssertionError(
+                "native composed context must not re-encode RGB")
+
+    windowed_composition_vae = WindowedCompositionVAE()
+    windowed_composed_state = chain._visual_context_state({
+        "plan": windowed_composed_plan, "index": 5,
+        "previous_frames": scene4_frames,
+        "previous_latent": {
+            "samples": [scene4_video, full_immediate_audio]},
+        "segments": [
+            {"index": scene,
+             "id": windowed_composed_plan["shots"][scene - 1]["id"],
+             "checkpoint": "scene_%d.safetensors" % scene,
+             "revision": "r%d" % scene,
+             "checkpoint_sha256": "h%d" % scene,
+             "raw_frames": 90,
+             "delivered_frames": 90 if scene == 1 else 51}
+            for scene in range(1, 5)
+        ],
+    }, vae=windowed_composition_vae)
+    assert windowed_composed_state["previous_frames"].shape[0] == 0
+    windowed_video = windowed_composed_state[
+        "previous_latent"]["samples"][0]
+    assert windowed_video.shape[2] == 12
+    assert torch.all(windowed_video[:, :, 0] == 55.0)
+    assert torch.all(windowed_video[:, :, 1] == 56.0)
+    assert torch.all(windowed_video[:, :, 2] == 42.0)
+    assert torch.all(windowed_video[:, :, -1] == 51.0)
+    windowed_frames = chain._previous_context_frames(
+        windowed_composed_state, windowed_composition_vae, 39)
+    assert torch.all(windowed_frames == 8.0)
+    assert torch.equal(windowed_composition_vae.decoded, windowed_video)
+
+    # The inverse ordered split is equally authorable. Its latest aligned lead
+    # crop intentionally stops before the physical tail so both saved latent
+    # blocks match their target temporal phases.
+    reverse_plan = json.loads(json.dumps(composed_plan))
+    reverse_plan["shots"][4]["visual_context_lead_frames"] = 17
+    assert chain._shot_visual_context_lead_frames(
+        reverse_plan["shots"][4], 39) == 17
+
+    reverse_state = chain._visual_context_state({
+        "plan": reverse_plan, "index": 5,
+        "previous_frames": scene4_frames,
+        "previous_latent": {
+            "samples": [scene4_video, full_immediate_audio]},
+        "segments": [
+            {"index": scene, "id": reverse_plan["shots"][scene - 1]["id"],
+             "checkpoint": "scene_%d.safetensors" % scene,
+             "revision": "r%d" % scene,
+             "checkpoint_sha256": "h%d" % scene}
+            for scene in range(1, 5)
+        ],
+    })
+    reverse_frames = reverse_state["previous_frames"]
+    reverse_video = reverse_state["previous_latent"]["samples"][0]
+    assert torch.all(reverse_frames[:17] == 4.0)
+    assert torch.all(reverse_frames[17:] == 3.0)
+    assert torch.all(reverse_video[:, :, 0] == 60.0)
+    assert torch.all(reverse_video[:, :, 4] == 64.0)
+    assert torch.all(reverse_video[:, :, 5] == 50.0)
+    assert torch.all(reverse_video[:, :, -1] == 56.0)
+    assert reverse_state["previous_latent"]["samples"][1] is full_immediate_audio
+finally:
+    chain._st_load = original_loader
+    chain._streams_from_latent = original_streams
+
+scene3_audio = torch.arange(150, dtype=torch.float32).reshape(
+    1, 1, 1, 150).expand(1, 32, 2, 150).clone()
+scene4_audio = (1000.0 + torch.arange(150, dtype=torch.float32)).reshape(
+    1, 1, 1, 150).expand(1, 32, 2, 150).clone()
+
+def independent_audio_loader(path):
+    scene = 4 if "scene_4" in str(path) else 3
+    return {
+        "context_frames": scene4_frames if scene == 4 else scene3_frames,
+        "video": scene4_video if scene == 4 else scene3_video,
+        "audio": scene4_audio if scene == 4 else scene3_audio,
+    }
+
+chain._st_load = independent_audio_loader
+chain._streams_from_latent = lambda value: value["samples"]
+try:
+    independent_audio_state = chain._selected_context_state({
+        "plan": independent_audio_plan, "index": 5,
+        "previous_frames": scene4_frames,
+        "previous_latent": {
+            "samples": [scene4_video, full_immediate_audio]},
+        "segments": [
+            {"index": scene,
+             "id": independent_audio_plan["shots"][scene - 1]["id"],
+             "checkpoint": "scene_%d.safetensors" % scene,
+             "revision": "r%d" % scene,
+             "checkpoint_sha256": "h%d" % scene,
+             "raw_frames": 90,
+             "delivered_frames": 90 if scene == 1 else 51}
+            for scene in range(1, 5)
+        ],
+    })
+    selected_audio = independent_audio_state[
+        "previous_latent"]["samples"][1]
+    assert selected_audio.shape[-1] == 65
+    # Scene 4 frames 12..16 map to latent steps 85..92; scene 3 frames
+    # 0..33 map to 65..121. Their authored order is preserved.
+    assert torch.all(selected_audio[..., 0] == 1085.0)
+    assert torch.all(selected_audio[..., 7] == 1092.0)
+    assert torch.all(selected_audio[..., 8] == 65.0)
+    assert torch.all(selected_audio[..., -1] == 121.0)
+    assert independent_audio_state["audio_context_source_segment"]["index"] == 3
+    assert independent_audio_state["audio_context_lead_segment"]["index"] == 4
+finally:
+    chain._st_load = original_loader
+    chain._streams_from_latent = original_streams
+
+short_scene3_frames = scene3_frames[-5:]
+short_scene4_frames = scene4_frames[-5:]
+
+def short_composed_loader(path):
+    scene = 4 if "scene_4" in str(path) else 3
+    return {
+        "context_frames": (
+            short_scene4_frames if scene == 4 else short_scene3_frames),
+        "video": scene4_video if scene == 4 else scene3_video,
+    }
+
+class ComposedDecodeVAE:
+    def __init__(self):
+        self.input = None
+
+    def decode(self, latent):
+        self.input = latent
+        return torch.full((39, 2, 2, 3), 9.0)
+
+chain._st_load = short_composed_loader
+chain._streams_from_latent = lambda value: value["samples"]
+try:
+    short_state = chain._visual_context_state({
+        "plan": composed_plan, "index": 5,
+        "previous_frames": short_scene4_frames,
+        "previous_latent": {
+            "samples": [scene4_video, full_immediate_audio]},
+        "segments": [
+            {"index": scene, "id": composed_plan["shots"][scene - 1]["id"],
+             "checkpoint": "scene_%d.safetensors" % scene}
+            for scene in range(1, 5)
+        ],
+    })
+    assert short_state["previous_frames"].shape[0] == 0
+    decoder = ComposedDecodeVAE()
+    recovered = chain._previous_context_frames(short_state, decoder, 39)
+    assert recovered.shape[0] == 39
+    assert torch.all(recovered == 9.0)
+    assert decoder.input is short_state["previous_latent"]["samples"][0]
+    assert short_state["previous_frames"] is recovered
+finally:
+    chain._st_load = original_loader
+    chain._streams_from_latent = original_streams
+
+for invalid_patch, expected in (
+        # This start fits inside the movie, but it bisects an H3 temporal
+        # latent block and therefore cannot be represented as a direct crop.
+        ({"visual_context_start_frame": 11}, "native temporal latent lattice"),
+        ({"visual_context_lead_source": "four",
+          "visual_context_lead_frames": 6}, "must be one of"),
+        ({"visual_context_lead_source": "four",
+          "visual_context_lead_frames": 5,
+          "visual_context_lead_start_frame": 47}, "must be between"),
+        ({"visual_context_lead_source": "four",
+          "visual_context_lead_frames": 5,
+          "video_blend_frames": 2}, "video_blend_frames must be 0")):
+    invalid_shots = [
+        {"id": name, "prompt": name, "length": 90,
+         **({"visual_context_source": "three", **invalid_patch}
+            if name == "five" else {})}
+        for name in ("one", "two", "three", "four", "five")
+    ]
+    try:
+        chain._normalize_plan(
+            json.dumps({"shots": invalid_shots}),
+            "invalid-composed-context", 64, 64, 39, "video", "head",
+            "disabled", "generated_audio", 39, 1.0, 8, 11, 18,
+            "body:auto:v1", 0, "masked_av")
+    except ValueError as exc:
+        assert expected in str(exc)
+    else:
+        raise AssertionError("invalid composed visual context was accepted")
+
+try:
+    chain._normalize_plan(
+        json.dumps({"shots": [
+            {"id": name, "prompt": name, "length": 39,
+             **({"visual_context_source": "three",
+                 "video_blend_frames": 2} if name == "five" else {})}
+            for name in ("one", "two", "three", "four", "five")
+        ]}),
+        "invalid-nonlinear-blend", 64, 64, 5, "video", "head",
+        "disabled", "generated_audio", 5, 1.0, 8, 11, 18,
+        "body:auto:v1", 0, "guide")
+except ValueError as exc:
+    assert "video_blend_frames must be 0" in str(exc)
+else:
+    raise AssertionError("non-linear visual context accepted an assembly blend")
+
+formatted = chain._format_dependency_mismatches(boundary_diffs)
+assert "scene 2 incoming_boundary.context_length" in formatted
+assert chain._scene_dependency_diffs({"version": "legacy"}, scene1_a) == []
+assert set(scene1_a["scopes"]) == set(chain.DEPENDENCY_SCOPES)
+assert scene1_a["version"] == chain.SCENE_DEPENDENCY_VERSION
+
+masked_plan = chain._normalize_plan(
+    json.dumps({"shots": [
+        {"id": "one", "prompt": "@actor opens.", "length": 90},
+        {"id": "two", "prompt": "@actor continues.", "length": 90},
+    ]}),
+    "masked-dependency-test", 64, 64, 39, "video", "head", "disabled",
+    "source_track", 39, 1.0, 8, 11, 18, "body:auto:v1", 0,
+    "audio_feathered_av")
+masked_dependency = chain._scene_dependency_record(masked_plan, 2, None)
+assert masked_dependency["scopes"]["incoming_boundary"][
+    "masked_audio_contract"] == "raw_source_window_v2"
+legacy_masked_dependency = json.loads(json.dumps(masked_dependency))
+del legacy_masked_dependency["scopes"]["incoming_boundary"][
+    "masked_audio_contract"]
+contract_diffs = chain._scene_dependency_diffs(
+    legacy_masked_dependency, masked_dependency)
+assert contract_diffs == [{
+    "scope": "incoming_boundary",
+    "scene": 2,
+    "field": "masked_audio_contract",
+    "saved": None,
+    "current": "raw_source_window_v2",
+    "regeneration_required": True,
+}]
+
+detail_plan = chain._normalize_plan(
+    json.dumps({"shots": [
+        {"id": "one", "prompt": "@actor opens.", "length": 90},
+        {"id": "two", "prompt": "@actor continues.", "length": 90},
+    ]}),
+    "detail-av-dependency-test", 64, 64, 39, "video", "head", "disabled",
+    "source_track", 39, 1.0, 8, 11, 18, "body:auto:v1", 0,
+    "tapered_av")
+detail_dependency = chain._scene_dependency_record(detail_plan, 2, None)
+assert detail_dependency["scopes"]["incoming_boundary"][
+    "detail_av_recipe"] == chain.DETAIL_AV_RECIPE
+changed_detail_dependency = json.loads(json.dumps(detail_dependency))
+changed_detail_dependency["scopes"]["incoming_boundary"][
+    "detail_av_recipe"]["alpha"] = 0.40
+detail_diffs = chain._scene_dependency_diffs(
+    changed_detail_dependency, detail_dependency)
+assert detail_diffs == [{
+    "scope": "incoming_boundary",
+    "scene": 2,
+    "field": "detail_av_recipe.alpha",
+    "saved": 0.4,
+    "current": 0.30,
+    "regeneration_required": True,
+}]
+
+drift_plan = chain._normalize_plan(
+    json.dumps({"shots": [
+        {"id": "one", "prompt": "@actor opens.", "length": 90},
+        {"id": "two", "prompt": "@actor continues.", "length": 90},
+    ]}),
+    "drift-av-dependency-test", 64, 64, 39, "video", "head", "disabled",
+    "source_track", 39, 1.0, 20, 11, 18, "body:auto:v1", 0,
+    "drift_control_av")
+drift_dependency = chain._scene_dependency_record(drift_plan, 2, None)
+assert drift_dependency["scopes"]["incoming_boundary"][
+    "drift_control_av_recipe"] == chain.DRIFT_CONTROL_AV_RECIPE
+changed_drift_dependency = json.loads(json.dumps(drift_dependency))
+changed_drift_dependency["scopes"]["incoming_boundary"][
+    "drift_control_av_recipe"]["taper_steps"] = 3
+drift_diffs = chain._scene_dependency_diffs(
+    changed_drift_dependency, drift_dependency)
+assert drift_diffs == [{
+    "scope": "incoming_boundary",
+    "scene": 2,
+    "field": "drift_control_av_recipe.taper_steps",
+    "saved": 3,
+    "current": 4,
+    "regeneration_required": True,
+}]
+
+# A visually new scene may deliberately keep only generated-audio continuity.
+# The saved predecessor audio remains authoritative, so changing that
+# predecessor's visual incoming-boundary recipe must not block the audio-only
+# edge. Prompt/model/source identity changes remain strict, and a visual edge
+# still compares the complete dependency record.
+audio_only_resume_plan = chain._normalize_plan(
+    json.dumps({"shots": [
+        {"id": "one", "prompt": "one", "length": 90},
+        {"id": "two", "prompt": "two", "length": 90,
+         "continuation_mode": "audio_feathered_av"},
+        {"id": "clean_picture", "prompt": "three", "length": 90,
+         "context_length": 0, "audio_context_length": 39,
+         "continuation_mode": "guide"},
+    ]}),
+    "audio-only-resume-test", 64, 64, 39, "video", "head", "disabled",
+    "generated_audio", 39, 1.0, 20, 11, 18, "body:auto:v1", 0,
+    "audio_feathered_av")
+audio_only_sources = chain._resume_context_predecessors(
+    audio_only_resume_plan, 3)
+assert audio_only_sources == {
+    "visual": None, "audio": 2, "scenes": [2],
+}
+saved_audio_only_plan = json.loads(json.dumps(audio_only_resume_plan))
+saved_audio_only_plan["shots"][1]["continuation_mode"] = "drift_control_av"
+saved_audio_predecessor = chain._scene_dependency_record(
+    saved_audio_only_plan, 2, None)
+current_audio_predecessor = chain._scene_dependency_record(
+    audio_only_resume_plan, 2, None)
+assert any(item["scope"] == "incoming_boundary"
+           for item in chain._scene_dependency_diffs(
+               saved_audio_predecessor, current_audio_predecessor))
+assert chain._resume_dependency_diffs(
+    saved_audio_predecessor, current_audio_predecessor, 2,
+    audio_only_sources) == []
+assert chain._resume_dependency_diffs(
+    saved_audio_predecessor, current_audio_predecessor, 2, {
+        "visual": None, "audio": 2, "audio_lead": 2, "scenes": [2],
+    }) == []
+assert chain._resume_dependency_diffs(
+    saved_audio_predecessor, current_audio_predecessor, 2, {
+        "visual": None, "audio": 1, "audio_lead": 2, "scenes": [1, 2],
+    }) == []
+visual_and_audio_sources = {
+    "visual": 2, "audio": 2, "scenes": [2],
+}
+assert any(item["scope"] == "incoming_boundary"
+           for item in chain._resume_dependency_diffs(
+               saved_audio_predecessor, current_audio_predecessor, 2,
+               visual_and_audio_sources))
+
+with tempfile.TemporaryDirectory() as temporary:
+    root = pathlib.Path(temporary)
+    original_output_root = chain._output_root
+    chain._output_root = lambda: str(root)
+    try:
+        for scene in (1, 2):
+            paths = chain._artifact_paths(saved_audio_only_plan, scene)
+            pathlib.Path(paths["segment"]).parent.mkdir(
+                parents=True, exist_ok=True)
+            pathlib.Path(paths["checkpoint"]).parent.mkdir(
+                parents=True, exist_ok=True)
+            pathlib.Path(paths["segment"]).write_bytes(
+                ("audio-only-video-%d" % scene).encode())
+            pathlib.Path(paths["checkpoint"]).write_bytes(
+                ("audio-only-checkpoint-%d" % scene).encode())
+            history = chain._history_hash(saved_audio_only_plan, scene)
+            segment = {
+                "index": scene,
+                "id": saved_audio_only_plan["shots"][scene - 1]["id"],
+                "segment": chain._relative_output_path(paths["segment"]),
+                "checkpoint": chain._relative_output_path(paths["checkpoint"]),
+                "segment_sha256": chain._file_sha256(paths["segment"]),
+                "checkpoint_sha256": chain._file_sha256(paths["checkpoint"]),
+                "history_hash": history,
+                "revision": "audio-only-%d" % scene,
+            }
+            pathlib.Path(paths["metadata"]).write_text(json.dumps({
+                "history_hash": history,
+                "compatibility": saved_audio_only_plan["compatibility"],
+                "scene_dependency": chain._scene_dependency_record(
+                    saved_audio_only_plan, scene, None),
+                "segment": segment,
+            }), encoding="utf-8")
+        audio_only_report = {"errors": [], "warnings": []}
+        audio_only_resume = chain._preflight_resume(
+            audio_only_resume_plan, 3, True, audio_only_report)
+        assert audio_only_resume["eligible"] is True
+        assert audio_only_report["errors"] == []
+        assert audio_only_resume["context_sources"] == audio_only_sources
+        assert audio_only_resume["selected_context"] == {
+            "scene": 3, "video_frames": 0, "audio_frames": 39,
+        }
+        assert audio_only_resume["predecessors"][1][
+            "consumed_streams"] == ["audio"]
+        assert audio_only_resume["predecessors"][1]["mismatches"] == []
+    finally:
+        chain._output_root = original_output_root
+
+color_drift_plan = chain._normalize_plan(
+    json.dumps({"shots": [
+        {"id": "one", "prompt": "@actor opens.", "length": 90},
+        {"id": "two", "prompt": "@actor continues.", "length": 90},
+    ]}),
+    "color-drift-av-dependency-test", 64, 64, 39, "video", "head",
+    "disabled", "source_track", 39, 1.0, 20, 11, 18, "body:auto:v1",
+    0, "color_stable_drift_av")
+color_drift_dependency = chain._scene_dependency_record(
+    color_drift_plan, 2, None)
+color_boundary = color_drift_dependency["scopes"]["incoming_boundary"]
+assert color_boundary[
+    "drift_control_av_recipe"] == chain.DRIFT_CONTROL_AV_RECIPE
+assert color_boundary[
+    "latent_color_carry_recipe"] == chain.LATENT_COLOR_CARRY_RECIPE
+changed_color_dependency = json.loads(json.dumps(color_drift_dependency))
+changed_color_dependency["scopes"]["incoming_boundary"][
+    "latent_color_carry_recipe"]["strength"] = 0.25
+color_diffs = chain._scene_dependency_diffs(
+    changed_color_dependency, color_drift_dependency)
+assert color_diffs == [{
+    "scope": "incoming_boundary",
+    "scene": 2,
+    "field": "latent_color_carry_recipe.strength",
+    "saved": 0.25,
+    "current": 0.50,
+    "regeneration_required": True,
+}]
+
+# Spatial reset is scheduled on the incoming scene, not inherited globally.
+proxy_plan = chain._normalize_plan(
+    json.dumps({"shots": [
+        {"id": "one", "prompt": "one", "length": 90},
+        {"id": "two", "prompt": "two", "length": 90},
+        {"id": "three", "prompt": "three", "length": 90},
+        {"id": "four", "prompt": "four", "length": 90,
+         "context_spatial_proxy": "latent_5_6"},
+    ]}),
+    "scheduled-proxy-test", 1376, 768, 39, "video", "head", "disabled",
+    "source_track", 39, 1.0, 8, 11, 18, "body:auto:v1", 0,
+    "masked_av")
+assert all("context_spatial_proxy" not in shot
+           for shot in proxy_plan["shots"][:3])
+assert proxy_plan["shots"][3]["context_spatial_proxy"] == "latent_5_6"
+assert chain._context_spatial_proxy_size(1376, 768) == (1152, 640)
+scene3_proxy_dependency = chain._scene_dependency_record(proxy_plan, 3, None)
+scene4_proxy_dependency = chain._scene_dependency_record(proxy_plan, 4, None)
+assert "context_spatial_proxy" not in scene3_proxy_dependency[
+    "scopes"]["incoming_boundary"]
+assert scene4_proxy_dependency["scopes"]["incoming_boundary"][
+    "context_spatial_proxy"] == "latent_5_6"
+assert scene4_proxy_dependency["scopes"]["incoming_boundary"][
+    "context_spatial_proxy_recipe"] == chain.CONTEXT_SPATIAL_PROXY_RECIPE
+
+native_plan = chain._normalize_plan(
+    json.dumps({"shots": [
+        {"id": name, "prompt": name, "length": 90}
+        for name in ("one", "two", "three", "four")
+    ]}),
+    "scheduled-proxy-test", 1376, 768, 39, "video", "head", "disabled",
+    "source_track", 39, 1.0, 8, 11, 18, "body:auto:v1", 0,
+    "masked_av")
+assert chain._history_hash(proxy_plan, 3) == chain._history_hash(native_plan, 3)
+assert chain._history_hash(proxy_plan, 4) != chain._history_hash(native_plan, 4)
+assert chain._scene_dependency_diffs(
+    chain._scene_dependency_record(native_plan, 3, None),
+    scene3_proxy_dependency) == []
+proxy_diffs = chain._scene_dependency_diffs(
+    chain._scene_dependency_record(native_plan, 4, None),
+    scene4_proxy_dependency)
+assert proxy_diffs
+assert all(item["scene"] == 4 and item["scope"] == "incoming_boundary"
+           and item["regeneration_required"] for item in proxy_diffs)
+
+guide_proxy_plan = chain._normalize_plan(
+    json.dumps({"shots": [
+        {"id": "one", "prompt": "one", "length": 39},
+        {"id": "two", "prompt": "two", "length": 39,
+         "context_spatial_proxy": "rgb_5_6"},
+    ]}),
+    "rgb-proxy-test", 1376, 768, 5, "video", "head", "disabled",
+    "source_track", 5, 1.0, 8, 11, 18, "body:auto:v1", 0,
+    "guide")
+assert guide_proxy_plan["shots"][1]["context_spatial_proxy"] == "rgb_5_6"
+
+for invalid_proxy, mode, expected in (
+        ("rgb_5_6", "masked_av", "low-grid 5/6"),
+        ("latent_5_6", "guide", "latent 5/6")):
+    try:
+        chain._normalize_plan(
+            json.dumps({"shots": [
+                {"id": "one", "prompt": "one", "length": 90},
+                {"id": "two", "prompt": "two", "length": 90,
+                 "context_spatial_proxy": invalid_proxy},
+            ]}),
+            "invalid-proxy", 64, 64, 39, "video", "head", "disabled",
+            "source_track", 39, 1.0, 8, 11, 18, "body:auto:v1", 0,
+            mode)
+    except ValueError as exc:
+        assert expected in str(exc)
+    else:
+        raise AssertionError("incompatible context spatial proxy was accepted")
+
+print("H3 scene dependencies: scene-local PCM, boundary isolation, assembly exclusion, and structured diffs pass")
+
+
+# Preflight exposes the same field-level mismatch against saved metadata.
+with tempfile.TemporaryDirectory() as temporary:
+    root = pathlib.Path(temporary)
+    chain._output_root = lambda: str(root)
+    resume_plan = chain._normalize_plan(
+        json.dumps({"shots": [
+            {"id": "one", "prompt": "saved prompt", "length": 22},
+            {"id": "two", "prompt": "next prompt", "length": 22},
+        ]}),
+        "dependency-resume", 64, 64, 5, "video", "head", "disabled",
+        "generated_audio", 5, 1.0, 8, 9, 18, "body:auto:v1", 0,
+        "guide")
+    resume_plan = chain._plan_with_source_audio(resume_plan, None)
+    saved_dependency = chain._scene_dependency_record(resume_plan, 1, None)
+    paths = chain._artifact_paths(resume_plan, 1)
+    pathlib.Path(paths["segment"]).parent.mkdir(parents=True)
+    pathlib.Path(paths["checkpoint"]).parent.mkdir(parents=True)
+    pathlib.Path(paths["segment"]).write_bytes(b"video")
+    pathlib.Path(paths["checkpoint"]).write_bytes(b"checkpoint")
+    prompt_path = pathlib.Path(paths["segment"]).with_suffix(".prompt.txt")
+    prompt_path.write_text("saved prompt", encoding="utf-8")
+    history = chain._history_hash(resume_plan, 1)
+    segment = {
+        "index": 1,
+        "segment": chain._relative_output_path(paths["segment"]),
+        "checkpoint": chain._relative_output_path(paths["checkpoint"]),
+        "prompt_file": chain._relative_output_path(str(prompt_path)),
+        "segment_sha256": chain._file_sha256(paths["segment"]),
+        "checkpoint_sha256": chain._file_sha256(paths["checkpoint"]),
+        "prompt_file_sha256": chain._file_sha256(str(prompt_path)),
+        "prompt_hash": resume_plan["shots"][0]["prompt_hash"],
+        "history_hash": history,
+    }
+    pathlib.Path(paths["metadata"]).write_text(json.dumps({
+        "history_hash": history,
+        "compatibility": resume_plan["compatibility"],
+        "scene_dependency": saved_dependency,
+        "segment": segment,
+    }), encoding="utf-8")
+    changed_plan = json.loads(json.dumps(resume_plan))
+    changed_plan["shots"][0]["prompt"] = "changed prompt"
+    changed_plan["shots"][0]["prompt_hash"] = chain.hashlib.sha256(
+        b"changed prompt").hexdigest()
+    diagnostic = {"errors": [], "warnings": []}
+    resume = chain._preflight_resume(
+        changed_plan, 2, True, diagnostic)
+    assert resume["eligible"] is False
+    mismatch = resume["predecessors"][0]["mismatches"][0]
+    assert mismatch == {
+        "scope": "scene_generation", "scene": 1,
+        "field": "prompt_hash",
+        "saved": resume_plan["shots"][0]["prompt_hash"],
+        "current": changed_plan["shots"][0]["prompt_hash"],
+        "regeneration_required": True,
+    }
+
+    # An explicitly independent selected scene consumes no predecessor state.
+    # Its earlier clips retain their saved identity for assembly, so editing a
+    # prior prompt cannot block the new zero-context sample.
+    independent_plan = json.loads(json.dumps(changed_plan))
+    independent_plan["shots"][1]["context_length"] = 0
+    independent_plan["shots"][1]["audio_context_length"] = 0
+    independent_report = {"errors": [], "warnings": []}
+    independent_resume = chain._preflight_resume(
+        independent_plan, 2, True, independent_report)
+    assert independent_resume["eligible"] is True
+    assert independent_resume["context_predecessor"] is None
+    assert independent_resume["predecessors"][0]["mismatches"] == []
+
+print("H3 structured resume preflight: field-level saved/current mismatch pass")
+
+
+with tempfile.TemporaryDirectory() as temporary:
+    root = pathlib.Path(temporary)
+    chain._output_root = lambda: str(root)
+    saved_plan = chain._plan_with_source_audio(nonlinear_plan, None)
+    for scene in range(1, 5):
+        paths = chain._artifact_paths(saved_plan, scene)
+        pathlib.Path(paths["segment"]).parent.mkdir(parents=True, exist_ok=True)
+        pathlib.Path(paths["checkpoint"]).parent.mkdir(
+            parents=True, exist_ok=True)
+        pathlib.Path(paths["segment"]).write_bytes(
+            ("video-%d" % scene).encode())
+        pathlib.Path(paths["checkpoint"]).write_bytes(
+            ("checkpoint-%d" % scene).encode())
+        history = chain._history_hash(saved_plan, scene)
+        segment = {
+            "index": scene,
+            "id": saved_plan["shots"][scene - 1]["id"],
+            "segment": chain._relative_output_path(paths["segment"]),
+            "checkpoint": chain._relative_output_path(paths["checkpoint"]),
+            "segment_sha256": chain._file_sha256(paths["segment"]),
+            "checkpoint_sha256": chain._file_sha256(paths["checkpoint"]),
+            "history_hash": history,
+            "revision": "r%d" % scene,
+        }
+        pathlib.Path(paths["metadata"]).write_text(json.dumps({
+            "history_hash": history,
+            "compatibility": saved_plan["compatibility"],
+            "scene_dependency": chain._scene_dependency_record(
+                saved_plan, scene, None),
+            "segment": segment,
+        }), encoding="utf-8")
+
+    changed_unconsumed = json.loads(json.dumps(saved_plan))
+    changed_unconsumed["shots"][1]["prompt"] = "changed scene two"
+    changed_unconsumed["shots"][1]["prompt_hash"] = (
+        chain.hashlib.sha256(b"changed scene two").hexdigest())
+    report = {"errors": [], "warnings": []}
+    preflight = chain._preflight_resume(
+        changed_unconsumed, 5, True, report)
+    assert preflight["eligible"] is True
+    assert preflight["context_sources"] == {
+        "visual": 3, "audio": 4, "scenes": [3, 4]}
+    assert preflight["predecessors"][1]["mismatches"] == []
+
+    for consumed_scene in (3, 4):
+        changed_consumed = json.loads(json.dumps(saved_plan))
+        changed_consumed["shots"][consumed_scene - 1]["prompt"] = (
+            "changed scene %d" % consumed_scene)
+        changed_consumed["shots"][consumed_scene - 1]["prompt_hash"] = (
+            chain.hashlib.sha256(
+                changed_consumed["shots"][consumed_scene - 1][
+                    "prompt"].encode()).hexdigest())
+        report = {"errors": [], "warnings": []}
+        blocked = chain._preflight_resume(
+            changed_consumed, 5, True, report)
+        assert blocked["eligible"] is False
+        assert blocked["predecessors"][consumed_scene - 1]["mismatches"]
+
+print("H3 non-linear resume preflight: visual scene 3 + audio scene 4 dependencies pass")
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_scene_duplication_js_test.mjs b/ComfyUI-MiniMaxH3-Context-Loop/tests/_scene_duplication_js_test.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..cd19cf06beaf0f200956c395bbd2f8f4b16c5239
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_scene_duplication_js_test.mjs
@@ -0,0 +1,215 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import vm from "node:vm";
+import {
+    MAX_SHOTS, calculatePlanTiming, duplicateShot, parsePlanJson, planToJson,
+    promptTextToLines, promptValueToText, renamePlanShot, sceneVisualContextSource,
+} from "../web/h3_chain_plan_core.mjs";
+
+const options = {contextLength:22, videoBlendFrames:5, anchorMode:"head",
+    defaultDurationSeconds:5, defaultSteps:20};
+const productionPlans = [];
+const makePlan = (spelling = "id", count = 10) => ({shots:Array.from({length:count}, (_, i) => ({
+    id:`scene_${i + 1}`, prompt:[`Prompt ${i + 1}`], length:90,
+    ...(i && spelling !== "implicit" ? {visual_context_source:
+        spelling === "id" ? `scene_${i}` : spelling === "number" ? i
+            : spelling === "numeric string" ? String(i) : spelling} : {}),
+}))});
+function valid(plan, name) {
+    assert.deepEqual(calculatePlanTiming(plan, options).errors, [], name);
+    productionPlans.push({name, plan:structuredClone(plan)});
+}
+
+for (const spelling of ["id", "number", "numeric string", "implicit", "previous", "immediate"]) {
+    for (const index of [0, 5, 9]) {
+        const plan = makePlan(spelling);
+        valid(plan, `${spelling} before insertion`);
+        const original = [...plan.shots];
+        const duplicate = duplicateShot(plan.shots, index);
+        assert.equal(plan.shots[index + 1], duplicate);
+        assert.deepEqual(duplicate.prompt, [`Prompt ${index + 1}`]);
+        assert.notEqual(duplicate.prompt, original[index].prompt, "prompt arrays are deep copied");
+        original.forEach((shot, offset) => {
+            assert.equal(plan.shots[offset + (offset > index ? 1 : 0)], shot);
+            assert.deepEqual(shot.prompt, [`Prompt ${offset + 1}`]);
+            assert.equal(shot.id, `scene_${offset + 1}`);
+        });
+        assert.equal(sceneVisualContextSource(plan, index + 2), index + 1);
+        if (index < original.length - 1) assert.equal(sceneVisualContextSource(plan, index + 3), index + 2);
+        valid(plan, `${spelling} duplicate at ${index + 1}`);
+        duplicateShot(plan.shots, index + 1);
+        assert.equal(new Set(plan.shots.map(shot => shot.id)).size, plan.shots.length);
+        valid(plan, `${spelling} repeated duplicate at ${index + 2}`);
+    }
+}
+
+// Explicit single-tail blocks behave like a normal previous-scene source.
+const blocks = makePlan();
+for (let index = 1; index < blocks.shots.length; index++) {
+    const shot = blocks.shots[index];
+    shot.visual_context_blocks = [{source:shot.visual_context_source, frames:22}];
+    shot.video_blend_frames = 0;
+    delete shot.visual_context_source;
+}
+valid(blocks, "single blocks before insertion");
+const blockCopy = duplicateShot(blocks.shots, 5);
+assert.equal(blockCopy.visual_context_blocks[0].source, "scene_6");
+assert.equal(blocks.shots[7].visual_context_blocks[0].source, blockCopy.id);
+valid(blocks, "single blocks after insertion");
+
+// Deliberate older sources and composed contexts keep their original clips.
+for (const patch of [
+    {visual_context_source:"scene_2"},
+    {visual_context_source:"scene_5", visual_context_lead_source:"scene_2", visual_context_lead_frames:5},
+    {visual_context_blocks:[{source:"scene_2", frames:5}, {source:"scene_5", frames:17}]},
+]) {
+    const plan = makePlan();
+    delete plan.shots[5].visual_context_source;
+    Object.assign(plan.shots[5], patch, {video_blend_frames:0});
+    valid(plan, "authored context before insertion");
+    const copied = duplicateShot(plan.shots, 5);
+    for (const [key, value] of Object.entries(patch)) assert.deepEqual(copied[key], value);
+    valid(plan, "authored context after insertion");
+}
+
+// Positional references to later original scenes shift, including references
+// nested inside a composition. Their authored frame windows do not change.
+const positional = makePlan();
+Object.assign(positional.shots[9], {
+    visual_context_source:8, visual_context_start_frame:0,
+    visual_context_lead_source:"7", visual_context_lead_frames:5,
+    audio_context_source:8, audio_context_start_frame:12,
+    audio_context_lead_source:"7", audio_context_lead_start_frame:3,
+});
+Object.assign(positional.shots[8], {
+    visual_context_blocks:[{source:7, frames:5, start_frame:0}, {source:"8", frames:17}],
+});
+duplicateShot(positional.shots, 5);
+assert.equal(positional.shots[10].visual_context_source, 9);
+assert.equal(positional.shots[10].visual_context_lead_source, "8");
+assert.equal(positional.shots[10].audio_context_source, 9);
+assert.equal(positional.shots[10].audio_context_lead_source, "8");
+assert.equal(positional.shots[10].visual_context_start_frame, 0);
+assert.equal(positional.shots[10].audio_context_start_frame, 12);
+assert.equal(positional.shots[10].audio_context_lead_start_frame, 3);
+assert.deepEqual(positional.shots[9].visual_context_blocks,
+    [{source:8, frames:5, start_frame:0}, {source:"9", frames:17}]);
+
+for (const patch of [
+    {visual_context_source:"scene_5", visual_context_start_frame:0},
+    {visual_context_blocks:[{source:"scene_5", frames:22, start_frame:0}]},
+    {audio_context_source:"scene_5", audio_context_start_frame:0},
+]) {
+    const plan = makePlan();
+    Object.assign(plan.shots[5], patch);
+    const copied = duplicateShot(plan.shots, 5);
+    for (const [key, value] of Object.entries(patch)) assert.deepEqual(copied[key], value,
+        "an explicitly selected frame window must keep its source clip");
+}
+
+const audio = makePlan();
+audio.shots[5].audio_context_source = "scene_5";
+audio.shots[6].audio_context_source = "scene_6";
+const audioCopy = duplicateShot(audio.shots, 5);
+assert.equal(audioCopy.audio_context_source, "scene_6");
+assert.equal(audio.shots[7].audio_context_source, audioCopy.id);
+
+const legacy = makePlan("number");
+legacy.shots.forEach(shot => { delete shot.id; });
+duplicateShot(legacy.shots, 5);
+assert.equal(legacy.shots[5].id, "clip_0006");
+assert.equal(legacy.shots[7].id, "clip_0007", "legacy identities survive insertion");
+valid(legacy, "legacy implicit IDs after duplication");
+const numericIds = makePlan();
+numericIds.shots[5].id = "123";
+numericIds.shots[6].visual_context_source = 6;
+valid(numericIds, "numeric scene ID before duplication");
+const numericCopy = duplicateShot(numericIds.shots, 5);
+assert.equal(numericCopy.visual_context_source, 6, "numeric IDs must not be interpreted as source positions");
+valid(numericIds, "numeric scene ID after duplication");
+
+const normalizedIds = makePlan();
+normalizedIds.shots[5].id = "scene 6";
+valid(normalizedIds, "normalized scene ID before duplication");
+const normalizedCopy = duplicateShot(normalizedIds.shots, 5);
+assert.equal(normalizedCopy.visual_context_source, "scene_6");
+valid(normalizedIds, "normalized scene ID after duplication");
+
+const independent = makePlan();
+independent.shots[5].context_length = 0;
+independent.shots[5].audio_context_length = 0;
+independent.chapters = [{id:"chapter_two", title:"Chapter 2", start_scene_id:"scene_7"}];
+const independentCopy = duplicateShot(independent.shots, 5);
+assert.equal(independentCopy.context_length, 0);
+assert.equal(independentCopy.audio_context_length, 0);
+assert.equal(independent.chapters[0].start_scene_id, "scene_7");
+valid(independent, "independent scene and chapter identity after duplication");
+
+const longIds = [{id:"x".repeat(96), prompt:["Original"]}];
+duplicateShot(longIds, 0); duplicateShot(longIds, 0);
+assert.equal(new Set(longIds.map(shot => shot.id)).size, 3);
+assert.ok(longIds.every(shot => shot.id.length <= 96));
+for (const index of [-1, 99, 1.5]) {
+    const before = JSON.stringify(longIds);
+    assert.throws(() => duplicateShot(longIds, index), /outside the Plan/);
+    assert.equal(JSON.stringify(longIds), before);
+}
+
+// Execute the real Studio button, delegated-prompt merge and write path.
+// This reproduces both the reported overwrite and a source prompt edited
+// since Studio's latest polling snapshot, without touching a live workflow.
+const studio = fs.readFileSync(new URL("../web/h3_chain_plan_studio.js", import.meta.url), "utf8");
+const functions = ["preserveDelegatedPrompts", "writePlan"].map(name => {
+    const code = studio.match(new RegExp(`^    function ${name}\\([^]*?^    }`, "m"))?.[0];
+    assert.ok(code, name); return code;
+}).join("\n");
+const buttonCode = studio.match(/const duplicate = button\("Duplicate", "Duplicate the selected scene", async \(\) => \{[^]*?^        \}\);/m)?.[0];
+assert.ok(buttonCode);
+const renameCode = studio.match(/id\.addEventListener\("change", \(\) => \{[^]*?^        \}\);/m)?.[0];
+assert.ok(renameCode);
+for (const linked of [false, true]) for (const implicitIds of [false, true]) {
+    const local = makePlan("implicit"), live = structuredClone(local);
+    if (implicitIds) for (const plan of [local, live]) plan.shots.forEach(shot => { delete shot.id; });
+    live.shots[5].prompt = ["Latest source prompt"];
+    const state = {plan:local, active:5, promptEditors:linked ? [{}] : [],
+        planWidget:{value:JSON.stringify(live)}, planNode:{}, activeChapterId:"chapter", planNotifyTimer:null};
+    const published = [], callbacks = [];
+    const context = vm.createContext({state, node:{}, MAX_SHOTS, duplicateShot,
+        parsePlanJson, planToJson, promptTextToLines, promptValueToText,
+        button:(_label, _title, action) => action, flushHistoryDraft:async () => {},
+        widget:() => null, setTimeout:action => { callbacks.push(action); return 1; }, clearTimeout() {},
+        persistView() {}, renderShell() {}, publishActiveScene() {}, scheduleEditorialSave() {}, renderStatus() {}, dirty() {},
+        publishCompanionPrompt:(_node, _planNode, index, prompt) => published.push({index, prompt}),
+    });
+    await vm.runInContext(`${functions}\n${buttonCode}\nduplicate();`, context);
+    callbacks.forEach(action => action());
+    const expected = linked ? "Latest source prompt" : "Prompt 6";
+    const saved = JSON.parse(state.planWidget.value);
+    assert.deepEqual(saved.shots[6].prompt, [expected]);
+    assert.deepEqual(saved.shots[5].prompt, [expected]);
+    assert.deepEqual(saved.shots[7].prompt, ["Prompt 7"]);
+    assert.deepEqual(saved.shots[8].prompt, ["Prompt 8"]);
+    assert.equal(state.active, 6);
+    assert.equal(state.activeChapterId, "");
+    assert.deepEqual(published, [{index:6, prompt:expected}]);
+
+    // Removing the unsafe positional fallback must not regress renames: pull
+    // a recent delegated edit before replacing the original scene ID.
+    const changed = JSON.parse(state.planWidget.value);
+    changed.shots[6].prompt = ["Latest before rename"];
+    state.planWidget.value = JSON.stringify(changed);
+    let rename;
+    Object.assign(context, {shot:state.plan.shots[6], renamePlanShot,
+        id:{value:"renamed_copy", setCustomValidity() {}, addEventListener:(_type, action) => { rename = action; }},
+        remapStudioEditorialSceneId() {},
+    });
+    vm.runInContext(renameCode, context);
+    rename();
+    const renamed = JSON.parse(state.planWidget.value);
+    assert.equal(renamed.shots[6].id, "renamed_copy");
+    assert.deepEqual(renamed.shots[6].prompt, [linked ? "Latest before rename" : expected]);
+    assert.deepEqual(renamed.shots[7].prompt, ["Prompt 7"]);
+}
+
+if (process.argv.includes("--plans")) console.log(JSON.stringify(productionPlans));
+else console.log("Scene duplication: context remapping, stable identities, source prompt freshness and real Studio save path pass");
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_scene_duplication_unit_test.py b/ComfyUI-MiniMaxH3-Context-Loop/tests/_scene_duplication_unit_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..bee921e5cb230d3ad4f6767400475a6ac8a9cc5d
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_scene_duplication_unit_test.py
@@ -0,0 +1,52 @@
+#!/usr/bin/env python3
+"""Validate JSON produced by the actual browser helper with the Python Plan parser."""
+
+import importlib.util
+import json
+import pathlib
+import subprocess
+import sys
+import tempfile
+import types
+
+
+ROOT = pathlib.Path(__file__).resolve().parents[1]
+PACKAGE = "h3_scene_duplication_unit"
+fixtures = json.loads(subprocess.check_output(
+    ["node", str(ROOT / "tests" / "_scene_duplication_js_test.mjs"), "--plans"],
+    cwd=ROOT, text=True))
+
+with tempfile.TemporaryDirectory(prefix="h3-duplicate-") as directory:
+    folders = types.ModuleType("folder_paths")
+    folders.get_output_directory = lambda: directory
+    folders.get_temp_directory = lambda: directory
+    folders.get_input_directory = lambda: directory
+    folders.get_annotated_filepath = lambda value: str(value)
+    sys.modules["folder_paths"] = folders
+    package = types.ModuleType(PACKAGE)
+    package.__path__ = [str(ROOT)]
+    sys.modules[PACKAGE] = package
+    nodes = types.ModuleType(PACKAGE + ".nodes")
+    nodes.MiniMaxH3MotionContext = object
+    nodes._claim_inline_patch_ownership = lambda _conditioning=None: "test"
+    nodes._prepare_native_guide_conditioning = lambda value: value
+    nodes._resize = lambda *args: None
+    nodes._streams_from_latent = lambda *args: None
+    sys.modules[nodes.__name__] = nodes
+    spec = importlib.util.spec_from_file_location(
+        PACKAGE + ".chain_nodes", ROOT / "chain_nodes.py")
+    chain = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = chain
+    spec.loader.exec_module(chain)
+
+    for fixture in fixtures:
+        try:
+            plan = chain._normalize_plan(
+                json.dumps(fixture["plan"]), "duplication-test", 64, 64, 22,
+                "video", "head", "disabled", "source_track", 22, 5.0, 20,
+                11, 18, "test-model", 5, "guide")
+        except Exception as exc:
+            raise AssertionError(fixture["name"]) from exc
+        assert len(plan["shots"]) == len(fixture["plan"]["shots"])
+
+print("Scene duplication: %d frontend-generated Plans pass the production Python validator" % len(fixtures))
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_scene_navigation_js_test.mjs b/ComfyUI-MiniMaxH3-Context-Loop/tests/_scene_navigation_js_test.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..b0acf5edc9c84d745ba75578a80c2bc5e3c3326b
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_scene_navigation_js_test.mjs
@@ -0,0 +1,146 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import vm from "node:vm";
+import {parsePlanJson, calculatePlanTiming} from "../web/h3_chain_plan_core.mjs";
+
+function handler(text, name) {
+    const match = text.match(new RegExp(`^    (?:async )?function ${name}\\([^]*?^    }$`, "m"));
+    assert.ok(match, name);
+    return match[0];
+}
+const tick = () => new Promise(resolve => setImmediate(resolve));
+const blankPrompts = ["", [""], [], null, "  "];
+for (const prompt of blankPrompts) {
+    const plan = parsePlanJson(JSON.stringify({shots:[
+        {id:"written", prompt:"Existing prompt"}, {id:"blank", prompt},
+    ]}));
+    const timing = calculatePlanTiming(plan);
+    assert.equal(plan.shots.length, 2);
+    assert.equal(timing.shots.length, 2, "validation must not hide the draft scene");
+    assert.ok(timing.shots[1].deliveredFrames > 0);
+}
+
+for (const filename of [
+    "h3_chain_scene_prompt_editor.js", "h3_chain_rich_scene_prompt_editor.js",
+    "h3_chain_plan_studio.js",
+]) {
+    const source = fs.readFileSync(new URL(`../web/${filename}`, import.meta.url), "utf8");
+    const studio = filename === "h3_chain_plan_studio.js";
+    const name = studio ? "selectScene" : "navigate";
+    const plan = {shots:[
+        {id:"written", prompt:["Existing prompt"]},
+        {id:"blank", prompt:[""]},
+        {id:"other", prompt:["Another prompt"]},
+    ]};
+    let pending = [];
+    let run = "run";
+    const published = [];
+    const state = {plan, planNode:{}, active:0, view:"scene", disposed:false};
+    const context = vm.createContext({
+        state, node:{}, console,
+        planRunName:() => run, runName:() => run, optimizerBusy:() => false,
+        flushPlanEffects(){}, flushPromptAnalysis(){},
+        flushHistoryDraft:() => new Promise(resolve => pending.push(resolve)),
+        persistView(){}, render(){}, renderPanel(){},
+        renderSourceTimeline(){}, renderSourceAudioTimeline(){},
+        updateTimelineSelection(){}, revealActiveTimelineScene(){},
+        publishCompanionScene:(_node, _plan, index) => published.push(index),
+        publishActiveScene:() => published.push(state.active),
+    });
+    vm.runInContext(handler(source, name), context);
+    const select = index => studio ? context.selectScene(index) : context.navigate(0, index);
+    // An older selection waiting for prompt-history IO must not pull BOTH
+    // editors back to a written scene after the user chooses a blank one.
+    select(2);
+    select(1);
+    pending[1]();
+    await tick();
+    assert.equal(state.active, 1, `${filename}: blank scene is selectable`);
+    pending[0]();
+    await tick();
+    assert.equal(state.active, 1, `${filename}: delayed old navigation must not replace the blank scene`);
+    assert.deepEqual(published, [1], "stale selection must not propagate to companions");
+    assert.deepEqual(plan.shots[1].prompt, [""], "navigation must not fill the blank prompt");
+
+    for (const prompt of blankPrompts) {
+        pending = [];
+        state.plan.shots[1].prompt = prompt;
+        select(1);
+        pending[0]();
+        await tick();
+        assert.equal(state.active, 1);
+        assert.equal(state.plan.shots[1].prompt, prompt);
+    }
+    if (!studio) {
+        pending = [];
+        state.active = 0;
+        context.navigate(1);
+        context.navigate(1);
+        pending[1](); pending[0]();
+        await tick();
+        assert.equal(state.active, 2, "rapid relative navigation advances twice");
+    }
+
+    // A timing/seed refresh can rebuild or reorder the Plan while history IO
+    // runs. Follow the selected scene ID, without writing any prompt or seed.
+    pending = [];
+    select(1);
+    state.plan = {shots:[plan.shots[1], plan.shots[0], plan.shots[2]]};
+    pending[0]();
+    await tick();
+    assert.equal(state.active, 0, "selection follows its scene through reordering");
+    state.plan = plan;
+    state.active = 1;
+
+    // Completion from the old project or a removed node is not navigation.
+    pending = [];
+    select(0);
+    state.planNode = {};
+    pending[0]();
+    await tick();
+    assert.equal(state.active, 1, `${filename}: ignore the old Plan`);
+    pending = [];
+    select(0);
+    run = "other_run";
+    pending[0]();
+    await tick();
+    assert.equal(state.active, 1, `${filename}: ignore the old Run`);
+    pending = [];
+    select(0);
+    state.disposed = true;
+    pending[0]();
+    await tick();
+    assert.equal(state.active, 1, `${filename}: ignore a disposed editor`);
+
+    // Exercise the actual history flush, not just an artificial navigation
+    // delay: consuming a draft while history is still loading leaves a window
+    // in which the newer selection completes before the older one.
+    state.disposed = false;
+    let finishLoad;
+    state.history = {
+        pendingDraft:{key:"old", runName:run, shotId:"written", sceneId:"written", prompt:"Saved draft"},
+        sceneKey:"old", loadPromise:new Promise(resolve => { finishLoad = resolve; }),
+    };
+    const saves = [];
+    Object.assign(context, {
+        window:{clearTimeout(){}}, clearTimeout(){}, renderHistory(){},
+        historyRequest:async (_query, body) => {
+            saves.push(body);
+            return {history:{active_revision:"revision"}, revision:{id:"revision"}};
+        },
+    });
+    vm.runInContext(handler(source, "flushHistoryDraft"), context);
+    const previousPublications = published.length;
+    select(2);
+    select(1);
+    await tick();
+    assert.equal(state.active, 1);
+    finishLoad({});
+    await tick();
+    assert.equal(state.active, 1, "actual delayed draft flush cannot bounce selection");
+    assert.deepEqual(published.slice(previousPublications), [1]);
+    assert.equal(saves.length, 1, "the original prompt draft still saves exactly once");
+    assert.equal(saves[0].scene_id, "written");
+    assert.equal(saves[0].prompt, "Saved draft");
+}
+console.log("Scene navigation preserves blank scenes and rejects stale async selections");
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_scene_prompt_editor_js_test.mjs b/ComfyUI-MiniMaxH3-Context-Loop/tests/_scene_prompt_editor_js_test.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..f1d630f292c2eee66feccb41c84cb85e1a0f7cf1
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_scene_prompt_editor_js_test.mjs
@@ -0,0 +1,185 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import {
+    parsePlanJson,
+    planToJson,
+    promptTextToLines,
+    promptValueToText,
+} from "../web/h3_chain_plan_core.mjs";
+
+const plan = parsePlanJson(JSON.stringify({
+    prompt_prefix: "Shared identity.",
+    shots: [
+        {id: "one", prompt: "Old one."},
+        {id: "two", prompt: ["Old two.", "", "CAMERA: Wide."]},
+    ],
+}));
+plan.shots[1].prompt = promptTextToLines(
+    "Continue the action.\n\n<Picture 1> remains the identity reference.",
+);
+const saved = parsePlanJson(planToJson(plan));
+assert.equal(promptValueToText(saved.shots[0].prompt), "Old one.");
+assert.equal(
+    promptValueToText(saved.shots[1].prompt),
+    "Continue the action.\n\n<Picture 1> remains the identity reference.",
+);
+
+const source = fs.readFileSync(
+    new URL("../web/h3_chain_scene_prompt_editor.js", import.meta.url),
+    "utf8",
+);
+assert.match(source, /MiniMaxH3ChainScenePromptEditor/);
+assert.match(source, /item\.name === "plan_json"/);
+assert.match(source, /shot\.prompt = promptTextToLines\(textarea\.value\)/);
+assert.match(source, /state\.planWidget\.value = value/);
+assert.match(source, /_h3ChainEditorRefresh/);
+assert.match(source, /Alt\+Left/);
+assert.match(source, /Alt\+Right/);
+assert.match(source, /@ Reference/);
+assert.match(source, /availableReferenceRecords/);
+assert.match(source, /does not invent unavailable labels/);
+assert.doesNotMatch(source, /Generic native labels are shown instead/);
+assert.match(source, /Hover to preview/);
+assert.match(source, /Audio never autoplays/);
+assert.match(source, /h3sp-ref-preview-media/);
+assert.match(source, /function referenceMediaPreview\(record, kind\)/);
+assert.match(source, /url: api\.apiURL\(record\.previewUrl\)/);
+assert.doesNotMatch(source, /record\.previewUrl\s*\?\s*api\.apiURL/);
+assert.match(source, /record\.kind === "picture" \? "image"/);
+assert.match(source, /showReferencePreview\(records\[0\], preview\)/);
+assert.match(source, /Core Ref2VA references/);
+assert.doesNotMatch(source, /event\.key === "#"/);
+assert.match(source, /createPromptCompletionController/);
+assert.match(source, /createH3PromptSchemaController/);
+assert.match(source, /h3_scene_prompt_editor/);
+assert.match(source, /getMode:\(\) => state\.schema/);
+assert.match(source, /h3sp-token-section/);
+assert.match(source, /h3sp-token-flow/);
+assert.match(source, /h3sp-token-speaker/);
+assert.match(source, /state\.completion\?\.handleKeydown/);
+assert.match(source, /restoreTextSelection/);
+assert.match(source, /editingSemanticTime/);
+assert.match(source, /type @ # < \[/);
+assert.doesNotMatch(source, /event\.key === "@"/);
+assert.match(source, /FONT_SIZE_PROPERTY/);
+assert.match(source, /const PROMPT_ASSISTANT_ENABLED = false;/);
+assert.match(source, /if \(PROMPT_ASSISTANT_ENABLED\) \{\s*assistant\.client = new PromptAssistantClient/);
+assert.match(source, /getMinHeight: \(\) => PROMPT_ASSISTANT_ENABLED \? 760 : 420/);
+assert.match(source, /const minimumHeight = PROMPT_ASSISTANT_ENABLED \? 900 : 620/);
+assert.match(source, /currentWidth === 760/);
+assert.match(source, /currentHeight === 900/);
+assert.match(source, /PromptAssistantClient/);
+assert.match(source, /buildPromptAssistantContext/);
+assert.match(source, /prompt_assist_result/);
+assert.match(source, /Staged .* proposal/);
+assert.match(source, /Apply to scene/);
+assert.match(source, /Apply anyway/);
+assert.match(source, /messagesByProvider/);
+assert.match(source, /promptAssistantIdentityKey/);
+assert.match(source, /activeWorkflow/);
+assert.match(source, /persistPendingRequest/);
+assert.match(source, /restorePendingRequest/);
+assert.match(source, /Accept only a request this editor incarnation/);
+assert.match(source, /assistant\.preparingRequest !== preparation/);
+assert.match(source, /Snapshot the selected scene before the asynchronous bridge handshake/);
+assert.match(source, /rebaseActivePromptOntoLivePlan/);
+assert.match(source, /publishCompanionScene/);
+assert.match(source, /prompt_assist_cancel_ack/);
+assert.match(source, /empty assistant draft cannot replace/i);
+assert.match(source, /Undo last apply/);
+assert.match(source, /assistant\.client\?\.close\(\)/);
+assert.match(source, /appendScene/);
+assert.match(source, /state\.plan\.shots\.push\(makeShot\(state\.plan\.shots\)\)/);
+assert.match(source, /Append a new scene and select it/);
+assert.match(source, /PRESENTATION_PROPERTY/);
+assert.match(source, /state\.decorated \? "Rich text" : "Plain text"/);
+assert.match(source, /tokenizeRichPrompt/);
+assert.match(source, /h3sp-token-picture/);
+assert.match(source, /h3sp-token-audio/);
+assert.match(source, /h3sp-token-thumb/);
+assert.match(source, /--h3sp-accent: color-mix\(in srgb, var\(--h3sp-text\)/);
+assert.match(source, /--h3sp-token-subject: color-mix/);
+assert.match(source, /color:var\(--h3sp-token-subject\)/);
+assert.doesNotMatch(source, /h3sp-token-subject \{ color:#8ed7a4/);
+assert.match(source, /h3sp-popover audio/);
+assert.match(source, /mediaElement\.controls = true/);
+assert.match(source, /contentEditable = "true"/);
+assert.match(source, /convertTaggedPictureReference/);
+assert.match(source, /replacePromptReferenceOccurrence/);
+assert.match(source, /click to replace or edit/);
+assert.match(source, /Time \(sec\)/);
+assert.match(source, /makeRichToken\(part, partStart, partEnd\)/);
+assert.match(source, /popoverPinned/);
+assert.match(source, /taggedPictureReferenceMode/);
+assert.match(source, /h3sp-ref-mode/);
+assert.match(source, /Use untimed Qwen-only #tag/);
+assert.match(source, /referenceButton\.addEventListener\("pointerdown", rememberPromptSelection\)/);
+assert.match(source, /document\.activeElement === state\.richEditor/);
+assert.match(source, /current\.slice\(0, insertionStart\)/);
+assert.match(source, /if \(record\.semanticOnly\) return "semantic"/);
+assert.match(source, /editorPlainText\(range\.cloneContents\(\)\)\.length/);
+assert.match(source, /maxItems:40/);
+assert.match(source, /"keydown", "keyup", "keypress", "copy", "cut", "paste"/);
+assert.match(source, /stopPropagation deliberately preserves the browser's default/);
+assert.match(source, /selectedEditorPlainText/);
+assert.match(source, /data-token value/);
+assert.match(source, /setData\("text\/plain", text\)/);
+assert.match(source, /richEditor\.addEventListener\("copy"/);
+assert.match(source, /richEditor\.addEventListener\("cut"/);
+assert.match(source, /PromptUndoHistory/);
+assert.match(source, /promptUndoDirection/);
+assert.match(source, /applyPromptUndo/);
+assert.match(source, /activeSceneIndexAfterRefresh/);
+assert.match(source, /ownsPromptHistoryTarget/);
+assert.match(source, /stopImmediatePropagation\(\)/);
+assert.match(source, /event\.inputType \|\| state\.richInputType/);
+assert.match(source, /promptUndoForScene\(shotId, text, \{external:true\}\)/);
+assert.match(source, /window\.setInterval\(\(\) => loadPlan\(false\), 500\)/);
+assert.match(source, /h3_prompt_history_core\.mjs/);
+assert.match(source, /promptRevisionNavigation/);
+assert.match(source, /promptRevisionLabel/);
+assert.match(source, /promptRevisionTree/);
+assert.match(source, /\/minimax_h3_context_loop\/prompt-history/);
+assert.match(source, /action: "save"/);
+assert.match(source, /action: "activate"/);
+assert.match(source, /mutateHistoryRevision\(\s*"label"/);
+assert.match(source, /mutateHistoryRevision\(\s*"archive"/);
+assert.match(source, /mutateHistoryRevision\(\s*"delete"/);
+assert.match(source, /parent → child progression/);
+assert.match(source, /Delete unexecuted leaf/);
+assert.match(source, /scheduleHistoryDraft\(shotId, textarea\.value\)/);
+assert.match(source, /navigation\.position.*navigation\.total/);
+assert.match(source, /Loading prompt versions/);
+assert.match(source, /runName === state\.lastRunName/);
+assert.match(source, /grid-template-columns:minmax\(0,1fr\) auto minmax\(0,1fr\)/);
+assert.match(source, /footer\.append\(identity, historyHost, status\)/);
+assert.match(source, /PROJECT_ASSET_CATALOG_CHANGED_EVENT/);
+assert.match(source, /function refreshReferenceState/);
+assert.match(source, /refreshReferenceState\(next\)/);
+assert.match(source, /const referenceData = refreshReferenceState\(activePromptText\(\)\)/);
+assert.match(source, /onProjectAssetCatalogChanged/);
+assert.match(source, /removeEventListener\?\.\(\s*PROJECT_ASSET_CATALOG_CHANGED_EVENT/);
+assert.match(source, /const scrollTop = state\.richEditor\.scrollTop/);
+assert.match(source, /state\.richEditor\.scrollTop = scrollTop/);
+assert.match(source, /target\.focus\(\{preventScroll:true\}\)/);
+assert.match(source, /const PROMPT_SYNC_DELAY_MS = 140/);
+assert.match(source, /const PROMPT_ANALYSIS_DELAY_MS = 90/);
+assert.match(source, /writePlan\(status, \{deferEffects:true\}\)/);
+assert.match(source, /function flushPlanEffects\(\)/);
+assert.match(source, /state\.planWidget\.value = value/);
+assert.match(source, /window\.setTimeout\(\s*flushPlanEffects, PROMPT_SYNC_DELAY_MS/);
+assert.match(source, /liveValue !== state\.lastValue && !rebaseActivePromptOntoLivePlan\(\)/);
+assert.match(source, /textarea\.addEventListener\("blur", \(\) => \{\s*flushPlanEffects\(\)/);
+assert.match(source, /schedulePromptAnalysis\(\)/);
+const teardown = source.slice(
+    source.indexOf("node.onRemoved = function ()"),
+    source.indexOf("node._h3PromptCompanionSetActiveScene"),
+);
+assert.match(teardown, /state\.disposed = true/);
+assert.match(teardown, /state\.planSyncPending = null/);
+assert.match(teardown, /state\.history\.pendingDraft = null/);
+assert.doesNotMatch(teardown, /flushPlanEffects\(\)/);
+assert.doesNotMatch(teardown, /flushPromptAnalysis\(\)/);
+assert.doesNotMatch(teardown, /flushHistoryDraft\(\)/);
+
+console.log("H3 Scene Prompt companion: Plan synchronization and controls pass");
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_segment_revision_unit_test.py b/ComfyUI-MiniMaxH3-Context-Loop/tests/_segment_revision_unit_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..1119b41ff2e2d9acde361f63bd50ce57c4fe72a8
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_segment_revision_unit_test.py
@@ -0,0 +1,295 @@
+#!/usr/bin/env python3
+"""Standalone regression test for non-destructive scene regeneration."""
+
+import importlib.util
+import json
+import pathlib
+import sys
+import tempfile
+import types
+import wave
+
+import torch
+
+
+ROOT = pathlib.Path(__file__).resolve().parents[1]
+PACKAGE = "h3_segment_revision_unit"
+
+folder_paths = types.ModuleType("folder_paths")
+folder_paths.get_output_directory = lambda: folder_paths.output_directory
+folder_paths.get_temp_directory = lambda: folder_paths.output_directory
+folder_paths.get_input_directory = lambda: folder_paths.output_directory
+folder_paths.get_annotated_filepath = lambda value: str(value)
+folder_paths.output_directory = str(ROOT)
+sys.modules["folder_paths"] = folder_paths
+
+package = types.ModuleType(PACKAGE)
+package.__path__ = [str(ROOT)]
+sys.modules[PACKAGE] = package
+
+shared_nodes = types.ModuleType(PACKAGE + ".nodes")
+shared_nodes.MiniMaxH3MotionContext = object
+shared_nodes._claim_inline_patch_ownership = lambda _conditioning=None: "test patch owner"
+shared_nodes._prepare_native_guide_conditioning = lambda *args: None
+shared_nodes._resize = lambda *args: None
+shared_nodes._streams_from_latent = lambda *args: None
+sys.modules[shared_nodes.__name__] = shared_nodes
+
+spec = importlib.util.spec_from_file_location(
+    PACKAGE + ".chain_nodes", ROOT / "chain_nodes.py")
+chain = importlib.util.module_from_spec(spec)
+sys.modules[spec.name] = chain
+spec.loader.exec_module(chain)
+
+
+class FakeImages:
+    shape = (5, 1, 1, 3)
+
+    def __getitem__(self, _key):
+        return self
+
+
+class FakeBlendImages(FakeImages):
+    shape = (7, 1, 1, 3)
+
+
+def main():
+    with tempfile.TemporaryDirectory() as tempdir:
+        folder_paths.output_directory = tempdir
+        chain._compact_latent = lambda _latent: {"samples": [b"video", b"audio"]}
+        chain._write_run_archives = lambda *_args, **_kwargs: {}
+        chain._archive_media_metadata = lambda _archives: {}
+
+        saved_tensors = []
+
+        def save_checkpoint(_tensors, path, metadata=None):
+            saved_tensors.append(dict(_tensors))
+            pathlib.Path(path).write_bytes(
+                json.dumps(metadata or {}, sort_keys=True).encode("utf-8"))
+
+        def save_video(_images, path, *_args, **_kwargs):
+            pathlib.Path(path).write_bytes(
+                ("video:" + pathlib.Path(path).name).encode("utf-8"))
+
+        chain._st_save = save_checkpoint
+        chain._write_segment_video = save_video
+
+        plan = {
+            "run_name": "revision_test",
+            "plan_hash": "plan",
+            "prompt_prefix": "",
+            "segment_crf": 18,
+            "source_timeline": {
+                "kind": "source_timeline",
+                "recovery": {"audio_path": "source.wav"},
+            },
+            "compatibility": {
+                "audio_mode": "source_track",
+                "width": 64,
+                "height": 64,
+                "context_length": 2,
+                "audio_context_length": 2,
+                "continuation_mode": "masked_av",
+                "video_blend_frames": 2,
+                "width": 960,
+                "height": 544,
+            },
+            "shots": [{
+                "id": "scene_one",
+                "prompt": "first take",
+                "scene_prompt": "first take",
+                "prompt_hash": "prompt-hash",
+                "seed": 1,
+                "steps": 5,
+                "raw_frames": 7,
+                "delivered_frames": 5,
+                "generation_start_frame": 0,
+                "lora_route": "c",
+                "prompt_seed_mode": "fixed",
+                "prompt_seed": 9001,
+                "source_audio_target": "off",
+            }],
+        }
+        state = {"plan": plan, "index": 1}
+        generated_audio = {
+            "waveform": torch.zeros(
+                (1, 2, round(5 / chain.FPS * 8000)), dtype=torch.float32),
+            "sample_rate": 8000,
+            chain.AUDIO_WITH_OVERLAP_WAVEFORM_KEY: torch.zeros(
+                (1, 2, round(7 / chain.FPS * 8000)), dtype=torch.float32),
+            chain.AUDIO_WITH_OVERLAP_FRAMES_KEY: 7,
+            chain.AUDIO_TRIM_FRAMES_KEY: 2,
+        }
+        saver = chain.MiniMaxH3ChainSegmentSave()
+        try:
+            saver.save(state, FakeImages(), object(), generated_audio)
+        except ValueError as exc:
+            assert "images_with_overlap" in str(exc)
+        else:
+            raise AssertionError("enabled blending accepted no overlap input")
+        first_result = saver.save(
+            state, FakeImages(), object(), generated_audio,
+            FakeBlendImages())
+        first = first_result["result"][0]
+        assert "audio_with_overlap" in saved_tensors[-1]
+        assert saved_tensors[-1]["audio_with_overlap"].shape[-1] == round(
+            7 / chain.FPS * 8000)
+        first_paths = {
+            key: pathlib.Path(chain._absolute_output_path(first[key]))
+            for key in ("segment", "checkpoint", "prompt_file",
+                        "revision_metadata", "generated_audio",
+                        "blend_segment")
+        }
+        assert all(path.is_file() for path in first_paths.values())
+        assert first_result["ui"]["images"] == [
+            chain._video_output_item(str(first_paths["segment"]))]
+        assert first_result["ui"]["animated"] == (True,)
+        assert first["generated_audio_sha256"] == chain._file_sha256(
+            str(first_paths["generated_audio"]))
+        assert first["scene_dependency"]["version"] == (
+            chain.SCENE_DEPENDENCY_VERSION)
+        assert set(first["scene_dependency"]["scopes"]) == set(
+            chain.DEPENDENCY_SCOPES)
+        assert first["branch_id"] == first["revision"]
+        assert first["resolved_context_length"] == 0
+        assert first["resolved_audio_context_length"] == 0
+        assert first["lora_route"] == "c"
+        assert first["prompt_seed_mode"] == "fixed"
+        assert first["prompt_seed"] == 9001
+        assert first["source_audio_target"] == "off"
+        assert chain._public_segment(first)["lora_route"] == "c"
+        restored_revision = chain._checkpoint_plan_revision(first)
+        assert restored_revision["lora_route"] == "c"
+        assert restored_revision["prompt_seed_mode"] == "fixed"
+        assert restored_revision["prompt_seed"] == "9001"
+        assert restored_revision["source_audio_target"] == "off"
+        checkpoint_metadata = json.loads(
+            first_paths["checkpoint"].read_text(encoding="utf-8"))
+        assert checkpoint_metadata["lora_route"] == "c"
+        with wave.open(str(first_paths["generated_audio"]), "rb") as audio_file:
+            assert audio_file.getnchannels() == 2
+            assert audio_file.getframerate() == 8000
+            assert audio_file.getnframes() == round(5 / chain.FPS * 8000)
+
+        old_alternate = "a" * 32
+        chain._atomic_json(chain._run_editorial_path("revision_test"), {
+            "run_name": "revision_test",
+            "scene_order": [{"scene": 1, "scene_id": "scene_one"}],
+            "alternate_draft": {
+                "enabled": True,
+                "scene": 1,
+                "scene_id": "scene_one",
+                "base_revision": first["revision"],
+                "prompt": "third take",
+                "seed": "3",
+            },
+            "replacements": [{
+                "scene": 1,
+                "scene_id": "scene_one",
+                "base_revision": first["revision"],
+                "alternate_revision": old_alternate,
+            }],
+        })
+        plan["shots"][0].update({
+            "prompt": "second take",
+            "scene_prompt": "second take",
+            "prompt_hash": "replacement-hash",
+            "seed": 2,
+        })
+        second_result = saver.save(
+            state, FakeImages(), object(), generated_audio,
+            FakeBlendImages())
+        second = second_result["result"][0]
+        assert second["revision"] != first["revision"]
+        assert second["supersedes"] == first["revision_metadata"]
+        assert second["branch_id"] == second["revision"]
+        assert second["forked_from_branch_id"] == first["branch_id"]
+        assert second["generated_audio"] != first["generated_audio"]
+        assert second["blend_segment"] != first["blend_segment"]
+        assert second["blend_frames"] == 2
+        assert all(path.is_file() for path in first_paths.values())
+        assert second_result["ui"]["images"] == [chain._video_output_item(
+            chain._absolute_output_path(second["segment"]))]
+        assert second_result["ui"]["animated"] == (True,)
+        reconciled_editorial = chain._load_run_editorial("revision_test")
+        assert reconciled_editorial["alternate_draft"] is None
+        assert reconciled_editorial["replacements"] == []
+
+        current = json.loads(pathlib.Path(
+            chain._absolute_output_path(second["metadata"])
+        ).read_text(encoding="utf-8"))
+        archived = json.loads(first_paths["revision_metadata"].read_text(
+            encoding="utf-8"))
+        assert current["segment"]["revision"] == second["revision"]
+        assert current["segment"]["prompt"] == "second take"
+        assert current["scene_dependency"] == second["scene_dependency"]
+        assert current["source_timeline"] == plan["source_timeline"]
+        assert archived["segment"]["revision"] == first["revision"]
+        assert archived["segment"]["prompt"] == "first take"
+
+        # A direct alternate take starts a branch. Later scenes regenerated
+        # because their parent changed inherit that branch instead of creating
+        # a new branch at every scene.
+        for index in (2, 3):
+            plan["shots"].append({
+                "id": "scene_%d" % index,
+                "prompt": "scene %d" % index,
+                "scene_prompt": "scene %d" % index,
+                "prompt_hash": "hash-%d" % index,
+                "seed": index,
+                "steps": 5,
+                "raw_frames": 7,
+                "delivered_frames": 5,
+                "generation_start_frame": (index - 1) * 5,
+            })
+        scene_two_old = saver.save(
+            {"plan": plan, "index": 2, "segments": [second]},
+            FakeImages(), object(), generated_audio, FakeBlendImages(),
+        )["result"][0]
+        scene_three_old = saver.save(
+            {"plan": plan, "index": 3,
+             "segments": [second, scene_two_old]},
+            FakeImages(), object(), generated_audio, FakeBlendImages(),
+        )["result"][0]
+        assert scene_two_old["branch_id"] == second["branch_id"]
+        assert scene_three_old["branch_id"] == second["branch_id"]
+
+        plan["shots"][1]["seed"] = 22
+        scene_two_new = saver.save(
+            {"plan": plan, "index": 2, "segments": [second]},
+            FakeImages(), object(), generated_audio, FakeBlendImages(),
+        )["result"][0]
+        assert scene_two_new["branch_id"] == scene_two_new["revision"]
+        assert scene_two_new["forked_from_branch_id"] == second["branch_id"]
+
+        plan["shots"][2]["seed"] = 33
+        scene_three_new = saver.save(
+            {"plan": plan, "index": 3,
+             "segments": [second, scene_two_new]},
+            FakeImages(), object(), generated_audio, FakeBlendImages(),
+        )["result"][0]
+        assert scene_three_new["branch_id"] == scene_two_new["branch_id"]
+        assert "forked_from_branch_id" not in scene_three_new
+
+        # AV with no picture prefix returns before consuming any generated
+        # audio, even when the inherited audio setting is nonzero.
+        plan["compatibility"]["audio_policy"] = chain._contract_audio_policy(
+            "generated", "off", "on")
+        plan["shots"][2].update({
+            "context_length":0, "audio_context_length":39,
+            "continuation_mode":"audio_feathered_av",
+            "raw_frames":5, "delivered_frames":5})
+        independent = saver.save(
+            {"plan":plan, "index":3, "segments":[second, scene_two_new]},
+            FakeImages(), object(), generated_audio)["result"][0]
+        assert independent["audio_context_length"] == 39, "retain the generation recipe"
+        assert independent["resolved_context_length"] == 0
+        assert independent["resolved_audio_context_length"] == 0
+        assert independent["generated_continuity"] == "on"
+
+    print("H3 segment revisions: regeneration advances the active pointer and "
+          "retains the previous take's video, checkpoint, prompt, and WAV")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_semantic_anchor_js_test.mjs b/ComfyUI-MiniMaxH3-Context-Loop/tests/_semantic_anchor_js_test.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..b89728f44fd1fb5f2ede1bdd916b1c332dc7a981
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_semantic_anchor_js_test.mjs
@@ -0,0 +1,46 @@
+#!/usr/bin/env node
+
+import assert from "node:assert/strict";
+import {
+    richGuideInstruction,
+    tokenizeRichPrompt,
+} from "../web/h3_rich_prompt_editor_core.mjs";
+
+const records = [
+    {kind:"picture", tag:"replacement", token:"@replacement",
+        label:"<Picture 1>", active:true},
+    {kind:"picture", tag:"door", token:"#door", nativeToken:null,
+        semanticOnly:true, previewUrl:"/project-assets/door", active:true},
+    {kind:"video", token:"@performance", label:"<Video 1>", active:true},
+];
+
+const parts = tokenizeRichPrompt(
+    "Use @replacement and #replacement, #replacement[0.00s], #replacement[2.50], " +
+    "preview #door, then reject #performance[1.00s] and " +
+    "#missing[1.50s].",
+    records,
+);
+const refs = parts.filter((item) => item.type === "reference");
+assert.deepEqual(refs.map((item) => [
+    item.text, item.kind, item.semantic, item.timestamp, item.unresolved,
+]), [
+    ["@replacement", "picture", false, null, false],
+    ["#replacement", "picture", true, null, false],
+    ["#replacement[0.00s]", "picture", true, 0, false],
+    ["#replacement[2.50]", "picture", true, 2.5, false],
+    ["#door", "picture", true, null, false],
+    ["#performance[1.00s]", "video", true, 1, true],
+    ["#missing[1.50s]", "unknown", true, 1.5, true],
+]);
+assert.equal(parts.map((item) => item.text).join(""),
+    "Use @replacement and #replacement, #replacement[0.00s], #replacement[2.50], " +
+    "preview #door, then reject #performance[1.00s] and " +
+    "#missing[1.50s].");
+const semanticOnly = refs.find((item) => item.text === "#door");
+assert.equal(semanticOnly.record, records[1]);
+assert.equal(semanticOnly.record.previewUrl, "/project-assets/door");
+
+const instruction = richGuideInstruction("general", "Ref2VA");
+assert.match(instruction, /bare #picture semantic visual/);
+
+console.log("H3 semantic-anchor prompt chips and optimizer preservation pass");
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_socket_presentation_js_test.mjs b/ComfyUI-MiniMaxH3-Context-Loop/tests/_socket_presentation_js_test.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..0b0cb7c8fcbc48e010739d49a830263d3b797d7c
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_socket_presentation_js_test.mjs
@@ -0,0 +1,422 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import {
+    ADVANCED_POLICY_NODE,
+    CHAIN_POLICY_NODE,
+    MODERN_PLAN_NODE,
+    PROFILE_POLICY_NODE,
+    applySocketPresentation,
+    hasSourceTimeline,
+    isPlanNode,
+    policyPlanConsumers,
+    presentationForNode,
+    resolveAudioContextLength,
+    resolveAudioPolicy,
+    resolveTransitionPolicy,
+} from "../web/h3_socket_presentation_core.mjs";
+
+class Graph {
+    constructor(nodes, links) {
+        this._nodes = nodes;
+        this.links = links;
+        for (const node of nodes) node.graph = this;
+    }
+
+    getNodeById(id) {
+        return this._nodes.find((node) => node.id === id) ?? null;
+    }
+}
+
+function node(id, type, inputs = [], outputs = [], widgets = []) {
+    return {
+        id,
+        comfyClass: type,
+        inputs: inputs.map(([name, link = null]) => ({name, link})),
+        outputs: outputs.map(([name, links = null]) => ({name, links})),
+        widgets: widgets.map(([name, value]) => ({name, value})),
+        properties: {},
+    };
+}
+
+const audioPolicy = node(1, CHAIN_POLICY_NODE, [], [["chain_policy", [10]]], [
+    ["incoming_transition", "guide"],
+    ["final_audio", "generated"],
+    ["source_reference", "off"],
+    ["generated_continuity", "on"],
+    ["lock_source_audio", false],
+]);
+const plan = node(2, "MiniMaxH3ChainPlan", [
+    ["chain_policy", 10],
+], [
+    ["plan", [11]], ["summary", null], ["clip_count", null],
+    ["video_blend_frames", null],
+], [
+    ["audio_mode", "source_track"], ["continuation_mode", "guide"],
+    ["context_length", 22], ["audio_context_length", 22],
+    ["encode_mode", "resize"], ["anchor_mode", "head"], ["crop", "center"],
+    ["video_blend_frames", 0],
+]);
+const start = node(3, "MiniMaxH3ChainLoopStart", [
+    ["plan", 11], ["source_audio", null], ["source_timeline", null],
+], [["flow", null], ["state", [12]], ["status", null]]);
+new Graph([audioPolicy, plan, start], {
+    10: {origin_id: 1, target_id: 2},
+    11: {origin_id: 2, target_id: 3},
+});
+
+assert.deepEqual(resolveAudioPolicy(start), {
+    known: true,
+    finalAudio: "generated",
+    sourceReference: "off",
+    generatedContinuity: "on",
+    source: "compact",
+});
+assert.equal(hasSourceTimeline(start), false);
+const planPresentation = presentationForNode(plan, false);
+assert.equal(planPresentation.hiddenWidgets.has("audio_mode"), true);
+assert.equal(planPresentation.hiddenWidgets.has("continuation_mode"), true);
+assert.equal(planPresentation.hiddenWidgets.has("context_length"), true);
+assert.equal(planPresentation.hiddenWidgets.has("audio_context_length"), true);
+assert.equal(planPresentation.hiddenWidgets.has("encode_mode"), true);
+assert.equal(planPresentation.hiddenWidgets.has("anchor_mode"), true);
+assert.equal(planPresentation.hiddenWidgets.has("crop"), true);
+assert.equal(planPresentation.hiddenWidgets.has("video_blend_frames"), true);
+assert.equal(planPresentation.hiddenOutputs.has("summary"), true);
+assert.equal(planPresentation.hiddenOutputs.has("clip_count"), true);
+assert.equal(planPresentation.hiddenOutputs.has("video_blend_frames"), true);
+assert.equal(presentationForNode(plan, true).hiddenWidgets.size, 0);
+
+const modernPlan = node(4, MODERN_PLAN_NODE, [
+    ["chain_policy", 13],
+], [
+    ["plan", [14]], ["summary", null], ["clip_count", null],
+    ["video_blend_frames", null],
+], [
+    ["encode_mode", "video"], ["crop", "disabled"],
+    ["video_blend_frames", 0],
+]);
+const modernStart = node(5, "MiniMaxH3ChainLoopStart", [
+    ["plan", 14], ["source_audio", null], ["source_timeline", null],
+]);
+new Graph([audioPolicy, modernPlan, modernStart], {
+    13: {origin_id: 1, target_id: 4},
+    14: {origin_id: 4, target_id: 5},
+});
+assert.equal(isPlanNode(modernPlan), true);
+assert.equal(resolveTransitionPolicy(modernStart).known, true);
+assert.equal(resolveAudioPolicy(modernStart).known, true);
+const modernPresentation = presentationForNode(modernPlan, false);
+assert.equal(modernPresentation.hiddenOutputs.has("summary"), true);
+assert.equal(modernPresentation.hiddenOutputs.has("clip_count"), true);
+assert.equal(modernPresentation.hiddenWidgets.has("encode_mode"), false);
+
+const studio = node(30, "MiniMaxH3ChainPlanStudio", [], [], [
+    ["verify_resume_history", true], ["plan_json", "{}"],
+    ["run_name", "h3_chain"], ["generation_fingerprint", ""],
+    ["width", 960], ["height", 544], ["context_length", 22],
+    ["encode_mode", "video"], ["anchor_mode", "head"],
+    ["crop", "disabled"], ["audio_mode", "generated_audio"],
+    ["audio_context_length", 22], ["default_duration_seconds", 15],
+    ["default_steps", 20], ["base_seed", 0], ["segment_crf", 18],
+    ["video_blend_frames", 0], ["continuation_mode", "guide"],
+]);
+const compactStudio = presentationForNode(studio, false);
+for (const name of [
+    "plan_json", "run_name", "generation_fingerprint", "width", "height",
+    "context_length", "encode_mode", "anchor_mode", "crop", "audio_mode",
+    "audio_context_length", "default_duration_seconds", "default_steps",
+    "base_seed", "segment_crf", "video_blend_frames", "continuation_mode",
+]) {
+    assert.equal(compactStudio.hiddenWidgets.has(name), true,
+        `${name} is edited in Studio's dedicated Plan settings tab`);
+}
+assert.equal(presentationForNode(studio, true).hiddenWidgets.has("run_name"), false);
+
+const inputOrder = start.inputs.map((slot) => slot.name);
+const outputOrder = start.outputs.map((slot) => slot.name);
+const linkIds = start.inputs.map((slot) => slot.link);
+applySocketPresentation(start, false);
+assert.equal(start.inputs[1].hidden, true, "unused legacy AUDIO is compact");
+assert.equal(start.outputs[2].hidden, true, "diagnostic status is compact");
+assert.deepEqual(start.inputs.map((slot) => slot.name), inputOrder);
+assert.deepEqual(start.outputs.map((slot) => slot.name), outputOrder);
+assert.deepEqual(start.inputs.map((slot) => slot.link), linkIds);
+
+applySocketPresentation(start, true);
+assert.equal(start.inputs[1].hidden, false);
+assert.equal(start.outputs[2].hidden, false);
+
+audioPolicy.widgets.find((item) => item.name === "source_reference").value = "on";
+assert.equal(presentationForNode(start, false).hiddenInputs.has("source_audio"), false);
+
+const timeline = node(4, "MiniMaxH3SourceTimeline", [], [["source_timeline", [13]]]);
+start.inputs.find((slot) => slot.name === "source_timeline").link = 13;
+start.graph = new Graph([audioPolicy, plan, timeline, start], {
+    10: {origin_id: 1, target_id: 2},
+    11: {origin_id: 2, target_id: 3},
+    13: {origin_id: 4, target_id: 3},
+});
+assert.equal(hasSourceTimeline(start), true);
+assert.equal(presentationForNode(start, false).hiddenInputs.has("source_audio"), true);
+
+const current = node(5, "MiniMaxH3ChainCurrent", [["state", 12], ["source_audio", null]], [
+    ["state", null], ["source_audio_slice", null], ["status", null],
+], [["align_audio_reference", false]]);
+start.graph._nodes.push(current);
+current.graph = start.graph;
+start.graph.links[12] = {origin_id: 3, target_id: 5};
+const currentPresentation = presentationForNode(current, false);
+assert.equal(currentPresentation.hiddenInputs.has("source_audio"), true);
+assert.equal(currentPresentation.hiddenOutputs.has("source_audio_slice"), false,
+    "source reference is on, so its output stays available");
+
+const upscaleAdapter = node(25, "MiniMaxH3ChainUpscaleAdapter", [], [], [
+    ["recipe_json", '{"upscaler":"LBH 3D"}'],
+]);
+assert.equal(
+    presentationForNode(upscaleAdapter, false).hiddenWidgets.has("recipe_json"),
+    true,
+    "upscale recipe provenance is hidden in the compact view",
+);
+assert.equal(
+    presentationForNode(upscaleAdapter, true).hiddenWidgets.has("recipe_json"),
+    false,
+    "advanced disclosure keeps the recipe editable",
+);
+
+const linkedStatus = node(6, "MiniMaxH3ChainSegmentSave", [], [
+    ["segment", null], ["status", [22]],
+]);
+applySocketPresentation(linkedStatus, false);
+assert.equal(linkedStatus.outputs[1].hidden, false,
+    "existing diagnostic links stay visible and untouched");
+assert.deepEqual(linkedStatus.outputs[1].links, [22]);
+
+assert.deepEqual(resolveTransitionPolicy(plan), {
+    known: true,
+    preset: "guide",
+    continuationMode: "guide",
+    contextLength: 22,
+    expertOverride: false,
+    source: "compact",
+});
+
+const unrelatedPlan = node(9, "MiniMaxH3ChainPlan", [
+    ["chain_policy", null],
+]);
+plan.graph._nodes.push(unrelatedPlan);
+unrelatedPlan.graph = plan.graph;
+assert.deepEqual(policyPlanConsumers(audioPolicy), [plan]);
+
+const compactPolicy = node(10, CHAIN_POLICY_NODE, [], [
+    ["chain_policy", [31]], ["status", null],
+], [
+    ["incoming_transition", "hard_av"], ["final_audio", "source"],
+    ["source_reference", "on"], ["generated_continuity", "off"],
+    ["lock_source_audio", false],
+]);
+const compactPlan = node(11, "MiniMaxH3ChainPlan", [
+    ["chain_policy", 31],
+], [["plan", [32]]], [
+    ["audio_context_length", 91],
+]);
+const compactStart = node(12, "MiniMaxH3ChainLoopStart", [
+    ["plan", 32], ["source_audio", null], ["source_timeline", null],
+]);
+new Graph([compactPolicy, compactPlan, compactStart], {
+    31: {origin_id: 10, target_id: 11},
+    32: {origin_id: 11, target_id: 12},
+});
+assert.deepEqual(resolveAudioPolicy(compactStart), {
+    known: true,
+    finalAudio: "source",
+    sourceReference: "on",
+    generatedContinuity: "off",
+    source: "compact",
+});
+assert.deepEqual(resolveTransitionPolicy(compactStart), {
+    known: true,
+    preset: "hard_av",
+    continuationMode: "masked_av",
+    contextLength: 39,
+    expertOverride: false,
+    source: "compact",
+});
+assert.equal(resolveAudioContextLength(compactStart), 39,
+    "compact 0.5 policy owns the automatic audio context default");
+assert.deepEqual(policyPlanConsumers(compactPolicy), [compactPlan]);
+assert.equal(
+    presentationForNode(compactPolicy, false).hiddenOutputs.has("status"), true,
+);
+compactPolicy.widgets.find(
+    (item) => item.name === "lock_source_audio").value = true;
+assert.deepEqual(resolveAudioPolicy(compactStart), {
+    known: true,
+    finalAudio: "source",
+    sourceReference: "off",
+    generatedContinuity: "off",
+    source: "compact",
+    sourceAudioTarget: "locked",
+});
+assert.equal(
+    presentationForNode(compactStart, false).hiddenInputs.has("source_audio"),
+    false,
+    "locked source target still needs legacy source audio without a timeline",
+);
+
+const generationProfile = node(40, PROFILE_POLICY_NODE, [], [
+    ["chain_policy", [41]], ["status", null],
+], [
+    ["scene_continuity", "Hard picture + smooth audio"],
+    ["audio_profile", "Lip-sync to source audio"],
+]);
+const profilePlan = node(41, "MiniMaxH3ChainPlan", [
+    ["chain_policy", 41],
+], [["plan", [42]]]);
+const profileStart = node(42, "MiniMaxH3ChainLoopStart", [
+    ["plan", 42], ["source_audio", null], ["source_timeline", null],
+]);
+new Graph([generationProfile, profilePlan, profileStart], {
+    41: {origin_id: 40, target_id: 41},
+    42: {origin_id: 41, target_id: 42},
+});
+assert.deepEqual(resolveAudioPolicy(profileStart), {
+    known: true,
+    finalAudio: "source",
+    sourceReference: "off",
+    generatedContinuity: "off",
+    source: "profile",
+    sourceAudioTarget: "locked",
+});
+assert.deepEqual(resolveTransitionPolicy(profileStart), {
+    known: true,
+    preset: "soft_av",
+    continuationMode: "audio_feathered_av",
+    contextLength: 39,
+    expertOverride: false,
+    source: "profile",
+});
+assert.equal(resolveAudioContextLength(profileStart), 39);
+assert.deepEqual(policyPlanConsumers(generationProfile), [profilePlan]);
+assert.equal(
+    presentationForNode(generationProfile, false).hiddenOutputs.has("status"),
+    true,
+);
+
+const legacyAdapter = node(8, "MiniMaxH3Legacy04PolicyAdapter", [], [
+    ["chain_policy", null], ["status", null],
+], [
+    ["audio_mode", "source_plus_timeline"],
+    ["continuation_mode", "masked_av"], ["context_length", 56],
+    ["audio_context_length", 91],
+]);
+assert.deepEqual(resolveAudioPolicy(legacyAdapter), {
+    known: true,
+    finalAudio: "source",
+    sourceReference: "on",
+    generatedContinuity: "on",
+    source: "legacy_adapter",
+});
+assert.equal(
+    presentationForNode(legacyAdapter, false).hiddenWidgets.has("audio_mode"),
+    false,
+    "standalone legacy migration still exposes its 0.4 audio mode",
+);
+assert.deepEqual(resolveTransitionPolicy(legacyAdapter), {
+    known: true,
+    preset: "custom",
+    continuationMode: "masked_av",
+    contextLength: 56,
+    expertOverride: true,
+    source: "legacy_adapter",
+});
+assert.equal(resolveAudioContextLength(legacyAdapter), 91);
+
+const layeredBase = node(20, CHAIN_POLICY_NODE, [], [
+    ["chain_policy", [41]], ["status", null],
+], [
+    ["incoming_transition", "guide"], ["final_audio", "source"],
+    ["source_reference", "on"], ["generated_continuity", "on"],
+    ["lock_source_audio", false],
+]);
+const layeredAdvanced = node(21, ADVANCED_POLICY_NODE, [
+    ["chain_policy", 41],
+], [["chain_policy", [42]], ["status", null]], [
+    ["incoming_transition", "drift_av"],
+]);
+const layeredPlan = node(22, "MiniMaxH3ChainPlan", [
+    ["chain_policy", 42],
+], [["plan", [43]]], [
+    ["audio_mode", "generated_audio"],
+    ["continuation_mode", "guide"],
+    ["context_length", 5],
+    ["audio_context_length", 5],
+]);
+const layeredStart = node(23, "MiniMaxH3ChainLoopStart", [
+    ["plan", 43], ["source_audio", null], ["source_timeline", null],
+]);
+new Graph([layeredBase, layeredAdvanced, layeredPlan, layeredStart], {
+    41: {origin_id: 20, target_id: 21},
+    42: {origin_id: 21, target_id: 22},
+    43: {origin_id: 22, target_id: 23},
+});
+assert.deepEqual(resolveAudioPolicy(layeredStart), {
+    known: true,
+    finalAudio: "source",
+    sourceReference: "on",
+    generatedContinuity: "on",
+    source: "compact",
+});
+assert.deepEqual(resolveTransitionPolicy(layeredStart), {
+    known: true,
+    preset: "drift_av",
+    continuationMode: "drift_control_av",
+    contextLength: 39,
+    expertOverride: false,
+    source: "advanced",
+});
+assert.equal(resolveAudioContextLength(layeredStart), 39);
+assert.deepEqual(policyPlanConsumers(layeredBase), [layeredPlan]);
+assert.deepEqual(policyPlanConsumers(layeredAdvanced), [layeredPlan]);
+
+const legacyOverlay = node(24, "MiniMaxH3Legacy04PolicyAdapter", [
+    ["chain_policy", 44],
+], [["chain_policy", null]], [
+    ["audio_mode", "generated_audio"],
+    ["continuation_mode", "feathered_av"], ["context_length", 39],
+    ["audio_context_length", 17],
+]);
+layeredBase.outputs[0].links.push(44);
+layeredBase.graph._nodes.push(legacyOverlay);
+legacyOverlay.graph = layeredBase.graph;
+layeredBase.graph.links[44] = {origin_id: 20, target_id: 24};
+assert.deepEqual(resolveAudioPolicy(legacyOverlay), {
+    known: true,
+    finalAudio: "source",
+    sourceReference: "on",
+    generatedContinuity: "on",
+    source: "compact",
+});
+assert.equal(
+    presentationForNode(legacyOverlay, false).hiddenWidgets.has("audio_mode"),
+    true,
+    "a chained legacy boundary does not expose its ignored audio mode",
+);
+assert.equal(
+    presentationForNode(legacyOverlay, true).hiddenWidgets.has("audio_mode"),
+    true,
+    "the ignored legacy audio mode stays hidden in the advanced view",
+);
+
+const extensionSource = fs.readFileSync(
+    new URL("../web/h3_socket_presentation.js", import.meta.url), "utf8");
+assert.match(extensionSource, /Show advanced H3 controls/);
+assert.match(extensionSource, /Hide advanced H3 controls/);
+assert.match(extensionSource, /refreshPolicyConsumers\(node\)/);
+assert.match(extensionSource, /_h3ChainEditorConnectionRefresh/);
+assert.match(extensionSource, /_h3PlanStudioRefresh/);
+assert.match(extensionSource, /scene_continuity:"Scene continuity"/);
+assert.match(extensionSource, /audio_profile:"Audio profile"/);
+assert.doesNotMatch(extensionSource, /removeInput|removeOutput/);
+
+console.log("H3 socket presentation: positional compatibility and policy visibility pass");
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_source_av_target_unit_test.py b/ComfyUI-MiniMaxH3-Context-Loop/tests/_source_av_target_unit_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..9ff873e6ed9b1c7d6624043961b065f2460b7de8
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_source_av_target_unit_test.py
@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""CPU regression for frame-locked loop source AV target construction."""
+
+import importlib.util
+import os
+import sys
+import types
+
+import torch
+import torch.nn.functional as functional
+
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+PACKAGE = "h3_source_av_target_test_pkg"
+
+
+class NestedTensor:
+    def __init__(self, parts):
+        self.parts = tuple(parts)
+
+    def unbind(self):
+        return self.parts
+
+
+def _install_stubs():
+    package = types.ModuleType(PACKAGE)
+    package.__path__ = [ROOT]
+    sys.modules[PACKAGE] = package
+
+    comfy = types.ModuleType("comfy")
+    comfy.__path__ = []
+    nested = types.ModuleType("comfy.nested_tensor")
+    nested.NestedTensor = NestedTensor
+    comfy.nested_tensor = nested
+    sys.modules["comfy"] = comfy
+    sys.modules["comfy.nested_tensor"] = nested
+
+    nodes = types.ModuleType("%s.nodes" % PACKAGE)
+    nodes.FPS = 24
+    nodes.AUDIO_HZ = 40
+
+    def resize(images, width, height, _crop):
+        work = images[..., :3].movedim(-1, 1)
+        work = functional.interpolate(
+            work, size=(height, width), mode="bilinear", align_corners=False)
+        return work.movedim(1, -1)
+
+    nodes._resize = resize
+    sys.modules[nodes.__name__] = nodes
+
+    context = types.ModuleType("%s.masked_context" % PACKAGE)
+
+    def validate_target(latent, strict_audio_grid=True):
+        video, audio = latent["samples"].unbind()
+        # 37 H3 video steps represent the exact 124-frame run used below.
+        frames = 124 if int(video.shape[2]) == 37 else -1
+        assert not strict_audio_grid
+        return video, audio, frames
+
+    context._validate_target_streams = validate_target
+    sys.modules[context.__name__] = context
+
+    ops = types.ModuleType("%s.masking_ops" % PACKAGE)
+
+    def normalize_mask(mask):
+        if mask.ndim == 2:
+            mask = mask.unsqueeze(0)
+        assert mask.ndim == 3
+        return mask.float().clamp(0.0, 1.0)
+
+    ops.normalize_comfy_mask = normalize_mask
+    sys.modules[ops.__name__] = ops
+
+
+def _load_node():
+    spec = importlib.util.spec_from_file_location(
+        "%s.source_av_target" % PACKAGE,
+        os.path.join(ROOT, "source_av_target.py"))
+    module = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = module
+    spec.loader.exec_module(module)
+    return module
+
+
+class VideoVAE:
+    def encode(self, frames):
+        assert int(frames.shape[0]) == 124
+        return torch.full((1, 24, 37, 2, 4), float(frames.mean()))
+
+
+class FloorAudioVAE:
+    audio_sample_rate = 32000
+
+    def __init__(self):
+        self.encoded_sample_counts = []
+
+    def encode(self, audio):
+        samples = int(audio.shape[1])
+        self.encoded_sample_counts.append(samples)
+        # This floor behavior is the former LTX concat failure: exact picture
+        # duration yields 206 steps, while the stock 124-frame target has 207.
+        steps = int(samples / self.audio_sample_rate * 40)
+        return torch.full((1, 32, 2, steps), float(audio.mean()))
+
+
+def main():
+    _install_stubs()
+    module = _load_node()
+
+    target_video = torch.zeros((1, 24, 37, 2, 4))
+    target_audio = torch.zeros((1, 32, 2, 207))
+    latent = {"samples": NestedTensor((target_video, target_audio))}
+    source_frames = torch.linspace(0.0, 1.0, 200).reshape(
+        200, 1, 1, 1).expand(200, 32, 64, 3).clone()
+    source_samples = round(200 / 24 * 32000)
+    source_audio = {
+        "waveform": torch.linspace(0.0, 1.0, source_samples).reshape(
+            1, 1, source_samples).repeat(1, 2, 1),
+        "sample_rate": 32000,
+    }
+    state = {
+        "index": 1,
+        "plan": {"shots": [{
+            "generation_start_frame": 17,
+            "raw_frames": 124,
+        }]},
+    }
+    audio_vae = FloorAudioVAE()
+    output, scene_frames, scene_audio, status = (
+        module.MiniMaxH3ContexLoopSourceAVTarget().prepare(
+            state, latent, VideoVAE(), audio_vae, source_frames,
+            source_audio, 24.0, "disabled"))
+
+    video, audio = output["samples"].unbind()
+    assert tuple(video.shape) == tuple(target_video.shape)
+    assert tuple(audio.shape) == tuple(target_audio.shape)
+    assert int(scene_frames.shape[0]) == 124
+    assert int(scene_audio["waveform"].shape[-1]) == round(124 / 24 * 32000)
+    assert audio_vae.encoded_sample_counts == [165600]
+    assert "source frames 17..140" in status
+    assert "207 audio steps" in status
+    assert not torch.count_nonzero(target_video)
+    assert not torch.count_nonzero(target_audio)
+    static_mask = torch.ones((1, 32, 64))
+    static_scene, static_count, static_status = (
+        module.MiniMaxH3ContexLoopMaskSlice().slice(
+            state, static_mask, 24.0))
+    assert static_scene.shape == (124, 32, 64)
+    assert static_count == 124
+    assert "static mask broadcast" in static_status
+
+    tracked_mask = torch.arange(200, dtype=torch.float32).reshape(
+        200, 1, 1).expand(200, 32, 64) / 199.0
+    tracked_scene, tracked_count, tracked_status = (
+        module.MiniMaxH3ContexLoopMaskSlice().slice(
+            state, tracked_mask, 24.0))
+    assert tracked_scene.shape == (124, 32, 64)
+    assert tracked_count == 124
+    assert torch.allclose(tracked_scene[0], tracked_mask[17])
+    assert torch.allclose(tracked_scene[-1], tracked_mask[140])
+    assert "tracked mask slice" in tracked_status
+
+    overlap_state = {
+        "index": 2,
+        "plan": {"shots": [state["plan"]["shots"][0], {
+            "generation_start_frame": 136,
+            "raw_frames": 175,
+        }]},
+    }
+    full_mask = torch.arange(311, dtype=torch.float32).reshape(
+        311, 1, 1).expand(311, 2, 2) / 310.0
+    overlap, overlap_count, _ = (
+        module.MiniMaxH3ContexLoopMaskSlice().slice(
+            overlap_state, full_mask, 24.0))
+    assert overlap_count == 175
+    assert torch.allclose(overlap[0], full_mask[136])
+    assert torch.allclose(overlap[-1], full_mask[310])
+
+    assert set(module.NODE_CLASS_MAPPINGS) == {
+        "MiniMaxH3ContexLoopSourceAVTarget",
+        "MiniMaxH3ContexLoopMaskSlice",
+    }
+
+    print(
+        "loop source AV target: 124 picture frames use the stock 207-step "
+        "audio grid; tracked masks slice exact scene/overlap frames while a "
+        "single mask broadcasts explicitly")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_source_timeline_consumers_unit_test.py b/ComfyUI-MiniMaxH3-Context-Loop/tests/_source_timeline_consumers_unit_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..a767d7015ff6b9a2d25d0150623881d8f81cb82a
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_source_timeline_consumers_unit_test.py
@@ -0,0 +1,384 @@
+#!/usr/bin/env python3
+"""0.5 consumers share one lazy Source Timeline through the full chain."""
+
+import importlib.util
+import json
+from fractions import Fraction
+import pathlib
+import sys
+import tempfile
+import types
+
+import av
+import numpy as np
+import torch
+
+
+ROOT = pathlib.Path(__file__).resolve().parents[1]
+PACKAGE = "h3_source_timeline_consumers_unit"
+
+folder_paths = types.ModuleType("folder_paths")
+folder_paths.root = str(ROOT)
+folder_paths.get_output_directory = lambda: folder_paths.root
+folder_paths.get_temp_directory = lambda: folder_paths.root
+folder_paths.get_input_directory = lambda: folder_paths.root
+folder_paths.get_annotated_filepath = lambda value: str(value)
+sys.modules["folder_paths"] = folder_paths
+
+package = types.ModuleType(PACKAGE)
+package.__path__ = [str(ROOT)]
+sys.modules[PACKAGE] = package
+
+shared_nodes = types.ModuleType(PACKAGE + ".nodes")
+shared_nodes.MiniMaxH3MotionContext = object
+shared_nodes._claim_inline_patch_ownership = lambda _conditioning=None: "test patch owner"
+shared_nodes._prepare_native_guide_conditioning = lambda value: value
+shared_nodes._resize = lambda *args: None
+shared_nodes._streams_from_latent = lambda *args: None
+sys.modules[shared_nodes.__name__] = shared_nodes
+
+spec = importlib.util.spec_from_file_location(
+    PACKAGE + ".chain_nodes", ROOT / "chain_nodes.py")
+chain = importlib.util.module_from_spec(spec)
+sys.modules[spec.name] = chain
+spec.loader.exec_module(chain)
+
+
+def write_fixture(path, frame_count=50, source_fps=25):
+    sample_rate = 48000
+    sample_count = round(frame_count / source_fps * sample_rate)
+    container = av.open(str(path), mode="w")
+    video = container.add_stream("libx264rgb", rate=source_fps)
+    video.width = video.height = 64
+    video.pix_fmt = "rgb24"
+    video.options = {"crf": "0", "preset": "ultrafast"}
+    audio = container.add_stream("pcm_f32le", rate=sample_rate)
+    audio.layout = "mono"
+    try:
+        for index in range(frame_count):
+            image = np.full((64, 64, 3), index * 4, dtype=np.uint8)
+            frame = av.VideoFrame.from_ndarray(image, format="rgb24")
+            frame.pts = index
+            frame.time_base = Fraction(1, source_fps)
+            for packet in video.encode(frame):
+                container.mux(packet)
+        for packet in video.encode():
+            container.mux(packet)
+        values = np.linspace(-0.8, 0.8, sample_count,
+                             dtype=np.float32).reshape(1, -1)
+        for start in range(0, sample_count, 2048):
+            frame = av.AudioFrame.from_ndarray(
+                values[:, start:start + 2048], format="fltp", layout="mono")
+            frame.sample_rate = sample_rate
+            frame.pts = start
+            frame.time_base = Fraction(1, sample_rate)
+            for packet in audio.encode(frame):
+                container.mux(packet)
+        for packet in audio.encode():
+            container.mux(packet)
+    finally:
+        container.close()
+
+
+def make_plan(run_name, audio_mode="source_track"):
+    return chain._normalize_plan(
+        json.dumps({"shots": [
+            {"id": "one", "prompt": "@motion begins.", "length": 22},
+            {"id": "two", "prompt": "@motion continues.", "length": 22},
+        ]}),
+        run_name, 64, 64, 5, "video", "head", "disabled",
+        audio_mode, 5, 1.0, 8, 7, 18, "model-stack", 0,
+        "guide")
+
+
+with tempfile.TemporaryDirectory() as temporary:
+    root = pathlib.Path(temporary)
+    folder_paths.root = str(root)
+    chain._output_root = lambda: str(root)
+    path = root / "source.mkv"
+    write_fixture(path)
+    timeline = chain.MiniMaxH3SourceTimeline().build(
+        str(path), "", "auto", 0)[0]
+    plan = make_plan("timeline-consumers")
+
+    started = chain.MiniMaxH3ChainLoopStart().start(
+        plan, 1, source_timeline=timeline)
+    state = started[1]
+    prepared = state["plan"]
+    runtime = state["source_timeline"]
+    assert prepared["compatibility"]["source_timeline_fingerprint"] == (
+        timeline["fingerprints"]["timeline"])
+    assert prepared["compatibility"]["source_audio_hash"] == (
+        timeline["fingerprints"]["audio"])
+    assert "value" not in prepared["source_timeline"]["audio"]
+
+    first = chain.MiniMaxH3ChainCurrent().current(state)["result"]
+    assert tuple(first[12]["waveform"].shape) == (1, 1, 44000)
+    state["index"] = 2
+    second = chain.MiniMaxH3ChainCurrent().current(state)["result"]
+    expected = chain._source_timeline_scene_audio(runtime, 17, 39)
+    assert torch.equal(second[12]["waveform"], expected["waveform"])
+    assert "Source Timeline frame-exact" in second[13]
+    assert second[14] == 0
+
+    scene_override_plan = chain._normalize_plan(
+        json.dumps({"shots": [
+            {"id": "dry", "prompt": "No source reference.", "length": 22},
+            {"id": "ref", "prompt": "Use source reference.", "length": 22,
+             "source_reference": "on"},
+        ]}),
+        "timeline-scene-overrides", 64, 64, 5, "video", "head",
+        "disabled", "generated_audio", 5, 1.0, 8, 7, 18,
+        "model-stack", 0, "guide")
+    override_started = chain.MiniMaxH3ChainLoopStart().start(
+        scene_override_plan, 1, source_timeline=timeline)
+    override_state = override_started[1]
+    assert chain.MiniMaxH3ChainCurrent().current(
+        override_state)["result"][12] is None
+    override_state["index"] = 2
+    override_second = chain.MiniMaxH3ChainCurrent().current(
+        override_state)["result"]
+    assert tuple(override_second[12]["waveform"].shape) == (1, 1, 44000)
+    assert override_second[0]["current_source_reference_dependency"] is not None
+
+    tagged = chain.MiniMaxH3TaggedMotionReferenceTimeline().add(
+        runtime, "motion", "<Subject 1>", "the supplied motion", "384",
+        "embedded", "", "sequential")
+    references, _fingerprint, _status, preview_source = tagged
+    entry = references["entries"][0]
+    assert chain._is_source_timeline(entry["value"])
+    assert entry["paired_audio_policy"] == "embedded"
+    scene_video, scene_audio, detail = chain._scheduled_video_reference_slice(
+        entry, state, 2, 2, 22)
+    assert tuple(scene_video.shape) == (22, 64, 64, 3)
+    assert tuple(scene_audio["waveform"].shape) == (1, 1, 44000)
+    assert "frames 17:39" in detail
+
+    masked_plan = {
+        **prepared,
+        "compatibility": {
+            **prepared["compatibility"],
+            "continuation_mode": "audio_feathered_av",
+        },
+        "shots": [dict(shot) for shot in prepared["shots"]],
+    }
+    masked_plan["shots"][1]["continuation_mode"] = "audio_feathered_av"
+    masked_video, masked_audio, masked_detail = (
+        chain._scheduled_video_reference_slice(
+            entry, {**state, "index": 2, "plan": masked_plan}, 2, 2, 22))
+    assert tuple(masked_video.shape) == (17, 64, 64, 3)
+    assert tuple(masked_audio["waveform"].shape) == (1, 1, 44000)
+    assert masked_detail == (
+        "@motion sequential delivered video frames 22:39; paired audio raw "
+        "frames 17:39 (origin scene 1)")
+
+    lazy_preview = chain.MiniMaxH3LazyMotionScenePreview().preview(
+        preview_source, 2, plan=prepared)
+    assert tuple(lazy_preview[0].shape) == (22, 64, 64, 3)
+    direct_preview = chain.MiniMaxH3SourceTimelineScenePreview().preview(
+        runtime, 2, "sequential", "384", True, prepared)
+    assert tuple(direct_preview[0].shape) == (22, 64, 64, 3)
+
+    manager_plan, manager_timeline = chain.MiniMaxH3ChainRunManager().passthrough(
+        plan, True, True, True, "[]", source_timeline=timeline)
+    assert manager_plan["source_timeline"]["fingerprints"] == (
+        timeline["fingerprints"])
+    assert chain._is_source_timeline(manager_timeline)
+    assert pathlib.Path(manager_timeline["video"]["path"]).is_file()
+    assert manager_timeline["recovery"]["video_archived"] is True
+    assert manager_timeline["audio"]["path"] == (
+        manager_timeline["video"]["path"])
+    assert (root / "h3_chains" / "timeline-consumers" /
+            "source_timeline.json").is_file()
+
+    promoted_plan = make_plan(
+        "timeline-promoted-source-track", "generated_audio")
+    source_binding = json.dumps([{
+        "binding_id": "original-song",
+        "label": "Original song",
+        "role": "source_track",
+        "node_id": "42",
+        "node_type": "LoadAudio",
+        "node_title": "Original song",
+        "output_slot": 0,
+        "output_type": "AUDIO",
+        "widget_name": "audio",
+        "original_value": path.name,
+    }])
+    original_input_root = chain._input_root
+    try:
+        chain._input_root = lambda: str(root)
+        promoted_plan, promoted_timeline = (
+            chain.MiniMaxH3ChainRunManager().passthrough(
+                promoted_plan, True, False, False, source_binding))
+    finally:
+        chain._input_root = original_input_root
+    assert chain._is_source_timeline(promoted_timeline)
+    assert promoted_timeline["video"] is None
+    assert promoted_timeline["audio"]["kind"] == "external_path"
+    assert promoted_timeline["recovery"]["source_route"] == (
+        "run_manager_source_track")
+    assert promoted_plan["source_timeline"]["fingerprints"] == (
+        promoted_timeline["fingerprints"])
+    studio_source = chain._register_plan_studio_source_previews(
+        promoted_plan, {"scenes": []})
+    assert studio_source["source_audio"]["available"] is True
+    assert studio_source["source_audio"]["timeline_available"] is True
+
+    manifest = chain._manifest_from_segments(prepared, [
+        {"index": 1, "id": "one", "delivered_frames": 22},
+        {"index": 2, "id": "two", "delivered_frames": 17},
+    ], True)
+    recovered = chain._source_timeline_from_metadata(manifest)
+    chain._validate_source_timeline_hash(
+        manifest["compatibility"], recovered, "test assemble")
+    assert manifest["source_timeline"]["fingerprints"] == (
+        timeline["fingerprints"])
+
+    segment_path = (
+        root / "h3_chains" / "timeline-consumers" / "segments" /
+        "clip_0001.mp4")
+    segment_path.parent.mkdir(parents=True, exist_ok=True)
+    segment_path.write_bytes(b"fake segment")
+    assembly_manifest = dict(manifest)
+    assembly_manifest["format"] = "h3_chain_manifest_v2"
+    assembly_manifest["segments"] = [dict(item) for item in manifest["segments"]]
+    for item in assembly_manifest["segments"]:
+        item["segment"] = chain._relative_output_path(str(segment_path))
+    original_validate_manifest = chain._validate_manifest
+    original_validate_prelude = chain._validate_prelude
+    original_metadata = chain._manifest_media_metadata
+    original_which = chain.shutil.which
+    original_ffmpeg = chain._run_ffmpeg
+    chain._validate_manifest = lambda value: value["segments"]
+    chain._validate_prelude = lambda _value: None
+    chain._manifest_media_metadata = lambda _value: {}
+    chain.shutil.which = lambda executable: (
+        "/fake/ffmpeg" if executable == "ffmpeg" else original_which(executable))
+
+    def fake_ffmpeg(command, timeout_seconds=None):
+        del timeout_seconds
+        if command[-1] == "-version":
+            return
+        pathlib.Path(command[-1]).write_bytes(b"assembled")
+
+    chain._run_ffmpeg = fake_ffmpeg
+    try:
+        assembled = chain.MiniMaxH3ChainAssemble().assemble(
+            assembly_manifest, "plan", "timeline_source", 96)
+    finally:
+        chain._validate_manifest = original_validate_manifest
+        chain._validate_prelude = original_validate_prelude
+        chain._manifest_media_metadata = original_metadata
+        chain.shutil.which = original_which
+        chain._run_ffmpeg = original_ffmpeg
+        chain._FFMPEG_PROBE_CACHE.clear()
+    assert pathlib.Path(assembled["result"][0]).is_file()
+
+    tensor_audio = chain._source_timeline_source_audio(timeline)
+    deferred = chain.MiniMaxH3SourceTimeline().build(
+        str(path), "", "ignore", 0, source_audio=tensor_audio)[0]
+    deferred_plan = make_plan("timeline-materialized")
+    deferred_prepared, materialized = chain._plan_with_source_timeline(
+        deferred_plan, deferred)
+    assert materialized["audio"]["kind"] == "external_path"
+    assert pathlib.Path(materialized["audio"]["path"]).is_file()
+    assert "value" not in deferred_prepared["source_timeline"]["audio"]
+    assert chain._source_timeline_from_recovery(
+        deferred_prepared["source_timeline"])["audio"]["kind"] == (
+            "external_path")
+
+    # A legacy AUDIO connected once at Loop Start is promoted to the same
+    # path-backed recovery contract without changing its released raw-audio
+    # fingerprint. Downstream nodes no longer need the tensor wire, while an
+    # old redundant wire remains valid when it carries the identical track.
+    legacy_plan = make_plan("legacy-audio-promoted")
+    legacy_started = chain.MiniMaxH3ChainLoopStart().start(
+        legacy_plan, 1, source_audio=tensor_audio)
+    legacy_state = legacy_started[1]
+    legacy_prepared = legacy_state["plan"]
+    legacy_timeline = legacy_state["source_timeline"]
+    legacy_hash = chain._audio_fingerprint(tensor_audio)
+    assert legacy_prepared["compatibility"]["source_audio_hash"] == (
+        legacy_hash)
+    assert "source_timeline_fingerprint" not in (
+        legacy_prepared["compatibility"])
+    assert legacy_timeline["audio"]["kind"] == "external_path"
+    assert legacy_timeline["recovery"][
+        "legacy_loop_start_source_audio_hash"] == legacy_hash
+    assert pathlib.Path(legacy_timeline["audio"]["path"]).is_file()
+    assert "source audio saved in run state" in legacy_started[2]
+    assert chain._canonical_source_reference_dependency(
+        legacy_prepared, 1, legacy_timeline, None) == (
+            chain._canonical_source_reference_dependency(
+                legacy_prepared, 1, None, tensor_audio))
+    legacy_current = chain.MiniMaxH3ChainCurrent().current(
+        legacy_state, tensor_audio)["result"]
+    assert tuple(legacy_current[12]["waveform"].shape) == (1, 1, 44000)
+    assert legacy_current[0]["current_source_reference_dependency"][
+        "route"] == "legacy_audio"
+
+    legacy_manifest = chain._manifest_from_segments(legacy_prepared, [
+        {"index": 1, "id": "one", "delivered_frames": 22},
+        {"index": 2, "id": "two", "delivered_frames": 17},
+    ], True)
+    legacy_recovered = chain._source_timeline_from_metadata(legacy_manifest)
+    chain._validate_source_timeline_hash(
+        legacy_manifest["compatibility"], legacy_recovered,
+        "legacy assembly recovery")
+    recovered_audio = chain._full_chain_selected_audio(
+        legacy_manifest, "source", None, None)
+    redundant_audio = chain._full_chain_selected_audio(
+        legacy_manifest, "source", None, tensor_audio)
+    assert int(recovered_audio["waveform"].shape[-1]) == 78000
+    assert torch.equal(
+        recovered_audio["waveform"], redundant_audio["waveform"])
+
+    # Checkpoint Manager must prefer the descriptor persisted with the
+    # selected revision, because Run Manager archived the user-facing Plan
+    # before Loop Start saw and materialized the legacy AUDIO wire.
+    manager_plan_path = root / "h3_chains" / "legacy-audio-promoted" / "plan.json"
+    manager_plan_path.write_text(json.dumps({
+        "plan_hash": legacy_prepared["plan_hash"],
+        "shots": [{"id": "one"}, {"id": "two"}],
+    }), encoding="utf-8")
+    manager_metadata = [{
+        "plan_hash": legacy_prepared["plan_hash"],
+        "compatibility": legacy_prepared["compatibility"],
+        "source_timeline": legacy_prepared["source_timeline"],
+        "segment": {
+            "index": index,
+            "delivered_frames": delivered,
+            "prompt_prefix": "",
+        },
+    } for index, delivered in ((1, 22), (2, 17))]
+    original_load_revision = chain._load_checkpoint_revision
+    original_validate_manifest = chain._validate_manifest
+    chain._load_checkpoint_revision = lambda _run, index, _revision, **_kwargs: (
+        manager_metadata[index - 1], "metadata.json")
+    chain._validate_manifest = lambda value: value["segments"]
+    try:
+        selected_manifest = chain._checkpoint_selection_manifest(json.dumps({
+            "run_name": "legacy-audio-promoted",
+            "lineage": [
+                {"scene": 1, "revision": "one"},
+                {"scene": 2, "revision": "two"},
+            ],
+        }))
+    finally:
+        chain._load_checkpoint_revision = original_load_revision
+        chain._validate_manifest = original_validate_manifest
+    assert selected_manifest["source_timeline"] == (
+        legacy_prepared["source_timeline"])
+
+assert chain.CHAIN_NODE_CLASS_MAPPINGS[
+    "MiniMaxH3TaggedMotionReferenceTimeline"] is (
+        chain.MiniMaxH3TaggedMotionReferenceTimeline)
+assert chain.CHAIN_NODE_CLASS_MAPPINGS[
+    "MiniMaxH3SourceTimelineScenePreview"] is (
+        chain.MiniMaxH3SourceTimelineScenePreview)
+
+print(
+    "Source Timeline consumers: Run Manager source-track promotion, Loop "
+    "Start state, Current Shot, Tagged Motion, both previews, manifest "
+    "recovery, and deferred-audio materialization pass")
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_source_timeline_unit_test.py b/ComfyUI-MiniMaxH3-Context-Loop/tests/_source_timeline_unit_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..3e71a406f8209e19eca514a171ef9425150ed9ed
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_source_timeline_unit_test.py
@@ -0,0 +1,213 @@
+#!/usr/bin/env python3
+"""The 0.5 Source Timeline stays lazy, aligned, and recovery-safe."""
+
+import importlib.util
+import json
+from fractions import Fraction
+import pathlib
+import shutil
+import sys
+import tempfile
+import types
+
+import av
+import numpy as np
+import torch
+
+
+ROOT = pathlib.Path(__file__).resolve().parents[1]
+PACKAGE = "h3_source_timeline_unit"
+
+folder_paths = types.ModuleType("folder_paths")
+folder_paths.get_output_directory = lambda: str(ROOT)
+folder_paths.get_temp_directory = lambda: str(ROOT)
+folder_paths.get_input_directory = lambda: str(ROOT)
+folder_paths.get_annotated_filepath = lambda value: str(value)
+sys.modules["folder_paths"] = folder_paths
+
+package = types.ModuleType(PACKAGE)
+package.__path__ = [str(ROOT)]
+sys.modules[PACKAGE] = package
+
+shared_nodes = types.ModuleType(PACKAGE + ".nodes")
+shared_nodes.MiniMaxH3MotionContext = object
+shared_nodes._claim_inline_patch_ownership = lambda _conditioning=None: "test patch owner"
+shared_nodes._prepare_native_guide_conditioning = lambda *args: None
+shared_nodes._resize = lambda *args: None
+shared_nodes._streams_from_latent = lambda *args: None
+sys.modules[shared_nodes.__name__] = shared_nodes
+
+spec = importlib.util.spec_from_file_location(
+    PACKAGE + ".chain_nodes", ROOT / "chain_nodes.py")
+chain = importlib.util.module_from_spec(spec)
+sys.modules[spec.name] = chain
+spec.loader.exec_module(chain)
+
+
+def write_fixture(path, frame_count=30, source_fps=25):
+    width = height = 64
+    sample_rate = 48000
+    sample_count = round(frame_count / source_fps * sample_rate)
+    container = av.open(str(path), mode="w")
+    video = container.add_stream("libx264rgb", rate=source_fps)
+    video.width = width
+    video.height = height
+    video.pix_fmt = "rgb24"
+    video.options = {"crf": "0", "preset": "ultrafast"}
+    audio = container.add_stream("pcm_f32le", rate=sample_rate)
+    audio.layout = "mono"
+    try:
+        for index in range(frame_count):
+            array = np.full(
+                (height, width, 3), index * 7, dtype=np.uint8)
+            frame = av.VideoFrame.from_ndarray(array, format="rgb24")
+            frame.pts = index
+            frame.time_base = Fraction(1, source_fps)
+            for packet in video.encode(frame):
+                container.mux(packet)
+        for packet in video.encode():
+            container.mux(packet)
+
+        waveform = np.linspace(
+            -0.75, 0.75, sample_count, dtype=np.float32).reshape(1, -1)
+        for start in range(0, sample_count, 2048):
+            stop = min(sample_count, start + 2048)
+            frame = av.AudioFrame.from_ndarray(
+                waveform[:, start:stop], format="fltp", layout="mono")
+            frame.sample_rate = sample_rate
+            frame.pts = start
+            frame.time_base = Fraction(1, sample_rate)
+            for packet in audio.encode(frame):
+                container.mux(packet)
+        for packet in audio.encode():
+            container.mux(packet)
+    finally:
+        container.close()
+
+
+with tempfile.TemporaryDirectory() as temporary:
+    path = pathlib.Path(temporary) / "source.mkv"
+    write_fixture(path)
+    node = chain.MiniMaxH3SourceTimeline()
+
+    timeline, status = node.build(
+        str(path), "", "auto", 10)
+    assert timeline["version"] == chain.SOURCE_TIMELINE_VERSION
+    assert timeline["kind"] == "source_timeline"
+    assert timeline["audio"]["kind"] == "embedded"
+    assert "waveform" not in timeline["audio"]
+    assert timeline["origin"]["skip_first_frames"] == 10
+    assert abs(timeline["origin"]["skip_seconds"] - 0.4) < 1e-9
+    assert timeline["extent"]["frame_count"] == 20
+    assert "lazy embedded audio" in status
+    assert len(timeline["fingerprints"]["timeline"]) == 64
+
+    video = chain._source_timeline_scene_video(timeline, 0, 5)
+    audio = chain._source_timeline_scene_audio(timeline, 0, 5)
+    assert tuple(video.shape) == (5, 64, 64, 3)
+    assert tuple(audio["waveform"].shape) == (1, 1, 10000)
+    for target_index, source_index in enumerate([10, 11, 12, 13, 14]):
+        expected = source_index * 7 / 255
+        assert abs(
+            float(video[target_index, 0, 0, 0]) - expected) < 1e-6
+    full_track = chain._source_timeline_source_audio(timeline)
+    assert tuple(full_track["waveform"].shape) == (1, 1, 40000)
+
+    recovery = chain._source_timeline_recovery_record(timeline)
+    json.dumps(recovery)
+    assert recovery["fingerprints"] == timeline["fingerprints"]
+    relocated_path = pathlib.Path(temporary) / "relocated.mkv"
+    shutil.copyfile(path, relocated_path)
+    relocated = chain._source_timeline_from_recovery(
+        recovery, video_path=str(relocated_path))
+    assert relocated["video"]["path"] == str(relocated_path)
+    assert relocated["audio"]["path"] == str(relocated_path)
+    assert relocated["fingerprints"] == timeline["fingerprints"]
+    relocated_video = chain._source_timeline_scene_video(relocated, 0, 5)
+    assert torch.equal(video, relocated_video)
+
+    external, external_status = node.build(
+        str(path), str(path), "ignore", 10)
+    assert external["audio"]["kind"] == "external_path"
+    assert "lazy external-path audio" in external_status
+    external_audio = chain._source_timeline_scene_audio(external, 0, 5)
+    assert tuple(external_audio["waveform"].shape) == (1, 1, 10000)
+    assert torch.allclose(
+        audio["waveform"], external_audio["waveform"], atol=1e-6)
+
+    deferred, deferred_status = node.build(
+        str(path), "", "ignore", 10, source_audio=full_track)
+    assert deferred["audio"]["kind"] == "deferred_tensor"
+    assert "deferred aligned AUDIO" in deferred_status
+    deferred_record = chain._source_timeline_recovery_record(deferred)
+    assert "value" not in deferred_record["audio"]
+    assert deferred_record["audio"]["requires_materialization"] is True
+    unresolved = chain._source_timeline_from_recovery(deferred_record)
+    assert unresolved["audio"]["kind"] == "deferred_tensor"
+    try:
+        chain._source_timeline_scene_audio(unresolved, 0, 5)
+    except ValueError as exc:
+        assert "must provide ComfyUI AUDIO" in str(exc)
+    else:
+        raise AssertionError("unmaterialized deferred audio was decoded")
+    restored = chain._source_timeline_from_recovery(
+        deferred_record, deferred_audio=full_track)
+    restored_audio = chain._source_timeline_scene_audio(restored, 0, 5)
+    assert tuple(restored_audio["waveform"].shape) == (1, 1, 10000)
+
+    # Independent 24 fps boundaries can differ by one PCM sample when an
+    # imported-video lead and extension soundtrack are recombined. That
+    # harmless quantization remainder is conformed, while a truly short
+    # extension remains an error.
+    quantized_extension = {
+        "waveform": torch.linspace(-0.5, 0.5, 1333).reshape(1, 1, -1),
+        "sample_rate": 8000,
+    }
+    imported_lead = {
+        "waveform": torch.full((1, 1, 333), 0.75),
+        "sample_rate": 8000,
+    }
+    recombined = chain._slice_audio_after_external_context(
+        quantized_extension, imported_lead, 5, 1, False)
+    assert int(recombined["waveform"].shape[-1]) == round(5 / 24 * 8000)
+    try:
+        chain._slice_audio_after_external_context({
+            "waveform": torch.zeros((1, 1, 1000)),
+            "sample_rate": 8000,
+        }, imported_lead, 5, 1, False)
+    except ValueError as exc:
+        assert "extension soundtrack" in str(exc)
+    else:
+        raise AssertionError("materially short extension audio was conformed")
+
+    wrong_audio = {
+        "waveform": torch.zeros_like(full_track["waveform"]),
+        "sample_rate": full_track["sample_rate"],
+    }
+    try:
+        chain._source_timeline_from_recovery(
+            deferred_record, deferred_audio=wrong_audio)
+    except ValueError as exc:
+        assert "does not match" in str(exc)
+    else:
+        raise AssertionError("mismatched recovered audio was accepted")
+
+    audio_only, audio_only_status = node.build(
+        "", str(path), "ignore", 0)
+    assert audio_only["video"] is None
+    assert audio_only["audio"]["kind"] == "external_path"
+    assert audio_only["extent"]["frame_count"] == 28
+    assert "audio-only" in audio_only_status
+
+    lazy = chain._source_timeline_to_lazy_motion_descriptor(timeline)
+    assert chain._is_lazy_motion_descriptor(lazy)
+    adapted = chain._source_timeline_from_lazy_motion_descriptor(lazy)
+    assert adapted["fingerprints"] == timeline["fingerprints"]
+    assert chain.CHAIN_NODE_CLASS_MAPPINGS[
+        "MiniMaxH3SourceTimeline"] is chain.MiniMaxH3SourceTimeline
+    assert node.RETURN_TYPES == (chain.SOURCE_TIMELINE_TYPE, "STRING")
+
+print(
+    "source timeline: lazy embedded/external AV windows, native-frame origin, "
+    "audio-only extent, deferred AUDIO recovery, content-verified relinking, "
+    "legacy adaptation, and typed node registration pass")
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_studio_branch_switch_js_test.mjs b/ComfyUI-MiniMaxH3-Context-Loop/tests/_studio_branch_switch_js_test.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..dd759380482868a588733961514a9f9a6acbb968
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_studio_branch_switch_js_test.mjs
@@ -0,0 +1,66 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import vm from "node:vm";
+import {matchingStudioCheckpoint, studioCheckpointSignature} from "../web/h3_chain_plan_studio_core.mjs";
+
+const source = fs.readFileSync(new URL("../web/h3_chain_plan_studio.js", import.meta.url), "utf8");
+const functions = ["refreshCheckpointsNow", "refreshTimelineCheckpoints", "updateTimelineCheckpointCard"];
+const handlers = functions.map(name => {
+    const match = source.match(new RegExp(`^    (?:async )?function ${name}\\([^]*?^    }$`, "m"));
+    assert.ok(match, name);
+    return match[0];
+}).join("\n");
+const rows = [1, 2, 3].map(scene => ({id:`scene_${scene}`, deliveredFrames:100}));
+const oldRecords = rows.map((row, index) => ({
+    scene:index + 1, scene_id:row.id, delivered_frames:100, ready:true,
+    revision:`old-${index}`, video:`old-${index}.mp4`,
+}));
+const cards = oldRecords.map((record, index) => {
+    const classes = new Set(["h3studio-rendered"]);
+    const card = {
+        dataset:{sceneIndex:index, checkpointThumbnail:record.video},
+        classes, classList:{toggle(name, on) { on ? classes.add(name) : classes.delete(name); }},
+        querySelector() { return card.thumbnail; },
+        prepend(image) { card.thumbnail = image; },
+    };
+    card.thumbnail = {remove() { card.thumbnail = null; }};
+    return card;
+});
+const state = {
+    disposed:false, checkpoints:new Map(oldRecords.map(record => [record.scene, record])),
+    checkpointSignature:studioCheckpointSignature("run", oldRecords),
+    checkpointError:"", checkpointToken:0, editorialEditEpoch:0,
+    plan:{shots:rows}, timelineHost:{querySelectorAll:() => cards},
+    view:"player", player:{paused:false, dataset:{source:"old-2.mp4"}},
+    playerIndex:2, playerAudio:{dataset:{source:"old-2.wav"}},
+};
+let response = {checkpoints:[oldRecords[0], {...oldRecords[1], revision:"new-1"}]};
+let panelRenders = 0;
+const context = vm.createContext({
+    state, Map, URLSearchParams, studioCheckpointSignature, matchingStudioCheckpoint,
+    runName:() => "run", timing:() => ({shots:rows}),
+    api:{fetchApi:async () => ({ok:true, json:async () => response})},
+    applyEditorialPayload:() => false, cacheStudioPresentation(){},
+    renderStatus(){}, renderTimeline(){},
+    renderPanel() { panelRenders += 1; },
+    checkpointThumbnailUrl:(_index, record) => record?.video ?? "",
+    playerCheckpoint:index => state.checkpoints.get(index + 1),
+    videoUrl:video => video,
+});
+vm.runInContext(handlers, context);
+await context.refreshCheckpointsNow();
+assert.equal(state.checkpoints.size, 2);
+assert.equal(state.checkpoints.get(2).revision, "new-1",
+    "metadata-only changes refresh the actual checkpoint map");
+assert.equal(cards[2].thumbnail, null, "inactive tail thumbnail is removed");
+assert.equal(cards[2].classes.has("h3studio-rendered"), false,
+    "inactive tail must not look rendered on the selected branch");
+assert.equal(cards[2].dataset.checkpointThumbnail, undefined);
+assert.equal(panelRenders, 1, "old video/audio is replaced even during playback");
+assert.ok(cards[0].thumbnail, "unchanged selected clips keep their preview");
+assert.equal(state.plan.shots.length, 3, "authored scene slots are not deleted");
+response = {checkpoints:[]};
+await context.refreshCheckpointsNow();
+assert.equal(state.checkpoints.size, 0);
+assert.ok(cards.every(card => card.thumbnail == null));
+console.log("Studio branch switch: inactive thumbnails, playing media, shared-media revisions and Plan preservation pass");
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_studio_empty_scene_seek_js_test.mjs b/ComfyUI-MiniMaxH3-Context-Loop/tests/_studio_empty_scene_seek_js_test.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..52cc2b3173a688009bf41827337b6d315483d93d
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_studio_empty_scene_seek_js_test.mjs
@@ -0,0 +1,134 @@
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import vm from "node:vm";
+import {
+    locateStudioTimelineSegment, studioEditorialSceneStartSeconds,
+    studioPlayerSegmentClock, studioSourceAudioSecond, studioSourceSecond,
+    studioTimelineSegments,
+} from "../web/h3_chain_plan_studio_core.mjs";
+
+// Exercise the actual seek/audio-mix/source-clock handlers without a server,
+// media generation or project writes. Browser timeupdate follows the seek.
+const source = fs.readFileSync(new URL("../web/h3_chain_plan_studio.js", import.meta.url), "utf8");
+function handler(name) {
+    const match = source.match(new RegExp(`^    function ${name}\\([^]*?^    }$`, "m"));
+    assert.ok(match, name);
+    return match[0];
+}
+function closure(name) {
+    const match = source.match(new RegExp(`^        const ${name} = [^]*?^        };$`, "m"));
+    assert.ok(match, name);
+    return match[0];
+}
+function media() {
+    const listeners = new Map();
+    return {
+        dataset:{}, currentTime:0, duration:300, playbackRate:1, paused:true,
+        isConnected:true,
+        pause() { this.paused = true; },
+        play() { this.paused = false; return Promise.resolve(); },
+        removeAttribute(name) { delete this[name]; },
+        load() { this.currentTime = 0; },
+        addEventListener(name, callback) {
+            const list = listeners.get(name) ?? [];
+            list.push(callback); listeners.set(name, list);
+        },
+        metadata() {
+            const callbacks = listeners.get("loadedmetadata") ?? [];
+            listeners.delete("loadedmetadata");
+            for (const callback of callbacks) callback();
+        },
+    };
+}
+const rows = [
+    {id:"written", deliveredFrames:2311},
+    {id:"no_video", deliveredFrames:306},
+    {id:"rendered", deliveredFrames:240},
+];
+const segments = studioTimelineSegments(rows, [], 3600);
+const model = {result:{shots:rows}, segments, totalSeconds:150};
+const video = media();
+const generatedAudio = media();
+const sourceVideo = media();
+const sourceTimelineAudio = media();
+const descriptor = {seek_seconds:2, available_duration_seconds:300};
+let hasSourceAudio = true;
+const slider = {}; const clock = {};
+const state = {
+    plan:{shots:rows}, active:0, playerIndex:0, playerSegmentKey:"scene:0",
+    timelinePosition:0, player:video, playerAudio:generatedAudio,
+    sourcePlayer:sourceVideo, sourceAudioPlayer:sourceTimelineAudio,
+    playerSlider:slider,
+};
+let redLine = null; let subtitlePosition = null;
+const generatedToggle = {checked:true, dispatchEvent() { context.applyAudioMix(); }};
+const context = vm.createContext({
+    state, video, generatedAudio, sourceVideo, sourceTimelineAudio, slider, clock,
+    generatedToggle, sourceToggle:{checked:true}, motionToggle:{checked:false},
+    Event, FPS:24, timelineModel:() => model, timing:() => model.result,
+    locateStudioTimelineSegment, studioEditorialSceneStartSeconds,
+    studioPlayerSegmentClock, studioSourceAudioSecond, studioSourceSecond,
+    sourceAudio:() => hasSourceAudio ? descriptor : null,
+    sourceAudioUrl:() => "source.wav", sourceAudioMuted:() => false,
+    sourceReference:() => null, sourcePreviewUrl:() => "",
+    playerCheckpoint:index => index === 1 ? null : {video:`scene_${index}.mp4`},
+    videoUrl:value => value, formatClock:value => String(value),
+    root:{querySelector:selector => selector === ".h3studio-audio-generated" ? generatedToggle : null,
+        querySelectorAll:() => []},
+    persistView(){}, renderSourceTimeline(){}, renderSourceAudioTimeline(){},
+    updateTimelineSelection(){}, revealActiveTimelineScene(){}, publishActiveScene(){},
+    applyAudioVolumes(){}, synchronizeGeneratedAudio(){},
+    positionTimelinePlayhead:value => { redLine = value; },
+    updateSubtitleOverlay:value => { subtitlePosition = value; },
+});
+vm.runInContext([
+    handler("seekTimeline"),
+    ...["playerTimelineSecond", "synchronizeSourceTimelineAudio", "updateTransportPosition",
+        "sourceTimelineSecond", "refreshSourceTransport", "applyAudioMix"].map(closure),
+    "globalThis.applyAudioMix = applyAudioMix;",
+    "globalThis.refreshSourceTransport = refreshSourceTransport;",
+    "globalThis.synchronizeSourceTimelineAudio = synchronizeSourceTimelineAudio;",
+    "globalThis.playerTimelineSecond = playerTimelineSecond;",
+].join("\n"), context);
+
+function assertPosition(target, label) {
+    assert.equal(state.timelinePosition, target, label);
+    assert.equal(Number(slider.value), target, `${label}: slider`);
+    assert.equal(redLine, target, `${label}: red playhead`);
+    assert.equal(subtitlePosition, target, `${label}: subtitles`);
+}
+function seekAndLoad(target) {
+    context.seekTimeline(target);
+    video.metadata(); sourceTimelineAudio.metadata();
+    // canplay and monitor toggles both use this default synchronization clock.
+    context.synchronizeSourceTimelineAudio(false);
+    if (hasSourceAudio) context.refreshSourceTransport();
+}
+
+seekAndLoad(100.5);
+assertPosition(100.5, "an unrendered scene retains the clicked timeline position");
+assert.equal(sourceTimelineAudio.currentTime, 102.5, "source offset is preserved");
+assert.equal(state.active, 1);
+// Repeated seeks and toggling audio must not reset a media-less video to zero.
+seekAndLoad(105);
+context.applyAudioMix(); context.refreshSourceTransport();
+assertPosition(105, "monitor changes preserve an unrendered scene's position");
+sourceTimelineAudio.currentTime = 108;
+context.refreshSourceTransport();
+context.applyAudioMix(); context.refreshSourceTransport();
+assertPosition(106, "source playback remains the clock when no video exists");
+
+seekAndLoad(115);
+assertPosition(115, "rendered scenes still use the local video clock");
+const renderedStart = segments.find(item => item.sceneIndex === 2 && item.kind === "scene").startSeconds;
+video.currentTime = 3;
+context.synchronizeSourceTimelineAudio(false);
+assert.equal(sourceTimelineAudio.currentTime, renderedStart + 3 + descriptor.seek_seconds);
+
+seekAndLoad(135);
+assertPosition(135, "black editorial gaps preserve the absolute position too");
+hasSourceAudio = false;
+seekAndLoad(101);
+assert.equal(context.playerTimelineSecond(), 101, "no video and no audio still has a timeline clock");
+assertPosition(101, "silent unrendered scene remains seekable");
+console.log("Studio seek: unrendered scenes, source audio, monitor changes, video and black gaps pass");
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_tokenizer_compat_unit_test.py b/ComfyUI-MiniMaxH3-Context-Loop/tests/_tokenizer_compat_unit_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..185fec006c427077b01513dba2f8325fde52f7f1
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_tokenizer_compat_unit_test.py
@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+
+import importlib.util
+from pathlib import Path
+from types import SimpleNamespace
+
+
+ROOT = Path(__file__).resolve().parents[1]
+SPEC = importlib.util.spec_from_file_location(
+    "h3_tokenizer_compat", ROOT / "tokenizer_compat.py")
+compat = importlib.util.module_from_spec(SPEC)
+SPEC.loader.exec_module(compat)
+
+
+class FakeTokenizerBackend:
+    def __init__(self):
+        self.vocab = {"base": 151668}
+        self.calls = []
+
+    def add_special_tokens(self, value):
+        self.calls.append(value)
+        for token in value["additional_special_tokens"]:
+            if token not in self.vocab:
+                self.vocab[token] = max(self.vocab.values()) + 1
+
+    def get_vocab(self):
+        return dict(self.vocab)
+
+
+class FakeQwenTokenizer:
+    def __init__(self, *args, **kwargs):
+        self.args = args
+        self.kwargs = kwargs
+        self.tokenizer = FakeTokenizerBackend()
+        self.inv_vocab = {151668: "base"}
+
+
+class FakeMiniMaxH3Tokenizer:
+    pass
+
+
+legacy = SimpleNamespace(
+    Qwen3VLSDTokenizer=FakeQwenTokenizer,
+    MiniMaxH3Tokenizer=FakeMiniMaxH3Tokenizer,
+)
+installed = compat.install_minimax_tokenizer_compat(legacy)
+assert installed["state"] == "compat"
+assert legacy.Qwen3VLSDTokenizer is not FakeQwenTokenizer
+assert issubclass(legacy.Qwen3VLSDTokenizer, FakeQwenTokenizer)
+
+tokenizer = legacy.Qwen3VLSDTokenizer("path", option=True)
+assert tokenizer.args == ("path",)
+assert tokenizer.kwargs == {"option": True}
+assert tokenizer.tokenizer.calls == [{
+    "additional_special_tokens": list(compat.MINIMAX_EXTRA_TOKENS),
+}]
+for token, expected_id in compat.MINIMAX_EXTRA_TOKEN_IDS.items():
+    assert tokenizer.tokenizer.get_vocab()[token] == expected_id
+    assert tokenizer.inv_vocab[expected_id] == token
+
+patched_class = legacy.Qwen3VLSDTokenizer
+again = compat.install_minimax_tokenizer_compat(legacy)
+assert again["state"] == "compat"
+assert legacy.Qwen3VLSDTokenizer is patched_class
+
+native_qwen = type("NativeMiniMaxQwen", (), {})
+native = SimpleNamespace(
+    Qwen3VLSDTokenizer=FakeQwenTokenizer,
+    MiniMaxH3Tokenizer=FakeMiniMaxH3Tokenizer,
+    MiniMaxQwenSDTokenizer=native_qwen,
+)
+native_status = compat.install_minimax_tokenizer_compat(native)
+assert native_status["state"] == "native"
+assert native.Qwen3VLSDTokenizer is FakeQwenTokenizer
+
+incompatible = SimpleNamespace(Qwen3VLSDTokenizer=object)
+assert compat.install_minimax_tokenizer_compat(incompatible)["state"] == "unavailable"
+
+print("MiniMax H3 tokenizer: native detection and guarded PR #15808 backport pass")
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_transition_policy_unit_test.py b/ComfyUI-MiniMaxH3-Context-Loop/tests/_transition_policy_unit_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..22fad2fcd801928dd7a22e4c879dbc24a822704a
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_transition_policy_unit_test.py
@@ -0,0 +1,650 @@
+#!/usr/bin/env python3
+"""Semantic incoming-transition presets resolve to generation fields."""
+
+import importlib.util
+import json
+import pathlib
+import sys
+import types
+
+import torch
+
+
+ROOT = pathlib.Path(__file__).resolve().parents[1]
+PACKAGE = "h3_transition_policy_unit"
+
+folder_paths = types.ModuleType("folder_paths")
+folder_paths.get_output_directory = lambda: str(ROOT)
+folder_paths.get_temp_directory = lambda: str(ROOT)
+folder_paths.get_input_directory = lambda: str(ROOT)
+folder_paths.get_annotated_filepath = lambda value: str(value)
+sys.modules["folder_paths"] = folder_paths
+
+package = types.ModuleType(PACKAGE)
+package.__path__ = [str(ROOT)]
+sys.modules[PACKAGE] = package
+
+shared_nodes = types.ModuleType(PACKAGE + ".nodes")
+shared_nodes.MiniMaxH3MotionContext = object
+shared_nodes._claim_inline_patch_ownership = lambda _conditioning=None: "test patch owner"
+shared_nodes._prepare_native_guide_conditioning = lambda value: value
+shared_nodes._resize = lambda *args: None
+shared_nodes._streams_from_latent = lambda *args: None
+sys.modules[shared_nodes.__name__] = shared_nodes
+
+spec = importlib.util.spec_from_file_location(
+    PACKAGE + ".chain_nodes", ROOT / "chain_nodes.py")
+chain = importlib.util.module_from_spec(spec)
+sys.modules[spec.name] = chain
+spec.loader.exec_module(chain)
+
+
+PLAN_JSON = json.dumps({
+    "shots": [
+        {"id": "one", "prompt": "First scene.", "length": 73},
+        {"id": "two", "prompt": "Second scene.", "length": 73},
+    ],
+})
+
+
+def make_plan(policy=None, *, encode_mode="video", anchor_mode="head",
+              context_length=22, continuation_mode="guide"):
+    combined = None
+    if policy is not None:
+        combined = chain._contract_compose_chain_policy(
+            chain.migrate_legacy_audio_mode("generated_audio"), policy,
+            audio_context_length=int(policy["context_length"]))
+    return chain._normalize_plan(
+        PLAN_JSON, "transition-policy-test", 64, 64, context_length,
+        encode_mode, anchor_mode, "disabled", "generated_audio", 22,
+        3.0, 8, 7, 18, "model-stack", 0, continuation_mode,
+        combined)
+
+
+def build_transition(preset="guide", expert_override=False,
+                     expert_continuation_mode="guide",
+                     expert_context_length=22):
+    policy = chain._contract_transition_policy(
+        preset, expert_override=expert_override,
+        continuation_mode=expert_continuation_mode,
+        context_length=expert_context_length)
+    status = chain._transition_policy_display({"transition_policy": policy})
+    if policy["expert_override"]:
+        status += "; expert override"
+    elif policy["preset"] in ("tone_guide", "detail_guide"):
+        status += "; experimental preset; published baseline 22f"
+    elif policy["preset"] == "detail_av":
+        status += "; experimental preset; clean-boundary latent taper v2 at 39f"
+    elif policy["preset"] == "drift_av":
+        status += (
+            "; experimental preset; schedule-matched 8+4 mask at 39f; "
+            "20-step baseline")
+    elif policy["preset"] == "color_drift_av":
+        status += (
+            "; experimental preset; schedule-matched 8+4 mask plus "
+            "scene-one VAE delta at 39f; 20-step baseline")
+    else:
+        status += "; tested preset"
+    return (policy, policy["continuation_mode"],
+            int(policy["context_length"]), status)
+
+
+preset_choices = (
+    "cut", "guide", "tone_guide", "latent_guide", "detail_guide",
+    "detail_av", "drift_av", "color_drift_av", "hard_av", "soft_av")
+assert "soft_av" in preset_choices
+assert "detail_av" in preset_choices
+assert "drift_av" in preset_choices
+assert "color_drift_av" in preset_choices
+assert "audio_feather_av" not in preset_choices
+expected = {
+    "cut": ("guide", 0),
+    "guide": ("guide", 22),
+    "tone_guide": ("tone_carry_guide", 22),
+    "latent_guide": ("latent_guide", 22),
+    "detail_guide": ("tapered_guide", 22),
+    "detail_av": ("tapered_av", 39),
+    "drift_av": ("drift_control_av", 39),
+    "color_drift_av": ("color_stable_drift_av", 39),
+    "hard_av": ("masked_av", 39),
+    "soft_av": ("audio_feathered_av", 39),
+    "audio_feather_av": ("audio_feathered_av", 39),
+}
+for preset, (mode, context) in expected.items():
+    policy, output_mode, output_context, status = build_transition(preset)
+    assert policy["preset"] == preset
+    assert policy["continuation_mode"] == mode
+    assert policy["context_length"] == context
+    assert policy["expert_override"] is False
+    assert output_mode == mode and output_context == context
+    assert " -> " in status
+    if preset in (
+            "tone_guide", "detail_guide", "detail_av", "drift_av",
+            "color_drift_av"):
+        assert "experimental preset" in status
+    else:
+        assert "tested preset" in status
+
+soft_status = build_transition("soft_av")[3]
+assert soft_status.startswith("Soft AV -> Audio-Feathered AV + 39 frames")
+hard_status = build_transition("hard_av")[3]
+assert hard_status.startswith("Hard AV -> Masked AV + 39 frames")
+detail_av_status = build_transition("detail_av")[3]
+assert detail_av_status.startswith("Detail AV -> Tapered AV + 39 frames")
+assert "clean-boundary latent taper v2" in detail_av_status
+drift_av_status = build_transition("drift_av")[3]
+assert drift_av_status.startswith(
+    "Drift-Control AV -> Drift-Control AV + 39 frames")
+assert "schedule-matched 8+4 mask" in drift_av_status
+color_drift_status = build_transition("color_drift_av")[3]
+assert color_drift_status.startswith(
+    "Color-Stable Drift AV -> Color-Stable Drift AV + 39 frames")
+assert "scene-one VAE delta" in color_drift_status
+audio_feather_status = build_transition("audio_feather_av")[3]
+assert audio_feather_status.startswith(
+    "Audio Feather AV (legacy alias) -> Audio-Feathered AV + 39 frames")
+
+legacy = make_plan(None, context_length=39, continuation_mode="masked_av")
+assert "transition_policy" not in legacy["compatibility"]
+assert legacy["compatibility"]["context_length"] == 39
+assert legacy["compatibility"]["continuation_mode"] == "masked_av"
+assert chain._transition_policy_summary(legacy) == "hard_av/masked_av/39f"
+
+cut_policy = build_transition("cut")[0]
+cut = make_plan(cut_policy)
+assert cut["compatibility"]["context_length"] == 0
+assert cut["compatibility"].get("continuation_mode", "guide") == "guide"
+assert cut["compatibility"]["transition_policy"] == cut_policy
+assert chain._plan_context_storage_length(cut) == 0
+assert cut["shots"][1]["generation_start_frame"] == 73
+assert cut["shots"][1]["delivered_frames"] == 73
+assert cut["total_delivered_frames"] == 146
+assert "context=0/guide" in cut["summary"]
+assert "transition=cut/guide/0f" in cut["summary"]
+
+hard_policy = build_transition("hard_av")[0]
+hard = make_plan(hard_policy, context_length=22, continuation_mode="guide")
+assert hard["compatibility"]["context_length"] == 39
+assert hard["compatibility"]["continuation_mode"] == "masked_av"
+assert hard["shots"][1]["generation_start_frame"] == 34
+assert hard["shots"][1]["delivered_frames"] == 34
+assert hard["total_delivered_frames"] == 107
+
+expert, expert_mode, expert_context, expert_status = build_transition(
+    "guide", True, "feathered_av", 39)
+assert expert_mode == "feathered_av" and expert_context == 39
+assert expert["preset"] == "guide"
+assert expert["expert_override"] is True
+assert "expert override" in expert_status
+expert_plan = make_plan(expert)
+assert expert_plan["compatibility"]["context_length"] == 39
+assert expert_plan["compatibility"]["continuation_mode"] == "feathered_av"
+
+migrated_expert, migrated_mode, migrated_context, migrated_status = build_transition(
+    "soft_av", True, "feathered_av_rgb", 39)
+assert migrated_mode == "feathered_av" and migrated_context == 39
+assert migrated_expert["expert_override"] is True
+assert "Feathered AV" in migrated_status
+
+try:
+    build_transition("guide", True, "masked_av", 1)
+except ValueError as exc:
+    assert "at least 5" in str(exc)
+else:
+    raise AssertionError("one-frame hard AV expert override was accepted")
+
+for off_grid in (5, 22, 56, 73):
+    transition = build_transition(
+        "soft_av", True, "audio_feathered_av", off_grid)[0]
+    source_driven = chain._contract_compose_chain_policy(
+        chain.migrate_legacy_audio_mode("source_track"), transition,
+        audio_context_length=off_grid)
+    assert source_driven["transition_policy"]["context_length"] == off_grid
+    try:
+        chain._contract_compose_chain_policy(
+            chain.migrate_legacy_audio_mode("generated_audio"), transition,
+            audio_context_length=off_grid)
+    except ValueError as exc:
+        assert "exact shared" in str(exc)
+    else:
+        raise AssertionError(
+            "off-grid AV generated-audio carry %d was accepted" % off_grid)
+
+try:
+    build_transition("detail_av", True, "tapered_av", 90)
+except ValueError as exc:
+    assert "exactly 39" in str(exc)
+else:
+    raise AssertionError("Detail AV accepted a non-v2 90-frame context")
+
+try:
+    build_transition("drift_av", True, "drift_control_av", 90)
+except ValueError as exc:
+    assert "exactly 39" in str(exc)
+else:
+    raise AssertionError("Drift-Control AV accepted a non-v1 90-frame context")
+
+try:
+    build_transition(
+        "color_drift_av", True, "color_stable_drift_av", 90)
+except ValueError as exc:
+    assert "exactly 39" in str(exc)
+else:
+    raise AssertionError(
+        "Color-Stable Drift AV accepted a non-v1 90-frame context")
+
+tapered_expert, tapered_mode, tapered_context, _ = build_transition(
+    "detail_guide", True, "tapered_guide", 39)
+assert tapered_mode == "tapered_guide" and tapered_context == 39
+assert tapered_expert["expert_override"] is True
+
+# The tuned 22-frame recipe keeps the Guide's luma/mouth structure intact,
+# uses a milder chroma treatment, and reaches a completely clean final frame.
+# The predecessor remains immutable and only the requested tail is returned.
+assert chain._tapered_guide_alpha(0, 22) == 0.30
+assert chain._tapered_guide_alpha(13, 22) == 0.30
+assert abs(chain._tapered_guide_alpha(14, 22) - 0.2625) < 1e-9
+assert abs(chain._tapered_guide_alpha(20, 22) - 0.0375) < 1e-9
+assert chain._tapered_guide_alpha(21, 22) == 0.0
+assert chain._tapered_guide_alpha(30, 39) == 0.30
+assert abs(chain._tapered_guide_alpha(31, 39) - 0.2625) < 1e-9
+assert chain._tapered_guide_alpha(38, 39) == 0.0
+source = torch.linspace(
+    0.08, 0.92, 45 * 19 * 31 * 3, dtype=torch.float32,
+).reshape(45, 19, 31, 3)
+source_copy = source.clone()
+noisy_39_a = chain._tapered_guide_context(source, 39, 730002)
+noisy_39_b = chain._tapered_guide_context(source, 39, 730002)
+noisy_39_c = chain._tapered_guide_context(source, 39, 730003)
+assert tuple(noisy_39_a.shape) == (39, 19, 31, 3)
+assert torch.equal(source, source_copy)
+assert torch.equal(noisy_39_a, noisy_39_b)
+assert not torch.equal(noisy_39_a, noisy_39_c)
+weights = torch.tensor(chain._TAPERED_GUIDE_LUMA)
+assert torch.allclose(
+    torch.sum(noisy_39_a * weights, dim=-1),
+    torch.sum(source[-39:] * weights, dim=-1),
+    atol=2e-6,
+)
+assert not torch.equal(noisy_39_a[0], source[-39])
+assert torch.equal(noisy_39_a[-1], source[-1])
+assert float(noisy_39_a.min()) >= 0.0
+assert float(noisy_39_a.max()) <= 1.0
+
+captured = {}
+
+
+class CapturingMotionContext:
+    def apply(self, **kwargs):
+        captured.update(kwargs)
+        return ("tapered-conditioning", int(kwargs["context_length"]))
+
+
+original_motion_context = chain.MiniMaxH3MotionContext
+chain.MiniMaxH3MotionContext = CapturingMotionContext
+try:
+    tapered_plan = make_plan(tapered_expert)
+    original_latent = {"samples": [torch.zeros(1), torch.zeros(1)]}
+    result = chain.MiniMaxH3ChainContext().apply(
+        state={
+            "index": 2,
+            "plan": tapered_plan,
+            "previous_frames": source,
+            "previous_latent": original_latent,
+            "segments": [],
+        },
+        conditioning="stock-conditioning",
+        vae=object(),
+        latent="target-latent",
+    )
+finally:
+    chain.MiniMaxH3MotionContext = original_motion_context
+
+assert result == ("tapered-conditioning", 39, True, "target-latent", None)
+assert captured["context_length"] == 39
+assert tuple(captured["context_frames"].shape) == (39, 19, 31, 3)
+assert not torch.equal(captured["context_frames"], source[-39:])
+assert captured["context_latent"] is original_latent
+assert captured["video_context_latent"] is None
+
+tone_policy = build_transition("tone_guide")[0]
+tone_curve = {
+    "version": "h3_guide_tone_carry_v1",
+    "points": [[0.0, 0.0], [0.25, 0.27], [0.75, 0.77], [1.0, 1.0]],
+}
+captured.clear()
+chain.MiniMaxH3MotionContext = CapturingMotionContext
+try:
+    tone_plan = make_plan(tone_policy)
+    tone_result = chain.MiniMaxH3ChainContext().apply(
+        state={
+            "index": 2,
+            "plan": tone_plan,
+            "previous_frames": source,
+            "previous_latent": original_latent,
+            "segments": [{"guide_tone_carry": tone_curve}],
+        },
+        conditioning="stock-conditioning",
+        vae=object(),
+        latent="target-latent",
+    )
+finally:
+    chain.MiniMaxH3MotionContext = original_motion_context
+
+assert tone_result == (
+    "tapered-conditioning", 22, True, "target-latent", None)
+expected_tone = chain._apply_guide_tone_carry(source, tone_curve)
+assert torch.allclose(captured["context_frames"], expected_tone)
+assert float(captured["context_frames"].mean()) > float(source.mean())
+assert captured["video_context_latent"] is None
+assert captured["context_latent"] is original_latent
+
+# The detector stores a direct curve from the raw generated scene to the RGB
+# Guide it actually received. The clean first frame followed by a four-level
+# exposure step mirrors the real H3 boundary this feature was designed for.
+guide_gradient = torch.linspace(
+    0.03, 0.73, 32, dtype=torch.float32).reshape(1, 1, 32, 1)
+guide_gradient = guide_gradient.expand(1, 32, 32, 3).contiguous()
+guide_context = guide_gradient.repeat(8, 1, 1, 1)
+guide_generated = torch.cat((
+    guide_gradient,
+    torch.clamp(guide_gradient - (4.0 / 255.0), 0.0, 1.0).repeat(3, 1, 1, 1),
+), dim=0)
+detected_tone = chain._detect_guide_tone_carry(
+    guide_context, guide_generated)
+assert detected_tone is not None
+assert detected_tone["version"] == "h3_guide_tone_carry_v1"
+assert detected_tone["start_frame"] == 1
+corrected_guide = chain._apply_guide_tone_carry(
+    guide_generated, detected_tone)
+assert float(corrected_guide[-1].mean()) > float(guide_generated[-1].mean())
+
+latent_policy = build_transition("latent_guide")[0]
+captured.clear()
+chain.MiniMaxH3MotionContext = CapturingMotionContext
+try:
+    latent_plan = make_plan(latent_policy)
+    latent_result = chain.MiniMaxH3ChainContext().apply(
+        state={
+            "index": 2,
+            "plan": latent_plan,
+            "previous_frames": source,
+            "previous_latent": original_latent,
+            "segments": [],
+        },
+        conditioning="stock-conditioning",
+        vae=object(),
+        latent="target-latent",
+    )
+finally:
+    chain.MiniMaxH3MotionContext = original_motion_context
+
+assert latent_result == (
+    "tapered-conditioning", 22, True, "target-latent", None)
+assert captured["video_context_latent"] is original_latent
+assert captured["context_latent"] is original_latent
+
+# Drift-Control AV validates its MODEL path before scene 1 spends sampler time,
+# then patches only the active continuation scene after the hard AV prefix is
+# prepared. Other modes retain the same appended MODEL passthrough output.
+drift_policy = build_transition("drift_av")[0]
+drift_plan = make_plan(drift_policy)
+drift_plan["shots"][1]["steps"] = 20
+masked_stub = types.ModuleType(PACKAGE + ".masked_context")
+masked_stub._require_h3_mask_support = lambda: True
+masked_calls = []
+
+
+def apply_masked_stub(**kwargs):
+    masked_calls.append(kwargs)
+    return (
+        "drift-conditioning",
+        {"samples": [
+            torch.zeros((1, 16, 12, 2, 2)),
+            torch.zeros((1, 32, 2, 65)),
+        ]},
+        39,
+    )
+
+
+masked_stub.apply_masked_prefix = apply_masked_stub
+drift_stub = types.ModuleType(PACKAGE + ".drift_control")
+drift_calls = []
+
+
+def mark_drift_latent(latent, prefix_steps):
+    marked = dict(latent)
+    marked["drift_prefix_steps"] = int(prefix_steps)
+    return marked
+
+
+def drift_prefix_steps(latent):
+    return int(latent["drift_prefix_steps"])
+
+
+def install_drift_model(
+        model, _latent, prefix_steps, schedule_override=None):
+    drift_calls.append((model, prefix_steps, schedule_override))
+    return ("patched-model", model, prefix_steps)
+
+
+drift_stub.mark_drift_control_latent = mark_drift_latent
+drift_stub.drift_control_latent_prefix_steps = drift_prefix_steps
+drift_stub.install_drift_control_av_model = install_drift_model
+sys.modules[masked_stub.__name__] = masked_stub
+sys.modules[drift_stub.__name__] = drift_stub
+try:
+    try:
+        chain.MiniMaxH3ChainContext().apply(
+            state={"index": 1, "plan": drift_plan},
+            conditioning="stock-conditioning",
+            vae=object(),
+            latent="target-latent",
+        )
+    except ValueError as exc:
+        assert "connect it to Chain Context" in str(exc)
+    else:
+        raise AssertionError(
+            "Drift-Control AV accepted a disconnected MODEL path")
+
+    first_result = chain.MiniMaxH3ChainContext().apply(
+        state={"index": 1, "plan": drift_plan},
+        conditioning="stock-conditioning",
+        vae=object(),
+        latent="target-latent",
+        model="h3-model",
+    )
+    assert first_result == (
+        "stock-conditioning", 0, False, "target-latent", "h3-model")
+    full_sigmas = torch.tensor([1.0, 0.8, 0.5, 0.2, 0.0])
+    split_first_result = chain.MiniMaxH3ChainContext().apply(
+        state={"index": 1, "plan": drift_plan},
+        conditioning="stock-conditioning",
+        vae=object(),
+        latent="target-latent",
+        drift_sigmas=full_sigmas,
+    )
+    assert split_first_result == (
+        "stock-conditioning", 0, False, "target-latent", None)
+    second_state = {
+            "index": 2,
+            "plan": drift_plan,
+            "previous_frames": source,
+            "previous_latent": original_latent,
+            "segments": [],
+        }
+    second_result = chain.MiniMaxH3ChainContext().apply(
+        state=second_state,
+        conditioning="stock-conditioning",
+        vae=object(),
+        latent="target-latent",
+        model="h3-model",
+        drift_sigmas=full_sigmas,
+    )
+    assert second_result[:3] == ("drift-conditioning", 39, True)
+    assert tuple(second_result[3]["samples"][0].shape) == (
+        1, 16, 12, 2, 2)
+    assert second_result[4] == ("patched-model", "h3-model", 12)
+    assert drift_calls[-1] == ("h3-model", 12, full_sigmas)
+
+    split_second_result = chain.MiniMaxH3ChainContext().apply(
+        state=second_state,
+        conditioning="stock-conditioning",
+        vae=object(),
+        latent="target-latent",
+        drift_sigmas=full_sigmas,
+    )
+    assert split_second_result[:3] == (
+        "drift-conditioning", 39, True)
+    assert split_second_result[4] is None
+
+    # A switched second model is patched inline from the same Chain Context
+    # latent and full unsplit schedule. The first scene remains a passthrough.
+    inline = chain.MiniMaxH3DriftControlModelPatch()
+    assert inline.patch(
+        "second-h3-model",
+        {"index": 1, "plan": drift_plan},
+        "stock-latent",
+        full_sigmas,
+    ) == ("second-h3-model",)
+    inline_result = inline.patch(
+        "second-h3-model",
+        second_state,
+        split_second_result[3],
+        full_sigmas,
+    )
+    assert inline_result == (
+        ("patched-model", "second-h3-model", 12),)
+    assert drift_calls[-1] == ("second-h3-model", 12, full_sigmas)
+
+    color_policy = build_transition("color_drift_av")[0]
+    color_plan = make_plan(color_policy)
+    color_plan["shots"][1]["steps"] = 20
+    color_plan["shots"].append({
+        **color_plan["shots"][1], "id": "three", "steps": 20,
+    })
+    anchor_stats = {
+        "version": "h3_latent_color_stats_v1",
+        "luma_percentiles": [100.0, 100.0, 100.0],
+        "saturation_percentiles": [80.0, 80.0, 80.0],
+        "sampled_frames": 12,
+    }
+    source_stats = {
+        **anchor_stats,
+        "luma_percentiles": [110.0, 110.0, 110.0],
+    }
+    color_state = {
+        "index": 3,
+        "plan": color_plan,
+        "previous_frames": source,
+        "previous_latent": original_latent,
+        "segments": [
+            {"index": 1, "latent_color_stats": anchor_stats},
+            {"index": 2, "latent_color_stats": source_stats},
+        ],
+    }
+    color_result = chain.MiniMaxH3ChainContext().apply(
+        state=color_state,
+        conditioning="stock-conditioning",
+        vae=object(),
+        latent="target-latent",
+        model="h3-model",
+        drift_sigmas=full_sigmas,
+    )
+    assert color_result[:3] == ("drift-conditioning", 39, True)
+    assert color_result[4] == ("patched-model", "h3-model", 12)
+    assert masked_calls[-1]["latent_color_carry"] == {
+        "anchor_stats": anchor_stats,
+        "current_stats": source_stats,
+        "anchor_scene": 1,
+        "source_scene": 2,
+    }
+    assert inline.patch(
+        "second-h3-model", color_state, color_result[3], full_sigmas,
+    ) == (("patched-model", "second-h3-model", 12),)
+finally:
+    sys.modules.pop(masked_stub.__name__, None)
+    sys.modules.pop(drift_stub.__name__, None)
+
+for invalid_context, invalid_encode, expected_message in (
+        (1, "video", "at least 5"),
+        (22, "frames", "encode_mode=video")):
+    try:
+        make_plan(
+            None, context_length=invalid_context,
+            encode_mode=invalid_encode, continuation_mode="latent_guide")
+    except ValueError as exc:
+        assert expected_message in str(exc)
+    else:
+        raise AssertionError(
+            "Latent Guide accepted invalid %s-frame/%s configuration" %
+            (invalid_context, invalid_encode))
+
+try:
+    make_plan(hard_policy, anchor_mode="before")
+except ValueError as exc:
+    assert "anchor_mode=head" in str(exc)
+else:
+    raise AssertionError("hard AV preset accepted before anchoring")
+
+plan_inputs = chain.MiniMaxH3ChainPlan.INPUT_TYPES()
+assert "transition_policy" not in plan_inputs["optional"]
+assert "MiniMaxH3TransitionPolicy" not in chain.CHAIN_NODE_CLASS_MAPPINGS
+
+legacy_adapter = chain.MiniMaxH3Legacy04PolicyAdapter()
+legacy_combined, legacy_status = legacy_adapter.build(
+    "source_plus_timeline", "feathered_av", 39, 33)
+legacy_audio = legacy_combined["audio_policy"]
+legacy_transition = legacy_combined["transition_policy"]
+assert legacy_audio == chain.migrate_legacy_audio_mode("source_plus_timeline")
+assert legacy_transition["continuation_mode"] == "feathered_av"
+assert legacy_transition["context_length"] == 39
+assert legacy_transition["expert_override"] is True
+assert legacy_combined["audio_policy"] == legacy_audio
+assert legacy_combined["transition_policy"] == legacy_transition
+assert legacy_combined["audio_context_length"] == 33
+assert "legacy 0.4 migration" in legacy_status
+matched = legacy_adapter.build(
+    "generated_audio", "masked_av", 39)[0]
+matched_audio = matched["audio_policy"]
+matched_transition = matched["transition_policy"]
+assert matched_audio == chain.migrate_legacy_audio_mode("generated_audio")
+assert matched_transition["preset"] == "hard_av"
+assert matched_transition["expert_override"] is False
+matched_audio_feather = legacy_adapter.build(
+    "generated_audio", "audio_feathered_av", 39)[0]["transition_policy"]
+assert matched_audio_feather["preset"] == "soft_av"
+assert matched_audio_feather["expert_override"] is False
+assert chain.CHAIN_NODE_CLASS_MAPPINGS[
+    "MiniMaxH3Legacy04PolicyAdapter"] is (
+        chain.MiniMaxH3Legacy04PolicyAdapter)
+assert len(legacy_adapter.OUTPUT_TOOLTIPS) == len(legacy_adapter.RETURN_TYPES)
+assert all(legacy_adapter.OUTPUT_TOOLTIPS)
+
+advanced_policy = chain.MiniMaxH3AdvancedPolicy()
+advanced_base = chain.MiniMaxH3ChainPolicy().build(
+    "guide", "source", "on", "on")[0]
+advanced_drift, advanced_status = advanced_policy.apply(
+    advanced_base, "drift_av")
+assert advanced_drift["audio_policy"] == advanced_base["audio_policy"]
+assert advanced_drift["transition_policy"]["preset"] == "drift_av"
+assert advanced_drift["transition_policy"]["continuation_mode"] == (
+    "drift_control_av")
+assert advanced_drift["audio_context_length"] == 39
+assert "advanced override" in advanced_status
+
+legacy_overlay = legacy_adapter.build(
+    "generated_audio", "feathered_av", 39, 33,
+    chain_policy=advanced_base)[0]
+assert legacy_overlay["audio_policy"] == advanced_base["audio_policy"]
+assert legacy_overlay["transition_policy"]["continuation_mode"] == (
+    "feathered_av")
+assert legacy_overlay["audio_context_length"] == 33
+
+print(
+    "transition policy: Cut/Guide/Tone Carry Guide/Latent Guide/Detail Guide/"
+    "Detail AV/Drift-Control AV/Color-Stable Drift AV/Hard AV/Soft AV/"
+    "Audio Feather AV presets, "
+    "advanced/raw "
+    "overrides, zero-context delivery, AV safety validation, legacy fallback "
+    "and adapter, Plan resolution, and one-wire registration pass")
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_upscale_alternate_unit_test.py b/ComfyUI-MiniMaxH3-Context-Loop/tests/_upscale_alternate_unit_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..a696ce0bac43f66525aa419ab4cd430d7064e622
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_upscale_alternate_unit_test.py
@@ -0,0 +1,242 @@
+#!/usr/bin/env python3
+"""Deferred ALT selection through real CPU checkpoints, saves and resume."""
+
+import copy
+import importlib
+import json
+from pathlib import Path
+import tempfile
+import unittest
+from unittest.mock import patch
+
+from _upscale_chain_unit_test import load_package, folder_paths, torch, av_latent, audio_for_frames
+
+package, chain, upscale = load_package()
+sources = importlib.import_module(package.__name__ + ".deferred_checkpoint_source")
+variants = importlib.import_module(package.__name__ + ".checkpoint_variants")
+recovery = importlib.import_module(package.__name__ + ".reference_cache_recovery")
+
+
+class Clip:
+    def tokenize(self, prompt, **kwargs):
+        return {"prompt": prompt}
+
+    def encode_from_tokens_scheduled(self, tokens):
+        return [[torch.zeros(1, 1, 4), {"tokens": tokens}]]
+
+
+class AlternateUpscaleTests(unittest.TestCase):
+    def setUp(self):
+        self.temp = tempfile.TemporaryDirectory()
+        self.addCleanup(self.temp.cleanup)
+        folder_paths.output_directory = self.temp.name
+        self.root = Path(self.temp.name)
+        self.run = "alternate_upscale_test"
+        plan = chain.MiniMaxH3ChainPlan().build(
+            json.dumps({"shots": [
+                {"id": "first", "prompt": "The original red folder.", "length": 5, "steps": 2, "seed": "7"},
+                {"id": "second", "prompt": "The next scene.", "length": 5, "steps": 2, "seed": "8"}]}),
+            self.run, "unit-test", 32, 32, 1, "video", "head", "disabled", "generated_audio",
+            1, 5 / 24, 2, 7, 18, 0, "guide")[0]
+        self.plan = chain._plan_with_source_audio(chain._plan_with_external_context(plan, None), None)
+        self.frames = torch.zeros(5, 32, 32, 3)
+        self.bases = []
+        for index in (1, 2):
+            state = chain._initial_state(self.plan, index)
+            delivered = self.plan["shots"][index - 1]["delivered_frames"]
+            audio = audio_for_frames(delivered)
+            audio["waveform"].fill_(0.2)
+            self.bases.append(chain.MiniMaxH3ChainSegmentSave().save(
+                state, self.frames[:delivered], av_latent(0.1), audio,
+                denoised_latent=av_latent(0.3))["result"][0])
+        self.selection = {"run_name": self.run, "output_mode": "workflow_local", "lineage": [
+            {"scene": index, "revision": item["revision"]} for index, item in enumerate(self.bases, 1)]}
+        self.manager = chain.MiniMaxH3ChainCheckpointManager()
+        self.manifest = self.manager.passthrough(json.dumps(self.selection))[0]
+        self.adapter = upscale.MiniMaxH3ChainUpscaleAdapter()
+        self.saver = upscale.MiniMaxH3ChainUpscaleSegmentSave()
+        self.alt = self.make_alternate()
+        self.original_files = {path: path.read_bytes() for path in (
+            self.root / item[key] for item in self.bases
+            for key in ("checkpoint", "revision_metadata", "metadata", "segment"))}
+
+    def make_alternate(self, scene=1):
+        base = self.bases[scene - 1]
+        plan = chain._alternate_take_plan(self.plan, {"alternate_draft": {
+            "enabled": True, "scene": scene, "scene_id": base["id"], "base_revision": base["revision"],
+            "prompt": "The alternate blue folder.", "seed": 91}})
+        audio = audio_for_frames(base["delivered_frames"])
+        audio["waveform"].fill_(0.8)
+        alt = chain.MiniMaxH3ChainSegmentSave().save(
+            chain._initial_state(plan, scene), self.frames[:base["delivered_frames"]],
+            av_latent(0.7), audio, denoised_latent=av_latent(0.9))["result"][0]
+        chain._select_editorial_alternate(plan, alt)
+        return alt
+
+    def adapt(self, manifest=None, profile="hq", backend="h3_latent", start=1, recipe="{}", save_latent=False):
+        return self.adapter.adapt(manifest or self.manifest, profile, backend, recipe, start, 0, save_latent, 18)
+
+    def test_full_sequence_uses_alt_picture_original_audio_and_frozen_lineage(self):
+        before = copy.deepcopy(self.manifest)
+        _, state, manifest, status = self.adapt()
+        self.assertIn("final-cut ALT pictures: 1/" + self.alt["revision"][:8], status)
+        self.assertEqual(manifest["segments"][0]["revision"], self.alt["revision"])
+        self.assertEqual(manifest["segments"][1], before["segments"][1])
+        self.assertEqual(self.manifest, before)
+        current = upscale.MiniMaxH3ChainUpscaleCurrent().current(state)
+        self.assertTrue(torch.all(current[2]["samples"] == 0.9))
+        self.assertTrue(torch.all(current[3]["samples"] == 0.3))
+        self.assertTrue(torch.all(current[13]["waveform"] == 0.2))
+        self.assertEqual(current[6], self.alt["prompt"])
+        self.assertIn("ALT " + self.alt["revision"][:8], current[-1])
+        self.assertEqual(current[9], 91)
+        # Resolving twice does not reapply today's editorial to an already pinned source.
+        self.assertEqual(upscale._verified_source_manifest(manifest), manifest)
+        self.assertEqual(self.original_files, {p: p.read_bytes() for p in self.original_files})
+
+    def test_chapter_and_pixel_reader_select_same_alt(self):
+        chapter, _ = chain._chapter_manifest_from_manifest(self.manifest, 1, persist=False)
+        self.make_alternate()  # Chapter selection remains frozen to the first ALT.
+        _, state, _, _ = self.adapt(chapter, backend="pixel")
+        self.assertEqual(state["source_manifest"]["segments"][0]["revision"], self.alt["revision"])
+
+        class VideoVAE:
+            def decode(_self, video):
+                self.assertTrue(torch.all(video == 0.9))
+                return self.frames
+
+        current = upscale.MiniMaxH3ChainUpscalePixelCurrent().current(state, VideoVAE())
+        self.assertEqual(current[3], self.alt["prompt"])
+        self.assertTrue(torch.all(current[2]["waveform"] == 0.2))
+        self.assertIn("ALT ", current[-1])
+
+    def test_alt_conditioning_uses_own_prompt_and_fingerprint(self):
+        path = self.root / self.alt["revision_metadata"]
+        meta = chain._read_json(str(path))
+        meta["compatibility"]["generation_fingerprint"] = "f" * 64
+        chain._atomic_json(str(path), meta)
+        _, state, _, _ = self.adapt()
+        with patch.object(chain, "_find_reference_cache", return_value=None) as lookup, patch.object(
+                recovery, "recover_reference_cache", side_effect=recovery.ReferenceRecoveryUnavailable("no references")):
+            result = upscale.MiniMaxH3ChainUpscaleReferenceConditioning().condition(state, Clip())
+        self.assertEqual(lookup.call_args.args[0], "f" * 64)
+        self.assertEqual(lookup.call_args.args[3], self.alt["prompt"])
+        self.assertEqual(result[0][0][1]["tokens"]["prompt"], self.alt["prompt"])
+
+    def test_selective_reader_never_loads_original_video_or_alt_audio(self):
+        from safetensors import safe_open
+        source = self.adapt()[2]["segments"][0]
+        reads = []
+
+        class TrackedFile:
+            def __init__(self, path, **kwargs):
+                self.path = path
+                self.reader = safe_open(path, **kwargs)
+
+            def __enter__(self):
+                self.reader.__enter__()
+                return self
+
+            def __exit__(self, *args):
+                return self.reader.__exit__(*args)
+
+            def keys(self):
+                return self.reader.keys()
+
+            def get_tensor(self, key):
+                reads.append((self.path, key))
+                return self.reader.get_tensor(key)
+
+        with patch("safetensors.safe_open", TrackedFile), patch.object(
+                chain, "_st_load", side_effect=AssertionError("must load selectively")):
+            upscale._load_source_tensors(source)
+            self.assertFalse(any(path.endswith(self.bases[0]["checkpoint"].split("/")[-1]) and "video" in key
+                                 or path.endswith(self.alt["checkpoint"].split("/")[-1]) and "audio" in key
+                                 for path, key in reads))
+            reads.clear()
+            audio = upscale._load_source_tensors(source, ("delivered_audio",))
+            self.assertEqual(reads, [(str(self.root / self.bases[0]["checkpoint"]), "delivered_audio")])
+            self.assertTrue(torch.all(audio["delivered_audio"] == 0.2))
+
+    def test_terminal_alt_video_keeps_denoised_base_audio(self):
+        path = self.root / self.alt["checkpoint"]
+        tensors = chain._st_load(str(path))
+        tensors.pop("denoised_video")
+        tensors.pop("denoised_audio")
+        chain._st_save(tensors, str(path))
+        metadata_path = self.root / self.alt["revision_metadata"]
+        metadata = chain._read_json(str(metadata_path))
+        metadata["segment"]["checkpoint_sha256"] = chain._file_sha256(str(path))
+        chain._atomic_json(str(metadata_path), metadata)
+        current = upscale.MiniMaxH3ChainUpscaleCurrent().current(self.adapt()[1])
+        self.assertTrue(torch.all(current[2]["samples"] == 0.7))
+        self.assertTrue(torch.all(current[3]["samples"] == 0.3))
+
+    def test_save_resume_and_catalogue_track_alt_not_base(self):
+        _, state, manifest, _ = self.adapt()
+        saved = self.saver.save(state, self.frames)["result"][0]
+        self.assertEqual(saved["source_revision"], self.alt["revision"])
+        tensors = chain._st_load(str(self.root / saved["checkpoint"]))
+        self.assertTrue(torch.all(tensors["delivered_audio"] == 0.2))
+        resumed = self.adapt(start=2)[1]
+        self.assertEqual(resumed["segments"][0]["revision"], saved["revision"])
+        graph = chain.CheckpointGraphManager(self.temp.name).graph(self.run, adopt_legacy=False)
+        catalog = variants.saved_checkpoint_variants(self.temp.name, self.run, graph["revisions"])
+        record = next(v for v in catalog["variants"] if v["revision"] == saved["revision"])
+        self.assertEqual(record["originals"], [{"scene": 1, "revision": self.bases[0]["revision"]}])
+        # An ALT baked into HQ must not be swapped back to its low-res media at assembly.
+        child = upscale._upscale_manifest(state, [saved], complete=False)
+        assembly = upscale._assembly_manifest(child, [saved])
+        self.assertEqual(assembly["editorial"]["replacements"], [])
+        self.assertEqual(assembly["segments"][0]["segment"], saved["segment"])
+        self.make_alternate()
+        with self.assertRaisesRegex(ValueError, "different source revision"):
+            self.adapt(start=2)
+        with self.assertRaisesRegex(ValueError, "branch changed"):
+            self.adapter.adapt(self.manifest, "hq", "h3_latent", "{}", 1, 0, False, 18, initial_state=state)
+        # The frozen previous source is still a valid explicit selection.
+        self.assertEqual(self.adapt(manifest, start=2)[1]["segments"][0]["revision"], saved["revision"])
+
+    def test_previous_original_upscale_not_reused_for_alt(self):
+        original = {**self.manifest, "editorial": {**chain._load_run_editorial(self.run), "replacements": []}}
+        _, old_state, _, _ = self.adapt(original)
+        self.saver.save(old_state, self.frames)
+        with self.assertRaisesRegex(ValueError, "different source revision"):
+            self.adapt(start=2)
+        # Restarting at the affected scene is allowed and retains old outputs.
+        self.assertEqual(self.adapt()[1]["segments"], [])
+
+    def test_missing_selected_alt_fails_without_silent_base_fallback(self):
+        (self.root / self.alt["revision_metadata"]).unlink()
+        with self.assertRaisesRegex(FileNotFoundError, "alternate revision is missing"):
+            self.adapt()
+
+    def test_no_alt_and_stale_other_branch_replacements_keep_original(self):
+        editorial = chain._load_run_editorial(self.run)
+        for replacements in ([], [{**editorial["replacements"][0], "base_revision": "0" * 32}]):
+            source = {**self.manifest, "editorial": {**editorial, "replacements": replacements}}
+            self.assertEqual(self.adapt(source)[2], source)
+
+    def test_derope_from_alt_is_reused_and_absent_scenes_resolve_alts(self):
+        # Both scenes have final-cut ALTs, but only scene 1 has DeRoPE yet.
+        alt_two = self.make_alternate(2)
+        _, state, _, _ = self.adapt(profile="motion", recipe='{"derope":true}', save_latent=True)
+        saved = self.saver.save(state, self.frames, av_latent(0.6))["result"][0]
+        meta = chain._read_json(str(self.root / saved["revision_metadata"]))
+        choice = {"stage": "derope", "profile_path": str((self.root / saved["metadata"]).parent.parent.relative_to(self.root)),
+                  "branch": {"kind": "metadata", "path": saved["revision_metadata"], "lineage": meta["processing_lineage"]}}
+        processed = self.manager.passthrough(json.dumps({**self.selection, "processing_source": choice}))[0]
+        self.assertEqual(processed["segments"][0]["revision"], saved["revision"])
+        self.assertEqual(processed["segments"][1]["revision"], alt_two["revision"])
+        _, after, _, _ = self.adapt(processed, profile="after-motion")
+        current = upscale.MiniMaxH3ChainUpscaleCurrent().current(after)
+        self.assertTrue(torch.all(current[2]["samples"] == 0.6))
+        self.assertTrue(torch.all(current[3]["samples"] == 0.6))
+        self.assertTrue(torch.all(current[13]["waveform"] == 0.2))
+        self.make_alternate()
+        with self.assertRaisesRegex(ValueError, "different original take or final-cut ALT"):
+            sources.derope_source_manifest(self.manifest, choice, chain, upscale)
+
+
+if __name__ == "__main__":
+    unittest.main(argv=[__file__])
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_upscale_chain_unit_test.py b/ComfyUI-MiniMaxH3-Context-Loop/tests/_upscale_chain_unit_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..bcc763286c30ff177cc0c9758ecfbec5a013639a
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_upscale_chain_unit_test.py
@@ -0,0 +1,1068 @@
+#!/usr/bin/env python3
+"""CPU integration test for deferred checkpoint upscale child runs."""
+
+import importlib.util
+import json
+import pathlib
+import os
+import sys
+import tempfile
+
+
+ROOT = pathlib.Path(__file__).resolve().parents[1]
+candidates = [pathlib.Path(os.environ["COMFYUI_PATH"])] if os.environ.get("COMFYUI_PATH") else []
+candidates += [ROOT.parent / "Comfyui", ROOT.parent / "ComfyUI"]
+COMFY = next(path for path in candidates
+             if (path / "comfy" / "options.py").is_file())
+sys.path.insert(0, str(COMFY))
+sys.argv = ["h3-upscale-test", "--cpu"]
+
+import comfy.options  # noqa: E402
+
+comfy.options.enable_args_parsing()
+import folder_paths  # noqa: E402
+import torch  # noqa: E402
+from safetensors import safe_open  # noqa: E402
+
+
+def load_package():
+    spec = importlib.util.spec_from_file_location(
+        "h3_upscale_test_package", ROOT / "__init__.py",
+        submodule_search_locations=[str(ROOT)])
+    package = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = package
+    spec.loader.exec_module(package)
+    return (package, sys.modules[spec.name + ".chain_nodes"],
+            sys.modules[spec.name + ".upscale_nodes"])
+
+
+def av_latent(value=0.0):
+    return {"samples": [
+        torch.full((1, 24, 2, 2, 2), value, dtype=torch.float32),
+        torch.full((1, 32, 2, 9), value, dtype=torch.float32),
+    ]}
+
+
+def audio_for_frames(frames, sample_rate=8000):
+    samples = round(frames / 24.0 * sample_rate)
+    return {
+        "waveform": torch.zeros((1, 2, samples), dtype=torch.float32),
+        "sample_rate": sample_rate,
+    }
+
+
+def legacy_cache_fixture(chain, metadata, version="h3_reference_cache_v2"):
+    """Materialize a real old bundle so legacy reader tests stay meaningful."""
+    tensors = chain._reference_cache_tensors(metadata)
+    legacy = dict(metadata)
+    legacy.pop("tensor_objects", None)
+    legacy["format"] = version
+    legacy["signature"] = chain._fingerprint({
+        "format": version, "reference_fingerprint": legacy["reference_fingerprint"],
+        **{key: legacy[key] for key in ("scene", "scene_count", "prompt", "compiled_prompt",
+                                       "width", "height", "length", "ref_image_size")},
+        "presentation": legacy.get("presentation_contract"),
+    })
+    metadata_path = pathlib.Path(chain._absolute_output_path(legacy["metadata"])).with_name(
+        "scene_%04d.%s.json" % (legacy["scene"], legacy["signature"][:24]))
+    legacy["metadata"] = chain._relative_output_path(str(metadata_path))
+    path = metadata_path.with_suffix(".safetensors")
+    chain._st_save({key: value.clone() for key, value in tensors.items()}, str(path))
+    legacy["tensors"] = chain._relative_output_path(str(path))
+    legacy["tensors_sha256"] = chain._file_sha256(str(path))
+    chain._atomic_json(chain._absolute_output_path(legacy["metadata"]), legacy)
+    return legacy
+
+
+def main():
+    package, chain, upscale = load_package()
+    required = {
+        "MiniMaxH3ChainUpscaleAdapter",
+        "MiniMaxH3ChainUpscaleCurrent",
+        "MiniMaxH3ChainDeropeGuard",
+        "MiniMaxH3ChainDeropeFreezeMask",
+        "MiniMaxH3ChainDeropeContinuity",
+        "MiniMaxH3ChainRecoveredAV",
+        "MiniMaxH3UpscaleReferencePromptOverride",
+        "MiniMaxH3ChainUpscaleReferenceConditioning",
+        "H3ConditioningSyncFromLatents",
+        "MiniMaxH3ChainPass2Prepare",
+        "MiniMaxH3ChainUpscaleSegmentSave",
+        "MiniMaxH3ChainUpscaleLoopEnd",
+        "MiniMaxH3ChainUpscaleMerge",
+    }
+    assert required <= set(package.NODE_CLASS_MAPPINGS)
+    assert upscale.UPSCALE_MANIFEST_TYPE == chain.MANIFEST_TYPE
+    assert upscale.MiniMaxH3ChainUpscaleLoopEnd.RETURN_TYPES[0] == (
+        chain.MANIFEST_TYPE)
+    assert upscale.MiniMaxH3ChainUpscaleMerge.DEPRECATED is True
+    legacy_chain_nodes = (
+        chain.MiniMaxH3ScheduledPictureReference,
+        chain.MiniMaxH3ScheduledVideoReference,
+        chain.MiniMaxH3ScheduledAudioReference,
+        chain.MiniMaxH3ScheduledReferenceToVideo,
+        chain.MiniMaxH3Legacy04PolicyAdapter,
+        chain.MiniMaxH3LazyMotionAVLoader,
+    )
+    assert all(node.DEPRECATED is True for node in legacy_chain_nodes)
+    expected_derope_union = "H3_CHAIN_UPSCALE_STATE,H3_CHAIN_STATE"
+    for node_name in (
+            "MiniMaxH3ChainDeropeGuard",
+            "MiniMaxH3ChainDeropeFreezeMask",
+            "MiniMaxH3ChainDeropeContinuity",
+            "MiniMaxH3ChainRecoveredAV"):
+        assert str(package.NODE_CLASS_MAPPINGS[node_name].INPUT_TYPES()[
+            "required"]["state"][0]) == expected_derope_union
+    for name in required:
+        node = package.NODE_CLASS_MAPPINGS[name]
+        schema = node.INPUT_TYPES()
+        for section in ("required", "optional"):
+            for input_name, spec in schema.get(section, {}).items():
+                options = spec[1] if len(spec) > 1 else {}
+                assert str(options.get("tooltip") or "").strip(), (
+                    name, input_name)
+        assert len(node.OUTPUT_TOOLTIPS) == len(node.RETURN_TYPES), name
+    manager_schema = package.NODE_CLASS_MAPPINGS[
+        "MiniMaxH3ChainCheckpointManager"].INPUT_TYPES()
+    assert "selection_json" in manager_schema["required"]
+    assert set(manager_schema["optional"]) == {"plan"}
+    assert "plan" not in upscale.MiniMaxH3ChainUpscaleAdapter.INPUT_TYPES()[
+        "required"]
+
+    with tempfile.TemporaryDirectory() as temporary:
+        folder_paths.output_directory = temporary
+        plan = chain.MiniMaxH3ChainPlan().build(
+            json.dumps({"shots": [{
+                "id": "upscale_scene_1",
+                "prompt": "A clean deferred upscale test begins.",
+                "length": 5,
+                "steps": 2,
+                "seed": "7",
+            }, {
+                "id": "upscale_scene_2",
+                "prompt": "The same test continues without a cut.",
+                "length": 5,
+                "steps": 2,
+                "seed": "8",
+            }]}),
+            "upscale_test", "unit-test", 32, 32, 1,
+            "video", "head", "disabled", "generated_audio", 1,
+            5 / 24, 2, 7, 18, 0, "guide")[0]
+        prepared_plan = chain._plan_with_source_audio(
+            chain._plan_with_external_context(plan, None), None)
+        state = chain._initial_state(prepared_plan, 1)
+        source_images = torch.zeros((5, 32, 32, 3), dtype=torch.float32)
+        source = chain.MiniMaxH3ChainSegmentSave().save(
+            state, source_images, av_latent(0.25), audio_for_frames(5),
+            denoised_latent=av_latent(0.75))["result"][0]
+        second_state = chain._initial_state(prepared_plan, 2)
+        second_frames = int(prepared_plan["shots"][1]["delivered_frames"])
+        source_2 = chain.MiniMaxH3ChainSegmentSave().save(
+            second_state,
+            torch.zeros((second_frames, 32, 32, 3), dtype=torch.float32),
+            av_latent(0.35), audio_for_frames(second_frames),
+            denoised_latent=av_latent(0.85))["result"][0]
+        source_checkpoint = pathlib.Path(
+            chain._absolute_output_path(source["checkpoint"]))
+        with safe_open(source_checkpoint, framework="pt", device="cpu") as saved:
+            assert {"video", "audio", "denoised_video", "denoised_audio"} <= set(
+                saved.keys())
+
+        selection = json.dumps({
+            "run_name": "upscale_test",
+            "lineage": [
+                {"scene": 1, "revision": source["revision"]},
+                {"scene": 2, "revision": source_2["revision"]},
+            ],
+        })
+        manager = chain.MiniMaxH3ChainCheckpointManager()
+        assert manager.passthrough("")[0] is None
+        partial_selection = json.dumps({
+            "run_name": "upscale_test",
+            "lineage": [
+                {"scene": 1, "revision": source["revision"]},
+            ],
+        })
+        partial_manifest = manager.passthrough(partial_selection)[0]
+        assert partial_manifest["clip_count"] == 1
+        assert partial_manifest["planned_clip_count"] == 2
+        assert partial_manifest["selection_complete"] is False
+        assert [item["revision"] for item in partial_manifest["segments"]] == [
+            source["revision"]]
+        selected_manifest = manager.passthrough(selection)[0]
+        assert selected_manifest["clip_count"] == 2
+        assert selected_manifest["planned_clip_count"] == 2
+        assert selected_manifest["selection_complete"] is True
+
+        adapter = upscale.MiniMaxH3ChainUpscaleAdapter()
+        _partial_flow, partial_state, partial_source, partial_status = (
+            adapter.adapt(
+                partial_manifest, "partial", "h3_latent", '{"scale":2}',
+                1, 0, False, 18))
+        assert len(partial_state["source_manifest"]["segments"]) == 1
+        assert partial_source["planned_clip_count"] == 2
+        assert "scene 1/1" in partial_status
+        flow, upscale_state, source_manifest, _status = adapter.adapt(
+            selected_manifest, "quality", "h3_latent", '{"scale":2}',
+            1, 1, False, 18)
+        assert source_manifest["segments"][0]["revision"] == source["revision"]
+        assert source_manifest["segments"][1]["revision"] == source_2["revision"]
+        current = upscale.MiniMaxH3ChainUpscaleCurrent().current(upscale_state)
+        assert torch.all(chain._streams_from_latent(current[1])[0] == 0.75)
+        assert getattr(current[1]["samples"], "is_nested", False)
+        assert torch.all(current[2]["samples"] == 0.75)
+        assert torch.all(current[3]["samples"] == 0.75)
+        assert current[7:10] == (32, 32, 7)
+        assert "saved denoised x0" in current[-1]
+
+        class FakeVideoVAE:
+            def encode(self, images):
+                return torch.full(
+                    (1, 24, 2, int(images.shape[1]) // 16,
+                     int(images.shape[2]) // 16),
+                    0.625, dtype=torch.float32)
+
+        class FakeClip:
+            def tokenize(self, prompt, **kwargs):
+                return {"prompt": prompt, "presentation": kwargs.get(
+                    "minimax_ref_items", [])}
+
+            def encode_from_tokens_scheduled(self, tokens):
+                return [[torch.zeros((1, 1, 4)), {"tokens": tokens}]]
+
+        first_override_refs = chain.MiniMaxH3TaggedPictureReference().add(
+            torch.ones((1, 80, 96, 3), dtype=torch.float32),
+            "detail_face")[0]
+        override_refs = chain.MiniMaxH3TaggedPictureReference().add(
+            torch.zeros((1, 64, 64, 3), dtype=torch.float32),
+            "optional_style", previous=first_override_refs)[0]
+        inline_override = (
+            upscale.MiniMaxH3UpscaleReferencePromptOverride().override(
+                prompt_override="@detail_face preserves the subject.",
+                disabled_tags="@optional_style",
+                references=override_refs))
+        assert len(chain._tagged_reference_entries(inline_override[0])) == 1
+        assert inline_override[1] == "@detail_face preserves the subject."
+        assert inline_override[2] == inline_override[0]["fingerprint"]
+        assert "disabled @optional_style" in inline_override[3]
+        no_refs_override = (
+            upscale.MiniMaxH3UpscaleReferencePromptOverride().override())
+        assert no_refs_override[:3] == (None, "", "")
+        assert "automatic cache remains active" in no_refs_override[3]
+
+        cache_status = chain._cache_reference_scene(
+            fingerprint="unit-test", scene=1, scene_count=2,
+            prompt=source["prompt"],
+            compiled_prompt=source["prompt"].replace(
+                "deferred upscale test", "<Picture 1> test"),
+            width=32, height=32, length=5, ref_image_size="match",
+            vae=FakeVideoVAE(), audio_vae=None,
+            pictures=[torch.ones((1, 64, 128, 3))], videos=[], audios=[])
+        assert "reference cache saved" in cache_status
+        cache_metadata = chain._find_reference_cache(
+            "unit-test", 1, 2, source["prompt"], 32, 32, 5)
+        assert cache_metadata["format"] == "h3_reference_cache_v3"
+        # Exercise backward compatibility with an actual V2 tensor bundle.
+        cache_metadata = legacy_cache_fixture(chain, cache_metadata)
+        cache_descriptor = chain._reference_cache_descriptor(cache_metadata)
+        assert cache_descriptor is not None
+        assert cache_metadata["format"] == "h3_reference_cache_v2"
+        assert len(cache_metadata["source_images"]) == 1
+        assert chain._load_reference_cache_descriptor(
+            cache_descriptor)["signature"] == cache_metadata["signature"]
+        cached_source = chain.MiniMaxH3ChainSegmentSave().save(
+            state, source_images, av_latent(0.25), audio_for_frames(5),
+            denoised_latent=av_latent(0.75))["result"][0]
+        adopted_cache = cached_source["reference_cache"]
+        assert adopted_cache != cache_descriptor
+        assert adopted_cache["metadata"].startswith(
+            "h3_chains/upscale_test/reference_cache/")
+        assert adopted_cache["tensors"].startswith(
+            "h3_chains/upscale_test/reference_cache/")
+        assert chain._load_reference_cache_descriptor(
+            adopted_cache)["run_name"] == "upscale_test"
+        cached_second_state = chain._initial_state(prepared_plan, 2)
+        cached_source_2 = chain.MiniMaxH3ChainSegmentSave().save(
+            cached_second_state,
+            torch.zeros((second_frames, 32, 32, 3), dtype=torch.float32),
+            av_latent(0.35), audio_for_frames(second_frames),
+            denoised_latent=av_latent(0.85))["result"][0]
+
+        # Simulate a checkpoint created by the first cache implementation:
+        # its immutable revision points at the global staging object and no
+        # run-local object exists yet.
+        legacy_revision_path = pathlib.Path(chain._absolute_output_path(
+            cached_source["revision_metadata"]))
+        legacy_revision = chain._read_json(str(legacy_revision_path))
+        legacy_revision["segment"]["reference_cache"] = cache_descriptor
+        chain._atomic_json(str(legacy_revision_path), legacy_revision)
+        pathlib.Path(chain._absolute_output_path(
+            adopted_cache["metadata"])).unlink()
+        pathlib.Path(chain._absolute_output_path(
+            adopted_cache["tensors"])).unlink()
+
+        legacy_selection = json.dumps({
+            "run_name": "upscale_test",
+            "lineage": [
+                {"scene": 1, "revision": cached_source["revision"]},
+                {"scene": 2, "revision": cached_source_2["revision"]},
+            ],
+        })
+        migrated_manifest = manager.passthrough(legacy_selection)[0]
+        migrated_cache = migrated_manifest["segments"][0]["reference_cache"]
+        assert migrated_cache["metadata"].startswith(
+            "h3_chains/upscale_test/reference_cache/")
+        assert migrated_cache["tensors"].startswith(
+            "h3_chains/upscale_test/reference_cache/")
+        assert pathlib.Path(chain._absolute_output_path(
+            cache_descriptor["metadata"])).is_file()
+        assert pathlib.Path(chain._absolute_output_path(
+            cache_descriptor["tensors"])).is_file()
+
+        # Once one selection has adopted and verified the cache, the original
+        # global staging pair may disappear without breaking future selection.
+        pathlib.Path(chain._absolute_output_path(
+            cache_descriptor["metadata"])).unlink()
+        pathlib.Path(chain._absolute_output_path(
+            cache_descriptor["tensors"])).unlink()
+        relocated_manifest = manager.passthrough(legacy_selection)[0]
+        assert (relocated_manifest["segments"][0]["reference_cache"] ==
+                migrated_cache)
+        cached_upscale_state = dict(upscale_state)
+        cached_upscale_state["source_manifest"] = relocated_manifest
+        live_override_conditioning = (
+            upscale.MiniMaxH3ChainUpscaleReferenceConditioning().condition(
+                cached_upscale_state, FakeClip(), "error",
+                video_vae=FakeVideoVAE(),
+                prompt_override=inline_override[1],
+                tagged_references=inline_override[0],
+                override_ref_image_size="max"))
+        assert live_override_conditioning[1] == (
+            "<Picture 1> preserves the subject.")
+        assert live_override_conditioning[2] is False
+        live_metadata = live_override_conditioning[0][0][1]
+        assert len(live_metadata["minimax_refs"]) == 1
+        assert live_metadata["_h3_upscale_ref_image_size"] == "max"
+        assert live_metadata["_h3_upscale_picture_refs_target_sized"] is False
+        assert "connected Tagged refs replace cached refs" in (
+            live_override_conditioning[3])
+        cached_conditioning = (
+            upscale.MiniMaxH3ChainUpscaleReferenceConditioning().condition(
+                cached_upscale_state, FakeClip(), "error"))
+        assert cached_conditioning[2] is True
+        assert "restored Ref2VA cache" in cached_conditioning[3]
+        cached_refs = cached_conditioning[0][0][1]["minimax_refs"]
+        assert len(cached_refs) == 1
+        assert cached_refs[0]["kind"] == "image"
+        assert torch.all(cached_refs[0]["latent"] == 0.625)
+        assert cached_conditioning[0][0][1][
+            "_h3_upscale_motion_ref_mode"] == "exclude_video_keep_audio"
+        assert cached_conditioning[0][0][1][
+            "_h3_upscale_ref_image_size"] == "match"
+        assert cached_conditioning[0][0][1][
+            "_h3_upscale_picture_refs_target_sized"] is False
+        override_conditioning = (
+            upscale.MiniMaxH3ChainUpscaleReferenceConditioning().condition(
+                cached_upscale_state, FakeClip(), "error",
+                prompt_override="Preserve identity and fine detail."))
+        assert override_conditioning[1] == "Preserve identity and fine detail."
+        assert override_conditioning[0][0][1]["tokens"]["prompt"] == (
+            "Preserve identity and fine detail.")
+        assert "custom pass-2 prompt override" in override_conditioning[3]
+
+        target_video = {
+            "samples": torch.zeros((1, 24, 2, 4, 4), dtype=torch.float32)}
+        target_conditioning = (
+            upscale.MiniMaxH3ChainUpscaleReferenceConditioning().condition(
+                cached_upscale_state, FakeClip(), "error",
+                target_video, FakeVideoVAE()))
+        target_refs = target_conditioning[0][0][1]["minimax_refs"]
+        assert tuple(target_refs[0]["latent"].shape[-2:]) == (2, 6)
+        target_presentation = target_conditioning[0][0][1]["tokens"][
+            "presentation"]
+        assert tuple(target_presentation[0]["data"].shape[1:3]) == (32, 96)
+        assert "pass-2 64x64 policy=match" in target_conditioning[3]
+        assert "1 source masters" in target_conditioning[3]
+        assert target_conditioning[0][0][1][
+            "_h3_upscale_ref_image_size"] == "match"
+        assert target_conditioning[0][0][1][
+            "_h3_upscale_picture_refs_target_sized"] is True
+        synced_target = upscale.H3ConditioningSyncFromLatents().sync(
+            {"samples": torch.zeros((1, 24, 2, 2, 2))},
+            target_video, target_conditioning[0], "bilinear")[0][0][1]
+        assert tuple(synced_target["minimax_refs"][0][
+            "latent"].shape[-2:]) == (2, 6)
+
+        legacy_cache = dict(chain._load_reference_cache_descriptor(
+            migrated_cache))
+        legacy_cache["format"] = "h3_reference_cache_v1"
+        legacy_cache.pop("source_images", None)
+        legacy_cache["presentation"] = [
+            {key: value for key, value in item.items() if key != "role"}
+            for item in legacy_cache["presentation"]]
+        assert chain._reference_cache_descriptor(legacy_cache) is not None
+        legacy_conditioning, legacy_detail = (
+            chain._conditioning_from_reference_cache_target(
+                FakeClip(), FakeVideoVAE(), legacy_cache, 64, 64))
+        assert legacy_detail["master_rebuilds"] == 0
+        assert legacy_detail["fallback_rebuilds"] == 1
+        legacy_refs = legacy_conditioning[0][1]["minimax_refs"]
+        assert tuple(legacy_refs[0]["latent"].shape[-2:]) == (4, 4)
+
+        max_cache = dict(chain._load_reference_cache_descriptor(
+            migrated_cache))
+        max_cache["ref_image_size"] = "max"
+        max_conditioning, max_detail = (
+            chain._conditioning_from_reference_cache_target(
+                FakeClip(), FakeVideoVAE(), max_cache, 64, 64))
+        max_refs = max_conditioning[0][1]["minimax_refs"]
+        assert max_detail["rebuilt_images"] == 0
+        assert tuple(max_refs[0]["latent"].shape[-2:]) == (2, 2)
+        marked_max = upscale._mark_h3_upscale_motion_policy(
+            max_conditioning, "exclude_video_keep_audio", "max")
+        synced_max = upscale.H3ConditioningSyncFromLatents().sync(
+            {"samples": torch.zeros((1, 24, 2, 2, 2))},
+            {"samples": torch.zeros((1, 24, 2, 4, 6))},
+            marked_max, "bilinear")[0][0][1]
+        assert tuple(synced_max["minimax_refs"][0][
+            "latent"].shape[-2:]) == (2, 2)
+        assert synced_max["minimax_refs"][0]["latent_h"] == 2
+        assert synced_max["minimax_refs"][0]["latent_w"] == 2
+
+        sync_positive = [[torch.zeros((1, 1, 4)), {
+            "minimax_refs": [{
+                "kind": "image",
+                "latent_h": 2,
+                "latent_w": 3,
+                "latent": torch.arange(
+                    1 * 24 * 1 * 2 * 3, dtype=torch.float32).reshape(
+                        1, 24, 1, 2, 3),
+            }, {
+                "kind": "video_audio",
+                "latent_t": 2,
+                "latent_h": 4,
+                "latent_w": 5,
+                "ref_audio_t": 2,
+                "latent": torch.zeros((1, 24, 2, 4, 5)),
+                "audio_latent": torch.ones((1, 32, 2, 9)),
+            }, {
+                "kind": "audio",
+                "ref_audio_t": 2,
+                "audio_latent": torch.ones((1, 32, 2, 9)),
+            }],
+            "minimax_keyframes": [{
+                "resolved_frame_index": 0,
+                "latent": torch.zeros((1, 24, 1, 2, 2)),
+                "audio_latent": torch.ones((1, 32, 2, 9)),
+            }],
+            "unchanged": "metadata",
+        }]]
+        synced = upscale.H3ConditioningSyncFromLatents().sync(
+            {"samples": torch.zeros((1, 24, 2, 2, 2))},
+            {"samples": torch.zeros((1, 24, 2, 4, 6))},
+            sync_positive, "bilinear")
+        synced_meta = synced[0][0][1]
+        assert synced[1] is None
+        assert synced[2:] == (96, 64, 3.0, 2.0)
+        assert tuple(synced_meta["minimax_refs"][0]["latent"].shape) == (
+            1, 24, 1, 4, 10)
+        assert synced_meta["minimax_refs"][0]["latent_h"] == 4
+        assert synced_meta["minimax_refs"][0]["latent_w"] == 10
+        assert synced_meta["minimax_refs"][1]["kind"] == "audio"
+        assert "latent" not in synced_meta["minimax_refs"][1]
+        assert "latent_t" not in synced_meta["minimax_refs"][1]
+        assert "latent_h" not in synced_meta["minimax_refs"][1]
+        assert "latent_w" not in synced_meta["minimax_refs"][1]
+        assert tuple(synced_meta["minimax_refs"][1][
+            "audio_latent"].shape) == (1, 32, 2, 9)
+        assert "latent" not in synced_meta["minimax_refs"][2]
+        assert tuple(synced_meta["minimax_keyframes"][0][
+            "latent"].shape) == (1, 24, 1, 4, 6)
+        assert tuple(synced_meta["minimax_keyframes"][0][
+            "audio_latent"].shape) == (1, 32, 2, 9)
+        assert synced_meta["unchanged"] == "metadata"
+        assert tuple(sync_positive[0][1]["minimax_refs"][0][
+            "latent"].shape) == (1, 24, 1, 2, 3)
+
+        max_sync_positive = upscale._mark_h3_upscale_motion_policy(
+            sync_positive, "exclude_video_keep_audio", "max")
+        max_synced_meta = upscale.H3ConditioningSyncFromLatents().sync(
+            {"samples": torch.zeros((1, 24, 2, 2, 2))},
+            {"samples": torch.zeros((1, 24, 2, 4, 6))},
+            max_sync_positive, "bilinear")[0][0][1]
+        assert tuple(max_synced_meta["minimax_refs"][0][
+            "latent"].shape) == (1, 24, 1, 2, 3)
+        assert max_synced_meta["minimax_refs"][0]["latent_h"] == 2
+        assert max_synced_meta["minimax_refs"][0]["latent_w"] == 3
+        assert tuple(max_synced_meta["minimax_keyframes"][0][
+            "latent"].shape) == (1, 24, 1, 4, 6)
+
+        filtered_presentation, filtered_blocks = (
+            chain._h3_motion_reference_policy([{
+                "type": "image", "role": "native_picture",
+            }, {
+                "type": "video", "role": "native_video",
+            }, {
+                "type": "audio", "role": "native_audio",
+            }, {
+                "type": "video", "role": "native_video",
+            }, {
+                "type": "video", "role": "semantic_presentation",
+            }], [{
+                "kind": "video_audio", "latent": torch.zeros(1),
+                "latent_t": 2, "latent_h": 4, "latent_w": 5,
+                "ref_audio_t": 2, "audio_latent": torch.ones(1),
+            }, {
+                "kind": "video", "latent": torch.zeros(1),
+                "latent_t": 2, "latent_h": 4, "latent_w": 5,
+                "ref_audio_t": 0, "audio_latent": None,
+            }, {
+                "kind": "image", "latent": torch.zeros(1),
+            }], "exclude_video_keep_audio"))
+        assert [item["type"] for item in filtered_presentation] == [
+            "image", "audio", "video"]
+        assert [block["kind"] for block in filtered_blocks] == [
+            "audio", "image"]
+        assert "latent" not in filtered_blocks[0]
+
+        native_motion = upscale.H3ConditioningSyncFromLatents().sync(
+            {"samples": torch.zeros((1, 24, 2, 2, 2))},
+            {"samples": torch.zeros((1, 24, 2, 4, 6))},
+            sync_positive, "bilinear", "keep_video_native")[0][0][1]
+        assert tuple(native_motion["minimax_refs"][1]["latent"].shape) == (
+            1, 24, 2, 4, 5)
+
+        resized_motion = upscale.H3ConditioningSyncFromLatents().sync(
+            {"samples": torch.zeros((1, 24, 2, 2, 2))},
+            {"samples": torch.zeros((1, 24, 2, 4, 6))},
+            sync_positive, "bilinear", "resize_video")[0][0][1]
+        assert tuple(resized_motion["minimax_refs"][1]["latent"].shape) == (
+            1, 24, 2, 8, 16)
+        assert resized_motion["minimax_refs"][1]["latent_t"] == 2
+
+        # De-rope expands the pass-2 time axis. Spatial reference sync must
+        # accept that new clock while leaving each reference's own time alone.
+        derope_synced = upscale.H3ConditioningSyncFromLatents().sync(
+            {"samples": torch.zeros((1, 24, 2, 2, 2))},
+            {"samples": torch.zeros((1, 24, 7, 4, 6))},
+            sync_positive, "bilinear", "resize_video")[0][0][1]
+        assert tuple(derope_synced["minimax_refs"][1]["latent"].shape) == (
+            1, 24, 2, 8, 16)
+
+        derope_manifest = json.loads(json.dumps(source_manifest))
+        derope_manifest["segments"][0].update({
+            "raw_frames": 39,
+            "delivered_frames": 22,
+        })
+        derope_manifest["segments"][1].update({
+            "raw_frames": 39,
+            "delivered_frames": 22,
+            "visual_context_source_scene": 1,
+        })
+        derope_state = {
+            **upscale_state,
+            "source_manifest": derope_manifest,
+            "source_manifest_hash": upscale._source_hash(derope_manifest),
+        }
+        guarded = upscale.MiniMaxH3ChainDeropeGuard().guard(
+            derope_state, json.dumps({
+                "holds": [4] * 39,
+                "world_len": 39,
+            }))
+        guarded_map = json.loads(guarded[0])
+        assert guarded[1:4] == (False, 17, 17)
+        assert guarded_map["holds"][:17] == [1] * 17
+        assert guarded_map["holds"][-17:] == [1] * 17
+        assert guarded_map["holds"][17:22] == [4] * 5
+        # Simulate H3 Time Smear's legal-grid tail pad. It lives on the final
+        # hold and does not disturb the protected incoming prefix.
+        used_map = dict(guarded_map)
+        used_map["holds"] = list(used_map["holds"])
+        used_map["holds"][-1] += 2
+        freeze = upscale.MiniMaxH3ChainDeropeFreezeMask().mask(
+            derope_state, json.dumps(used_map))
+        assert freeze[1] == sum(used_map["holds"])
+        assert tuple(freeze[0].shape) == (freeze[1], 8, 8)
+        assert torch.all(freeze[0][:17] == 0)
+        assert torch.all(freeze[0][17:] == 1)
+
+        packed_recovered = upscale.MiniMaxH3ChainRecoveredAV().pack(
+            upscale_state,
+            {"samples": torch.ones((1, 24, 2, 4, 6))},
+            {"samples": torch.ones((1, 32, 2, 9))})
+        assert len(chain._streams_from_latent(packed_recovered[0])) == 2
+        assert "joint AV" in packed_recovered[1]
+        try:
+            upscale.MiniMaxH3ChainRecoveredAV().pack(
+                upscale_state,
+                {"samples": torch.ones((1, 24, 7, 4, 6))})
+        except ValueError as exc:
+            assert "still has 7 latent steps" in str(exc)
+        else:
+            raise AssertionError("Recovered AV accepted a dilated time axis")
+
+        class FakeSampling:
+            @staticmethod
+            def noise_scaling(sigma, generated, latent):
+                return latent + sigma * generated
+
+            @staticmethod
+            def inverse_noise_scaling(_sigma, mixed):
+                return mixed
+
+        class FakeModel:
+            objects = {
+                "model_sampling": FakeSampling(),
+                "process_latent_in": lambda samples: samples,
+                "process_latent_out": lambda samples: samples,
+            }
+
+            def get_model_object(self, name):
+                return self.objects[name]
+
+        class FakeNoise:
+            @staticmethod
+            def generate_noise(latent):
+                return torch.ones_like(latent["samples"])
+
+        prepared = upscale.MiniMaxH3ChainPass2Prepare().prepare(
+            {"samples": torch.ones(
+                (1, 24, 2, 4, 6), dtype=torch.float32)},
+            current[3], FakeModel(), FakeNoise(),
+            torch.tensor([0.24, 0.0], dtype=torch.float32))
+        prepared_streams = chain._streams_from_latent(prepared[0])
+        prepared_masks = chain._streams_from_latent({
+            "samples": prepared[0]["noise_mask"]})
+        assert prepared[1:3] == (96, 64)
+        assert torch.allclose(
+            prepared_streams[0], torch.full_like(prepared_streams[0], 1.24))
+        assert torch.all(prepared_streams[1] == 0.75)
+        assert torch.all(prepared_masks[0] == 1)
+        assert torch.all(prepared_masks[1] == 0)
+        assert "audio" in prepared[3] and "locked" in prepared[3]
+
+        drift_manifest = json.loads(json.dumps(source_manifest))
+        drift_manifest["segments"][1].update({
+            "raw_frames": 44,
+            "delivered_frames": 5,
+            "continuation_mode": "drift_control_av",
+            "context_length": 39,
+        })
+        previous_hq_video = torch.arange(
+            16, dtype=torch.float32).view(1, 1, 16, 1, 1).expand(
+                1, 24, 16, 4, 4).clone()
+        previous_hq = {"samples": [
+            previous_hq_video,
+            torch.full((1, 32, 2, 9), 0.75, dtype=torch.float32),
+        ]}
+        drift_save_state = {
+            **upscale_state,
+            "profile": "drift-quality",
+            "source_manifest": drift_manifest,
+            "source_manifest_hash": upscale._source_hash(drift_manifest),
+            "segments": [],
+        }
+        drift_saved = upscale.MiniMaxH3ChainUpscaleSegmentSave().save(
+            drift_save_state,
+            torch.zeros((5, 64, 64, 3), dtype=torch.float32),
+            previous_hq)["result"][0]
+        assert not drift_saved["latent_saved"]
+        assert drift_saved["context_steps"] == 12
+        drift_checkpoint = pathlib.Path(
+            chain._absolute_output_path(drift_saved["checkpoint"]))
+        with safe_open(drift_checkpoint, framework="pt", device="cpu") as saved:
+            assert "upscaled_video_context" in saved.keys()
+            assert "upscaled_video" not in saved.keys()
+            assert tuple(saved.get_tensor(
+                "upscaled_video_context").shape) == (1, 24, 12, 4, 4)
+
+        resumed_drift_state = {
+            **drift_save_state,
+            "index": 2,
+            "segments": [drift_saved],
+            "previous_latent": None,
+        }
+        restored_context, restored_route = (
+            upscale._load_previous_upscaled_context(
+                resumed_drift_state, 2))
+        assert "compact saved HQ context" in restored_route
+        resumed_drift_state["previous_latent"] = restored_context
+        drift_prepared = upscale.MiniMaxH3ChainPass2Prepare().prepare(
+            {"samples": torch.ones(
+                (1, 24, 16, 4, 4), dtype=torch.float32)},
+            current[3], FakeModel(), FakeNoise(),
+            torch.tensor([0.24, 0.0], dtype=torch.float32),
+            resumed_drift_state)
+        drift_streams = chain._streams_from_latent(drift_prepared[0])
+        drift_masks = chain._streams_from_latent({
+            "samples": drift_prepared[0]["noise_mask"]})
+        assert torch.allclose(
+            drift_streams[0][:, :, :12], previous_hq_video[:, :, -12:])
+        assert torch.allclose(
+            drift_streams[0][:, :, 12:],
+            torch.full_like(drift_streams[0][:, :, 12:], 1.24))
+        assert torch.all(drift_masks[0][:, :, :12] == 0)
+        assert torch.all(drift_masks[0][:, :, 12:] == 1)
+        assert "previous HQ latent tail spliced and protected" in (
+            drift_prepared[3])
+        derope_continuity = (
+            upscale.MiniMaxH3ChainDeropeContinuity().splice(
+                resumed_drift_state,
+                {"samples": torch.ones(
+                    (1, 24, 16, 4, 4), dtype=torch.float32)}))
+        assert torch.allclose(
+            derope_continuity[0]["samples"][:, :, :12],
+            previous_hq_video[:, :, -12:])
+        assert "previous HQ latent tail spliced and protected" in (
+            derope_continuity[1])
+
+        # The same nodes may run inline from Current Shot. Boundary guarding
+        # follows actual future visual consumers rather than scene numbering,
+        # and continuity uses Chain Context's resolved non-linear/composed
+        # visual state instead of the immediate predecessor's video stream.
+        direct_plan = {
+            "compatibility": {
+                "continuation_mode": "drift_control_av",
+                "context_length": 39,
+            },
+            "shots": [{
+                "id": "direct_1",
+                "raw_frames": 56,
+                "delivered_frames": 17,
+                "continuation_mode": "drift_control_av",
+            }, {
+                "id": "direct_2_hard_cut",
+                "raw_frames": 56,
+                "delivered_frames": 17,
+                "continuation_mode": "drift_control_av",
+                "context_length": 0,
+            }, {
+                "id": "direct_3_from_1",
+                "raw_frames": 56,
+                "delivered_frames": 17,
+                "continuation_mode": "drift_control_av",
+                "context_length": 39,
+                "visual_context_source": "direct_1",
+            }],
+        }
+        direct_state_1 = {
+            "plan": direct_plan,
+            "index": 1,
+            "previous_latent": None,
+            "segments": [],
+        }
+        direct_guard_1 = upscale.MiniMaxH3ChainDeropeGuard().guard(
+            direct_state_1, json.dumps({
+                "holds": [4] * 56,
+                "world_len": 56,
+            }))
+        assert direct_guard_1[1:4] == (False, 39, 17)
+        assert json.loads(direct_guard_1[0])[
+            "h3_chain_visual_consumers"] == [3]
+        direct_state_2 = {**direct_state_1, "index": 2}
+        direct_guard_2 = upscale.MiniMaxH3ChainDeropeGuard().guard(
+            direct_state_2, json.dumps({
+                "holds": [4] * 56,
+                "world_len": 56,
+            }))
+        assert direct_guard_2[1:4] == (True, 39, 0)
+
+        immediate_video = torch.full(
+            (1, 24, 17, 4, 4), 9.0, dtype=torch.float32)
+        selected_video = torch.full(
+            (1, 24, 17, 4, 4), 3.0, dtype=torch.float32)
+        context_audio = torch.zeros(
+            (1, 32, 2, 9), dtype=torch.float32)
+        direct_state_3 = {
+            "plan": direct_plan,
+            "index": 3,
+            "previous_latent": {
+                "samples": [immediate_video, context_audio]},
+            "segments": [],
+            "_visual_context_state": {
+                "_visual_context_target": 3,
+                "_visual_context_source": 1,
+                "_visual_context_lead_source": 0,
+                "_visual_context_lead_frames": 0,
+                "_visual_context_signature": ((1, 39, -1, False),),
+                "previous_latent": {
+                    "samples": [selected_video, context_audio]},
+            },
+        }
+        direct_continuity = (
+            upscale.MiniMaxH3ChainDeropeContinuity().splice(
+                direct_state_3,
+                {"samples": torch.ones(
+                    (1, 24, 17, 4, 4), dtype=torch.float32)}))
+        assert torch.allclose(
+            direct_continuity[0]["samples"][:, :, :12],
+            selected_video[:, :, -12:])
+        assert "resolved chain visual context" in direct_continuity[1]
+        try:
+            upscale.MiniMaxH3ChainRecoveredAV().pack(
+                direct_state_3,
+                {"samples": torch.ones(
+                    (1, 24, 17, 4, 4), dtype=torch.float32)})
+        except ValueError as exc:
+            assert "requires recovered audio_latent" in str(exc)
+        else:
+            raise AssertionError(
+                "Live-chain Recovered AV accepted a video-only checkpoint")
+        direct_recovered = upscale.MiniMaxH3ChainRecoveredAV().pack(
+            direct_state_3,
+            {"samples": torch.ones(
+                (1, 24, 17, 4, 4), dtype=torch.float32)},
+            {"samples": context_audio})
+        assert len(chain._streams_from_latent(direct_recovered[0])) == 2
+        fallback_state = {**resumed_drift_state, "previous_latent": None}
+        fallback_prepared = upscale.MiniMaxH3ChainPass2Prepare().prepare(
+            {"samples": torch.ones(
+                (1, 24, 16, 4, 4), dtype=torch.float32)},
+            current[3], FakeModel(), FakeNoise(),
+            torch.tensor([0.24, 0.0], dtype=torch.float32), fallback_state)
+        fallback_streams = chain._streams_from_latent(fallback_prepared[0])
+        fallback_masks = chain._streams_from_latent({
+            "samples": fallback_prepared[0]["noise_mask"]})
+        assert torch.all(fallback_streams[0][:, :, :12] == 1)
+        assert torch.all(fallback_masks[0][:, :, :12] == 0)
+        assert "source prefix protected" in fallback_prepared[3]
+
+        hq_images = torch.zeros((5, 64, 64, 3), dtype=torch.float32)
+        saved_result = upscale.MiniMaxH3ChainUpscaleSegmentSave().save(
+            upscale_state, hq_images)
+        hq_segment = saved_result["result"][0]
+        assert not hq_segment["latent_saved"]
+        hq_checkpoint = pathlib.Path(
+            chain._absolute_output_path(hq_segment["checkpoint"]))
+        with safe_open(hq_checkpoint, framework="pt", device="cpu") as saved:
+            assert "delivered_audio" in saved.keys()
+            assert "upscaled_video" not in saved.keys()
+
+        recovered_audio_state = {
+            **upscale_state,
+            "profile": "recovered-audio",
+        }
+        recovered_audio = audio_for_frames(5)
+        recovered_audio["waveform"].fill_(0.5)
+        recovered_audio_segment = (
+            upscale.MiniMaxH3ChainUpscaleSegmentSave().save(
+                recovered_audio_state, hq_images,
+                recovered_audio=recovered_audio)["result"][0])
+        assert recovered_audio_segment["audio_route"] == (
+            "recovered de-rope audio")
+        with safe_open(chain._absolute_output_path(
+                recovered_audio_segment["checkpoint"]), framework="pt",
+                device="cpu") as saved:
+            assert torch.all(saved.get_tensor("delivered_audio") == 0.5)
+
+        partial = upscale.MiniMaxH3ChainUpscaleLoopEnd().end(
+            flow, upscale_state, hq_images, hq_segment)[0]
+        assert partial["format"] == "h3_chain_upscale_partial_manifest_v1"
+
+        flow, upscale_state, source_manifest, _status = adapter.adapt(
+            selected_manifest, "quality", "h3_latent", '{"scale":2}',
+            2, 0, False, 18)
+        assert len(upscale_state["segments"]) == 1
+        current = upscale.MiniMaxH3ChainUpscaleCurrent().current(upscale_state)
+        assert current[4] == 2
+        assert torch.all(current[2]["samples"] == 0.85)
+        second_raw = int(source_2["raw_frames"])
+        hq_images_2 = torch.zeros(
+            (second_raw, 64, 64, 3), dtype=torch.float32)
+        hq_segment_2 = upscale.MiniMaxH3ChainUpscaleSegmentSave().save(
+            upscale_state, hq_images_2)["result"][0]
+        manifest = upscale.MiniMaxH3ChainUpscaleLoopEnd().end(
+            flow, upscale_state, hq_images_2, hq_segment_2)[0]
+        assert manifest["format"] == "h3_chain_upscale_manifest_v1"
+        assert manifest["profile"] == "quality"
+        assert len(manifest["segments"]) == 2
+        assert not manifest["latent_saving"]
+        merged_result = chain.MiniMaxH3ChainAssemble().assemble(
+            manifest, "generated", "final", 96,
+            copy_to_output=True, output_subfolder="published_upscale")
+        merged = merged_result["result"][0]
+        merged_path = pathlib.Path(merged)
+        assert merged_path.is_file() and merged_path.stat().st_size > 0
+        assert merged_path.parent == (
+            pathlib.Path(temporary) / "h3_chains" / "upscale_test" /
+            "upscaled" / "quality" / "final")
+        output_copy = (pathlib.Path(temporary) / "published_upscale" /
+                       merged_path.name)
+        assert output_copy.is_file() and output_copy.stat().st_size > 0
+        final_record = merged_path.with_suffix(".json")
+        assert json.loads(final_record.read_text(encoding="utf-8"))[
+            "format"] == "h3_chain_upscale_final_v1"
+        legacy_merged = upscale.MiniMaxH3ChainUpscaleMerge().merge(
+            manifest, "none", "legacy_wrapper", 96)["result"][0]
+        assert pathlib.Path(legacy_merged).parent == merged_path.parent
+
+        _flow, latent_state, _manifest, _ = adapter.adapt(
+            selected_manifest, "archive_latent", "h3_latent", "{}",
+            1, 0, True, 18)
+        try:
+            upscale.MiniMaxH3ChainUpscaleSegmentSave().save(
+                latent_state, hq_images)
+        except ValueError as exc:
+            assert "received no HQ latent" in str(exc)
+        else:
+            raise AssertionError("save_latent accepted a missing HQ latent")
+        latent_segment = upscale.MiniMaxH3ChainUpscaleSegmentSave().save(
+            latent_state, hq_images, av_latent(1.0))["result"][0]
+        with safe_open(chain._absolute_output_path(
+                latent_segment["checkpoint"]), framework="pt",
+                device="cpu") as saved:
+            assert {"upscaled_video", "upscaled_audio"} <= set(saved.keys())
+
+        # Deferred DeRoPE -> latent upscale, using actual CPU safetensors and
+        # the same immutable selection contract emitted by Checkpoint Manager.
+        from importlib import import_module
+        catalogue = import_module(package.__name__ + ".checkpoint_variants")
+        sources = import_module(package.__name__ + ".deferred_checkpoint_source")
+        saver = upscale.MiniMaxH3ChainUpscaleSegmentSave()
+        originals = [{"scene": item["index"], "revision": item["revision"],
+                      "checkpoint_sha256": item["checkpoint_sha256"]}
+                     for item in selected_manifest["segments"]]
+
+        def processing_selection(profile):
+            records = catalogue.saved_checkpoint_variants(temporary, "upscale_test", originals)["variants"]
+            record = next(item for item in records if item["profile"] == profile)
+            assert record["processing_branch"]
+            return {"stage": "derope", "profile_path": record["profile_path"],
+                    "branch": record["processing_branch"]}
+
+        def rejected(call, message):
+            try:
+                call()
+            except (ValueError, FileNotFoundError) as exc:
+                assert message.lower() in str(exc).lower(), str(exc)
+            else:
+                raise AssertionError("Expected rejection: " + message)
+
+        _flow, motion_state, _, _ = adapter.adapt(
+            selected_manifest, "motion", "h3_latent", '{"derope":true}', 1, 0, True, 18)
+        recovered = upscale.MiniMaxH3ChainRecoveredAV().pack(
+            motion_state, {"samples": torch.full((1, 24, 2, 4, 4), 0.6)},
+            {"samples": torch.full((1, 32, 2, 9), 0.4)})[0]
+        recovered_wave = audio_for_frames(5)
+        recovered_wave["waveform"].fill_(0.3)
+        motion = saver.save(motion_state, hq_images, recovered, recovered_wave)["result"][0]
+        choice = processing_selection("motion")
+        processed = manager.passthrough(json.dumps({**json.loads(selection), "processing_source": choice}))[0]
+        assert processed["clip_count"] == 2  # Never pin only the previewed prefix.
+        assert processed["segments"][0]["revision"] == motion["revision"]
+        assert processed["segments"][1] == selected_manifest["segments"][1]  # absent -> original
+        assert processed["segments"][0]["processing_source"]["original"] == selected_manifest["segments"][0]
+        assert selected_manifest["segments"][0]["revision"] == source["revision"]
+        _, processed_state, _, _ = adapter.adapt(processed, "after_motion", "h3_latent", "{}", 1, 0, True, 18)
+        read = upscale.MiniMaxH3ChainUpscaleCurrent().current(processed_state)
+        assert torch.all(read[2]["samples"] == 0.6)
+        assert torch.all(read[3]["samples"] == 0.4)
+        assert torch.all(read[13]["waveform"] == 0.3)
+        assert read[7:9] == (64, 64)
+        assert "recovered DeRoPE" in read[-1]
+        # Ref2VA's legacy lookup must use original generation geometry even
+        # when the DeRoPE save already changed the canvas.
+        from unittest.mock import patch
+        with patch.object(chain, "_find_reference_cache", return_value=None) as lookup:
+            upscale.MiniMaxH3ChainUpscaleReferenceConditioning().condition(
+                processed_state, FakeClip(), missing_cache="text_only")
+            assert lookup.call_args.args[4:6] == (32, 32)
+        rejected(lambda: adapter.adapt(processed, "motion", "h3_latent", "{}", 1, 0, True, 18), "new output profile")
+        # Saving a second processing stage keeps transitive provenance.
+        after = saver.save(processed_state, hq_images, recovered)["result"][0]
+        after_record = next(item for item in catalogue.saved_checkpoint_variants(
+            temporary, "upscale_test", originals)["variants"] if item["revision"] == after["revision"])
+        assert after_record["originals"] == [{"scene": 1, "revision": source["revision"]}]
+        _, resumed, _, _ = adapter.adapt(processed, "after_motion", "h3_latent", "{}", 2, 0, True, 18)
+        assert resumed["index"] == 2 and len(resumed["segments"]) == 1
+        assert torch.all(upscale.MiniMaxH3ChainUpscaleCurrent().current(resumed)[2]["samples"] == 0.85)
+        # A video-only DeRoPE save reuses the exact original denoised audio,
+        # while its delivered audio is read from the processing checkpoint.
+        _, single_state, _, _ = adapter.adapt(selected_manifest, "motion_video", "h3_latent", '{"derope":true}', 1, 0, True, 18)
+        single = {"samples": torch.full((1, 24, 2, 4, 4), 0.2)}
+        saver.save(single_state, hq_images, single)
+        single_manifest = sources.derope_source_manifest(selected_manifest, processing_selection("motion_video"), chain, upscale)
+        loaded = upscale._load_source_tensors(single_manifest["segments"][0])
+        assert torch.all(loaded["video"] == 0.2) and torch.all(loaded["audio"] == 0.75)
+        assert set(upscale._load_source_tensors(single_manifest["segments"][0], ("delivered_audio",))) == {"delivered_audio"}
+        saved_single, layout = upscale._latent_checkpoint_tensors({"samples": torch.zeros((2, 24, 2, 4, 4))})
+        assert layout == "single" and tuple(saved_single["upscaled_samples"].shape) == (2, 24, 2, 4, 4)
+        assert tuple(upscale._cpu_latent(single)["samples"].shape) == (1, 24, 2, 4, 4)
+        # Recover the accidentally omitted B=1 axis in older video-only saves.
+        legacy = json.loads(json.dumps(single_manifest["segments"][0]))
+        legacy_path = pathlib.Path(temporary) / "legacy_single.safetensors"
+        chain._st_save({"upscaled_samples": single["samples"][0].clone()}, str(legacy_path))
+        legacy.update(checkpoint="legacy_single.safetensors", checkpoint_sha256=chain._file_sha256(str(legacy_path)))
+        upscale._validate_processed_latent_header(legacy)
+        assert tuple(upscale._load_source_tensors(legacy)["video"].shape) == (1, 24, 2, 4, 4)
+        rejected(lambda: saver.save(single_state, hq_images, single, recovered_wave), "audio_latent")
+        rejected(lambda: saver.save(single_state, hq_images, {"samples": torch.zeros((1, 24, 7, 4, 4))}), "RAW clock")
+        rejected(lambda: saver.save(single_state, hq_images, {"samples": [single["samples"], torch.zeros((1, 32, 2, 100))]}), "audio latent")
+        # Chapter-local sources retain original indexes and scheduling clocks.
+        chapter = json.loads(json.dumps(selected_manifest))
+        chapter.update(segments=[chapter["segments"][1]], clip_count=1,
+                       total_delivered_frames=source_2["delivered_frames"], scene_start=2, scene_end=2,
+                       source_scene_count=13, chapter={"number": 2, "id": "second", "start_scene": 2,
+                       "end_scene": 2, "planned_end_scene": 2, "complete": True, "source_start_frame": 5})
+        _, chapter_state, _, _ = adapter.adapt(chapter, "chapter_motion", "h3_latent", '{"derope":true}', 1, 0, True, 18)
+        chapter_video = {"samples": torch.zeros((1, 24, (second_raw - 5) // 17 * 5 + 2, 4, 4))}
+        chapter_child = saver.save(chapter_state, hq_images_2, chapter_video)["result"][0]
+        chapter_choice = processing_selection("chapter_motion")
+        assert "/chapters/" in chapter_choice["profile_path"]
+        chapter_processed = sources.derope_source_manifest(chapter, chapter_choice, chain, upscale)
+        _, chapter_next, _, _ = adapter.adapt(chapter_processed, "chapter_after", "h3_latent", "{}", 1, 0, True, 18)
+        chapter_read = upscale.MiniMaxH3ChainUpscaleCurrent().current(chapter_next)
+        assert chapter_read[4:6] == (2, 13)
+        assert chapter_processed["chapter"]["source_start_frame"] == 5
+        assert chapter_processed["segments"][0]["revision"] == chapter_child["revision"]
+        # Availability/lineage failures must not silently substitute originals.
+        _, preview_state, _, _ = adapter.adapt(selected_manifest, "motion_preview", "h3_latent", '{"derope":true}', 1, 0, False, 18)
+        saver.save(preview_state, hq_images)
+        rejected(lambda: sources.derope_source_manifest(selected_manifest, processing_selection("motion_preview"), chain, upscale), "no full latent")
+        wrong = json.loads(json.dumps(selected_manifest))
+        wrong["segments"][0]["revision"] = "f" * 32
+        rejected(lambda: sources.derope_source_manifest(wrong, choice, chain, upscale), "different original take")
+        wrong["segments"][0]["adopted_from_revision"] = source["revision"]
+        assert sources.derope_source_manifest(wrong, choice, chain, upscale)["segments"][0]["revision"] == motion["revision"]
+        rejected(lambda: sources.derope_source_manifest(selected_manifest, {**choice, "profile_path": "../escape"}, chain, upscale), "outside")
+        changed = json.loads(json.dumps(choice))
+        changed["branch"]["lineage"][0]["revision"] = "e" * 32
+        rejected(lambda: sources.derope_source_manifest(selected_manifest, changed, chain, upscale), "branch changed")
+        # Delete a real saved chapter take during a downstream encode. The
+        # saver must not publish a new branch against its now-deleted source.
+        deletion = import_module(package.__name__ + ".processing_checkpoint_delete")
+        processing_manager = deletion.ProcessingCheckpointManager(temporary)
+        delete_preview = processing_manager.deletion_preview(
+            "upscale_test", chapter_child["revision_metadata"])
+        assert delete_preview["allowed"]
+        write_video = chain._write_segment_video
+
+        def delete_source_during_encode(*args, **kwargs):
+            result = write_video(*args, **kwargs)
+            processing_manager.delete("upscale_test", chapter_child["revision_metadata"],
+                                      delete_preview["snapshot"])
+            return result
+
+        with patch.object(chain, "_write_segment_video", side_effect=delete_source_during_encode):
+            rejected(lambda: saver.save(chapter_next, hq_images_2, chapter_video), "deleted")
+        failed_profile = pathlib.Path(upscale._state_profile_paths(chapter_next, 2)["metadata"]).parent.parent
+        assert not any(path.is_file() for path in failed_profile.rglob("*"))
+        assert pathlib.Path(chain._absolute_output_path(source_2["checkpoint"])).is_file()
+        assert not any(item["revision"] == chapter_child["revision"] for item in
+                       catalogue.saved_checkpoint_variants(temporary, "upscale_test", originals)["variants"])
+        # Existing saves can use the exact full/partial profile manifest.
+        motion_metadata = chain._read_json(chain._absolute_output_path(motion["revision_metadata"]))
+        motion_metadata.pop("processing_lineage")
+        chain._atomic_json(chain._absolute_output_path(motion["revision_metadata"]), motion_metadata)
+        legacy_choice = processing_selection("motion")
+        assert legacy_choice["branch"]["kind"] == "manifest"
+        assert sources.derope_source_manifest(selected_manifest, legacy_choice, chain, upscale)["segments"][0]["revision"] == motion["revision"]
+        pathlib.Path(chain._absolute_output_path(motion["checkpoint"])).unlink()
+        rejected(lambda: sources.derope_source_manifest(selected_manifest, legacy_choice, chain, upscale), "missing")
+
+    print("H3 upscale child run: denoised source preference, optional HQ latent, "
+          "self-contained audio, unified manifest, assembler, and output copy pass")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_upscale_pixel_unit_test.py b/ComfyUI-MiniMaxH3-Context-Loop/tests/_upscale_pixel_unit_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..a0b546367a8635260aae01e10c2f151d04ec79f1
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_upscale_pixel_unit_test.py
@@ -0,0 +1,710 @@
+#!/usr/bin/env python3
+"""CPU pixel-loop integration: real checkpoints/media, fake VAE and CLIP.
+
+Set COMFYUI_PATH when ComfyUI is not adjacent to the checkout. No weights,
+external image upscalers, live projects or GPU sampling are used.
+"""
+import copy
+import gc
+import importlib.util
+import json
+import os
+from pathlib import Path
+import sys
+import subprocess
+import tempfile
+import weakref
+from types import SimpleNamespace
+from unittest.mock import patch
+
+ROOT = Path(__file__).resolve().parents[1]
+candidates = [Path(os.environ["COMFYUI_PATH"])] if os.environ.get("COMFYUI_PATH") else []
+candidates += [ROOT.parent / "Comfyui", ROOT.parent / "ComfyUI"]
+COMFY = next(path for path in candidates if (path / "comfy/options.py").is_file())
+sys.path.insert(0, str(COMFY))
+sys.argv = ["h3-pixel-test", "--cpu"]
+import comfy.options
+comfy.options.enable_args_parsing()
+import folder_paths
+import torch
+
+
+def fails(call, text):
+    try:
+        call()
+    except ValueError as exc:
+        assert text in str(exc), str(exc)
+    else:
+        raise AssertionError("Expected failure: " + text)
+
+
+class VideoVAE:
+    def decode(self, video):
+        assert video.ndim == 5 and video.shape[1] == 24
+        assert torch.all(video == 0.75), "must use saved clean x0, not noisy AV"
+        return torch.linspace(0, 1, 5).view(5, 1, 1, 1).expand(5, 32, 32, 3)
+
+    def encode(self, images):
+        return torch.ones(1, 24, 2, images.shape[1] // 16, images.shape[2] // 16)
+
+
+class Clip:
+    def tokenize(self, prompt, **kwargs):
+        return {"prompt": prompt, "presentation": kwargs.get("minimax_ref_items", [])}
+
+    def encode_from_tokens_scheduled(self, tokens):
+        return [[torch.zeros(1, 1, 4), {"tokens": tokens}]]
+
+
+def assert_extended_selection_resume(chain, upscale, chapter_source, frames):
+    """Save only scene 8, extend to 8..10, resume 9 without redoing 8."""
+    adapter = upscale.MiniMaxH3ChainUpscaleAdapter()
+    short = copy.deepcopy(chapter_source)
+    short.update(scene_end=8, clip_count=1, segments=short["segments"][:1])
+    short["chapter"]["end_scene"] = 8
+    short["total_delivered_frames"] = short["segments"][0]["delivered_frames"]
+    short["duration_seconds"] = short["total_delivered_frames"] / 24
+    _, state, _, _ = adapter.adapt(short, "extended-prefix", "pixel", "{}", 1, 0, False, 18)
+    saved = upscale.MiniMaxH3ChainUpscaleSegmentSave().save(state, frames)["result"][0]
+    metadata_path = chain._absolute_output_path(saved["metadata"])
+    metadata = chain._read_json(metadata_path)
+    assert metadata["source_scene_contract"]
+    artifacts = {Path(chain._absolute_output_path(saved[key])) for key in (
+        "checkpoint", "segment", "revision_metadata")}
+    original = {path:path.read_bytes() for path in artifacts}
+
+    def resume(source=chapter_source, backend="pixel", recipe="{}", crf=18):
+        return adapter.adapt(source, "extended-prefix", backend, recipe, 9, 0, False, crf)[1]
+
+    extended = resume()
+    assert extended["index"] == 9 and extended["end_clip"] == 10
+    assert extended["source_manifest_hash"] != state["source_manifest_hash"]
+    assert extended["segments"][0]["revision"] == saved["revision"]
+    assert all(path.read_bytes() == data for path, data in original.items())
+    # Only completed sources matter; later scenes can be added/replaced.
+    future_changed = copy.deepcopy(chapter_source)
+    future_changed["segments"][2]["revision"] = "f" * 32
+    assert resume(future_changed)["segments"][0]["revision"] == saved["revision"]
+    for key, changed in (("revision", "f" * 32), ("checkpoint_sha256", "f" * 64),
+                         ("segment_sha256", "f" * 64), ("prompt", "Changed prompt"),
+                         ("seed", 123456), ("raw_frames", 22),
+                         ("delivered_frames", 4), ("context_length", 17)):
+        source = copy.deepcopy(chapter_source["segments"][0])
+        source[key] = changed
+        fails(lambda: upscale._verify_upscale_source(metadata, source, 8), "source")
+    fails(lambda: resume(backend="h3_latent"), "different profile settings")
+    fails(lambda: resume(recipe='{"denoise":0.5}'), "different profile settings")
+    fails(lambda: resume(crf=20), "different profile settings")
+
+    # Existing saves have no per-scene contract; the retained source hashes,
+    # frame clock, prompt, seed and steps are sufficient for this migration.
+    legacy = copy.deepcopy(metadata)
+    legacy.pop("source_scene_contract")
+    chain._atomic_json(metadata_path, legacy)
+    assert resume()["segments"][0]["revision"] == saved["revision"]
+    changed = copy.deepcopy(chapter_source)
+    changed["segments"][0]["revision"] = "f" * 32
+    fails(lambda: resume(changed), "different source revision")
+    for key, value in (("run_name", "other"), ("profile", "other")):
+        chain._atomic_json(metadata_path, {**legacy, key:value})
+        fails(resume, "different run or profile")
+    chain._atomic_json(metadata_path, legacy)
+    # Existing artifact integrity checks still run, even on an extended range.
+    damaged = copy.deepcopy(legacy)
+    damaged["segment"]["checkpoint_sha256"] = "f" * 64
+    chain._atomic_json(metadata_path, damaged)
+    fails(resume, "checkpoint")
+    chain._atomic_json(metadata_path, legacy)
+    assert all(path.read_bytes() == data for path, data in original.items())
+
+
+def assert_independent_pixel_cleanup(chain, upscale, state, manifest, frames):
+    """Real saver metadata, safe deletion, and gap repair without changing S10."""
+    processing = importlib.import_module(upscale.__package__ + ".processing_checkpoint_delete")
+    manager = processing.ProcessingCheckpointManager(chain._output_root())
+    first, middle, last = manifest["segments"]
+    preview = manager.deletion_preview(state["run_name"], middle["revision_metadata"])
+    assert preview["allowed"], preview["dependents"]
+    assert preview["retained_independent_takes"][0]["revision"] == last["revision"]
+    last_files = {Path(chain._absolute_output_path(last[key])) for key in
+                  ("segment", "checkpoint", "generated_audio", "prompt_file", "metadata", "revision_metadata")}
+    last_bytes = {path:path.read_bytes() for path in last_files}
+    manager.delete(state["run_name"], middle["revision_metadata"], preview["snapshot"])
+    upscale._verify_upscale_segment(last, last["index"])
+    assert all(path.read_bytes() == value for path, value in last_bytes.items())
+    # The already-running saver still carries the deleted scene in its
+    # prefix. Its transaction must fail without touching the retained S10.
+    saver = upscale.MiniMaxH3ChainUpscaleSegmentSave()
+    fails(lambda: saver.save(state, frames), "deleted")
+    assert all(path.read_bytes() == value for path, value in last_bytes.items())
+    try:
+        upscale._load_upscale_prefix(state, last["index"])
+    except FileNotFoundError as exc:
+        assert "scene 9 metadata is missing" in str(exc)
+    else:
+        raise AssertionError("a missing middle scene must not be silently skipped")
+    adapter = upscale.MiniMaxH3ChainUpscaleAdapter()
+    _, repair, _, _ = adapter.adapt(
+        state["source_manifest"], state["profile"], "pixel", "{}", middle["index"], middle["index"], False, 18)
+    assert repair["segments"][0]["revision"] == first["revision"]
+    rebuilt = saver.save(repair, frames)["result"][0]
+    assert rebuilt["revision"] != middle["revision"]
+    assert all(path.read_bytes() == value for path, value in last_bytes.items())
+    kept_sequence = upscale._load_upscale_prefix(repair, last["index"] + 1)
+    assert [s["revision"] for s in kept_sequence] == [first["revision"], rebuilt["revision"], last["revision"]]
+    validated = upscale._upscale_manifest(repair, kept_sequence, complete=True)
+    upscale._validate_upscale_manifest(validated)
+
+
+def assert_loop_releases_pixels(package, chain, upscale, manifest, ram_cache=False, png_export=False):
+    """Run the real recursive Comfy executor, without models or a live server.
+
+    NullCache deliberately evicts ordinary node outputs. Pending subgraph
+    input references still survive there, so this detects the original leak
+    independently of Comfy's discretionary RAM-pressure cache policy.
+    """
+    import execution
+    import nodes
+    old_frames = []
+    rendered = []
+    consumed = []
+
+    def evict_finished_images():
+        if not ram_cache:
+            return
+        # Model ordinary output-cache eviction independently of scheduler
+        # ownership. The production RAM-pressure policy is free to retain
+        # outputs until needed; it must be ABLE to release finished scenes.
+        old_ids = {id(ref()) for ref in old_frames if ref() is not None}
+        def contains_old(value):
+            if isinstance(value, dict):
+                return any(contains_old(v) for v in value.values())
+            if isinstance(value, (list, tuple)):
+                return any(contains_old(v) for v in value)
+            return id(value) in old_ids
+        cache = executor.caches.outputs
+        for key, entry in list(cache.cache.items()):
+            if contains_old(entry.outputs):
+                cache.cache.pop(key)
+                cache.timestamps.pop(key, None)
+                cache.used_generation.pop(key, None)
+
+    class Pixels:
+        @classmethod
+        def INPUT_TYPES(cls):
+            return {"required": {"state": (upscale.UPSCALE_STATE_TYPE,)}}
+        RETURN_TYPES = (upscale.UPSCALE_STATE_TYPE, "IMAGE", "VIDEO")
+        FUNCTION = "make"
+
+        def make(self, state):
+            evict_finished_images()
+            gc.collect()
+            assert all(ref() is None for ref in old_frames), (
+                "A waiting loop node still pins a completed scene's pixels")
+            scene = int(state["index"])
+            source = upscale._source_segment(state)
+            images = torch.full((source["raw_frames"], 64, 96, 3), scene / 10)
+            old_frames.append(weakref.ref(images))
+            rendered.append(scene)
+            video = None
+            if png_export:
+                import av
+                from comfy_api.latest import InputImpl
+                path = Path(chain._output_root()) / ("memory_scene_%d.mkv" % scene)
+                with av.open(str(path), "w") as container:
+                    stream = container.add_stream("ffv1", rate=24)
+                    stream.width, stream.height, stream.pix_fmt = 96, 64, "bgr0"
+                    for number, image in enumerate(images):
+                        frame = av.VideoFrame.from_ndarray((image * 255).round().byte().numpy(), format="rgb24")
+                        frame.pts = number
+                        container.mux(stream.encode(frame))
+                    container.mux(stream.encode())
+                video = InputImpl.VideoFromFile(str(path))
+            return state, images, video
+
+    class AfterPNG:
+        @classmethod
+        def INPUT_TYPES(cls):
+            return {"required": {"video": ("VIDEO",), "images": ("IMAGE",), "folder": ("STRING",)}}
+        RETURN_TYPES = ("IMAGE",)
+        FUNCTION = "ready"
+
+        def ready(self, video, images, folder):
+            # This dependency gate models the native VIDEO saver/loop boundary.
+            # PNG publication must have finished before either may advance.
+            record = json.loads((Path(folder) / "export.json").read_text())
+            assert record["last_scene"] == rendered[-1]
+            assert len(record["clips"]) == len(rendered)
+            assert video is not None
+            return (images,)
+
+    class Result:
+        @classmethod
+        def INPUT_TYPES(cls):
+            return {"required": {"manifest": (upscale.UPSCALE_MANIFEST_TYPE,),
+                                 "tail": ("IMAGE",)}}
+        RETURN_TYPES = ()
+        FUNCTION = "consume"
+        OUTPUT_NODE = True
+
+        def consume(self, manifest, tail):
+            assert len(manifest["segments"]) == len(rendered) == 2, rendered
+            assert torch.all(tail == rendered[-1] / 10)
+            consumed.append(manifest)
+            return ()
+
+    prompt = {
+        "adapter": {"class_type": "MiniMaxH3ChainUpscaleAdapter", "inputs": {
+            "source_manifest": manifest, "profile": "memory-test-" + str(ram_cache) + ("-png" if png_export else ""), "backend": "pixel",
+            "recipe_json": "{}", "start_clip": 1, "end_clip": 0,
+            "save_latent": False, "segment_crf": 18}},
+        "pixels": {"class_type": "MemoryTestPixels", "inputs": {"state": ["adapter", 1]}},
+        "save": {"class_type": "MiniMaxH3ChainUpscaleSegmentSave", "inputs": {
+            "state": ["pixels", 0], "images": ["pixels", 1]}},
+        "end": {"class_type": "MiniMaxH3ChainUpscaleLoopEnd", "inputs": {
+            "flow": ["adapter", 0], "state": ["pixels", 0],
+            "images": ["pixels", 1], "segment": ["save", 0]}},
+        "result": {"class_type": "MemoryTestResult", "inputs": {
+            "manifest": ["end", 0], "tail": ["end", 2]}},
+    }
+    if png_export:
+        prompt["png"] = {"class_type": "MiniMaxH3ChainExportPNG", "inputs": {
+            "video": ["pixels", 2], "state": ["pixels", 0], "export_name": "loop-sequence",
+            "first_frame_number": 1, "png_compression": 1, "embed_workflow": False,
+            "png_bit_depth": "16", "save_workers": 2}}
+        prompt["after_png"] = {"class_type": "MemoryTestAfterPNG", "inputs": {
+            "video": ["png", 4], "folder": ["png", 0], "images": ["pixels", 1]}}
+        prompt["save"]["inputs"]["images"] = ["after_png", 0]
+        prompt["end"]["inputs"]["images"] = ["after_png", 0]
+    server = SimpleNamespace(client_id=None, last_node_id=None,
+                             send_sync=lambda *a, **k: None)
+    executor = execution.PromptExecutor(server, execution.CacheType.RAM_PRESSURE if ram_cache else execution.CacheType.NONE,
+                                       {"ram": 0, "ram_inactive": 0})
+    class SaveForTest(upscale.MiniMaxH3ChainUpscaleSegmentSave):
+        # With no cache, eagerly scheduled OUTPUT_NODE saves can execute twice
+        # before the lazy boundary attaches its dependencies. Test the same
+        # saver through its explicit handoff dependency only.
+        OUTPUT_NODE = False
+
+    with patch.dict(nodes.NODE_CLASS_MAPPINGS, {
+            **package.NODE_CLASS_MAPPINGS, "MemoryTestPixels": Pixels,
+            "MemoryTestAfterPNG": AfterPNG,
+            "MemoryTestResult": Result,
+            "MiniMaxH3ChainUpscaleSegmentSave": (
+                upscale.MiniMaxH3ChainUpscaleSegmentSave if ram_cache else SaveForTest)}):
+        executor.execute(prompt, "pixel-memory-test", execute_outputs=["result"])
+    assert executor.success, executor.status_messages
+    assert len(consumed) == 1 and rendered == [1, 2]
+    evict_finished_images()
+    gc.collect()
+    assert all(ref() is None for ref in old_frames)
+
+
+def assert_attributed_branch_upscales(chain, upscale):
+    """Real save -> attach -> select -> cached conditioning -> HQ save/resume."""
+    with tempfile.TemporaryDirectory() as temporary:
+        folder_paths.output_directory = temporary
+        plan = chain.MiniMaxH3ChainPlan().build(
+            json.dumps({"shots": [{"id": f"attached_{i}", "prompt": "A quiet room.",
+                                    "length": 5, "steps": 2, "seed": str(i),
+                                    "context_length": 0, "audio_context_length": 0}
+                                   for i in (1, 2)]}),
+            "attached_pixel", "attached-pixel-cache", 32, 32, 1,
+            "video", "head", "disabled", "generated_audio", 1,
+            5 / 24, 2, 7, 18, 0, "guide")[0]
+        plan = chain._plan_with_source_audio(chain._plan_with_external_context(plan, None), None)
+        latent = {"samples": [torch.full((1, 24, 2, 2, 2), 0.75),
+                               torch.full((1, 32, 2, 9), 0.75)]}
+        audio = {"waveform": torch.full((1, 2, round(5 / 24 * 8000)), 0.25),
+                 "sample_rate": 8000}
+        sources = []
+        # Save an original branch, then a new scene-1 tip to receive scene 2.
+        for index in (1, 2, 1):
+            sources.append(chain.MiniMaxH3ChainSegmentSave().save(
+                chain._initial_state(plan, index), torch.zeros(5, 32, 32, 3),
+                latent, audio, denoised_latent=latent)["result"][0])
+        candidate, parent = sources[1:]
+        for index, source in ((1, parent), (2, candidate)):
+            chain._cache_reference_scene(
+                fingerprint="attached-pixel-cache", scene=index, scene_count=2,
+                prompt=source["prompt"], compiled_prompt="<Picture 1> in a quiet room.",
+                width=32, height=32, length=5, ref_image_size="match",
+                vae=VideoVAE(), audio_vae=None, pictures=[torch.ones(1, 32, 32, 3)],
+                videos=[], audios=[])
+        attached = chain.CheckpointGraphManager(temporary).attribute(
+            plan["run_name"], 1, parent["revision"], 2, candidate["revision"])
+        assert attached["created"]
+        before = {p: p.read_bytes() for p in Path(temporary).rglob("*") if p.is_file()}
+        manifest = chain.MiniMaxH3ChainCheckpointManager().passthrough({
+            "run_name": plan["run_name"], "output_mode": "workflow_local",
+            "lineage": [{"scene": 1, "revision": parent["revision"]},
+                        {"scene": 2, "revision": attached["revision"]}]})[0]
+        assert candidate["revision"] in manifest["archives"]["plan"]
+        assert manifest["segments"][1]["checkpoint"] == candidate["checkpoint"]
+        adapter = upscale.MiniMaxH3ChainUpscaleAdapter()
+        for index in (1, 2):
+            # Resuming the second scene verifies the HQ prefix too.
+            flow, state, _, _ = adapter.adapt(
+                manifest, "attached", "pixel", "{}", index, index, False, 18)
+            assert len(state["segments"]) == index - 1
+            current = upscale.MiniMaxH3ChainUpscalePixelCurrent().current(state, VideoVAE())
+            target = current[1].repeat_interleave(2, 1).repeat_interleave(2, 2)
+            conditioned = upscale.MiniMaxH3ChainUpscalePixelConditioning().condition(
+                state, Clip(), target, VideoVAE(), missing_cache="error")
+            assert conditioned[5] is True, "attached take must retain its source reference cache"
+            saved = upscale.MiniMaxH3ChainUpscaleSegmentSave().save(state, target)["result"][0]
+            assert saved["source_revision"] == (parent["revision"] if index == 1 else attached["revision"])
+            result = upscale.MiniMaxH3ChainUpscaleLoopEnd().end(flow, state, target, saved)[0]
+        upscale._validate_upscale_manifest(result)
+        assert len(result["segments"]) == 2
+        assembled = chain.MiniMaxH3ChainAssemble().assemble(
+            result, "plan", "attached_final", 128, False, "")["result"][0]
+        assert Path(assembled).is_file()
+        assert all(p.read_bytes() == content for p, content in before.items()), \
+            "upscaling must not rewrite either branch, its recovery snapshots or caches"
+
+
+def main():
+    spec = importlib.util.spec_from_file_location(
+        "h3_pixel_test", ROOT / "__init__.py", submodule_search_locations=[str(ROOT)])
+    package = importlib.util.module_from_spec(spec)
+    sys.modules[spec.name] = package
+    spec.loader.exec_module(package)
+    chain = sys.modules[spec.name + ".chain_nodes"]
+    upscale = sys.modules[spec.name + ".upscale_nodes"]
+    for name in ("MiniMaxH3ChainUpscalePixelCurrent", "MiniMaxH3ChainUpscalePixelConditioning"):
+        cls = package.NODE_CLASS_MAPPINGS[name]
+        assert cls.EXPERIMENTAL and len(cls.OUTPUT_TOOLTIPS) == len(cls.RETURN_TYPES)
+
+    with tempfile.TemporaryDirectory() as temporary:
+        folder_paths.output_directory = temporary
+        plan = chain.MiniMaxH3ChainPlan().build(
+            json.dumps({"shots": [{"id": "pixel_%d" % i, "prompt": "A quiet room.",
+                                    "length": 5, "steps": 2, "seed": str(i)}
+                                   for i in (1, 2)]}),
+            "pixel_test", "pixel-test-cache", 32, 32, 1,
+            "video", "head", "disabled", "generated_audio", 1,
+            5 / 24, 2, 7, 18, 0, "guide")[0]
+        plan = chain._plan_with_source_audio(chain._plan_with_external_context(plan, None), None)
+        lineage = []
+        source_segments = []
+        for index in (1, 2):
+            state = chain._initial_state(plan, index)
+            delivered = int(plan["shots"][index - 1]["delivered_frames"])
+            latent = {"samples": [torch.full((1, 24, 2, 2, 2), 0.75),
+                                   torch.full((1, 32, 2, 9), 0.75)]}
+            audio = {"waveform": torch.full((1, 2, round(delivered / 24 * 8000)), index * 0.1),
+                     "sample_rate": 8000}
+            segment = chain.MiniMaxH3ChainSegmentSave().save(
+                state, torch.zeros(delivered, 32, 32, 3), latent, audio,
+                denoised_latent=latent)["result"][0]
+            source_segments.append(segment)
+            lineage.append({"scene": index, "revision": segment["revision"]})
+        manifest = chain.MiniMaxH3ChainCheckpointManager().passthrough(
+            json.dumps({"run_name": "pixel_test", "lineage": lineage}))[0]
+        original_files = {p: p.read_bytes() for p in Path(temporary).rglob("*") if p.is_file()}
+        pinned = chain.MiniMaxH3ChainCheckpointManager().passthrough(json.dumps({
+            "run_name": "pixel_test", "lineage": lineage,
+            "output_mode": "workflow_local"}))[0]
+        assert pinned == manifest, "local pin must preserve the source recipe and manifests"
+        manifest = pinned
+        assert_loop_releases_pixels(package, chain, upscale, manifest)
+        assert_loop_releases_pixels(package, chain, upscale, manifest, ram_cache=True)
+        assert_loop_releases_pixels(package, chain, upscale, manifest, ram_cache=True, png_export=True)
+        # Chapter output can combine takes with different catalog histories.
+        # Cache lookup must use the current take, including an empty legacy
+        # fingerprint, not the first chapter scene's catalog.
+        for fingerprint in ("second-scene-catalog", ""):
+            mixed = copy.deepcopy(manifest)
+            mixed["segments"][1]["generation_fingerprint"] = fingerprint
+            mixed["segments"][1].pop("reference_cache", None)
+            with patch.object(chain, "_find_reference_cache", return_value=None) as lookup:
+                try:
+                    upscale.MiniMaxH3ChainUpscaleReferenceConditioning().condition(
+                        {"source_manifest":mixed, "index":2}, Clip(), missing_cache="error")
+                except FileNotFoundError:
+                    pass
+                else:
+                    raise AssertionError("Expected a missing cache")
+                assert lookup.call_args.args[:2] == (fingerprint, 2)
+        adapter = upscale.MiniMaxH3ChainUpscaleAdapter()
+        flow, state, _, _ = adapter.adapt(manifest, "pixel", "pixel", "{}", 1, 0, False, 18)
+        reader = upscale.MiniMaxH3ChainUpscalePixelCurrent()
+        conditioner = upscale.MiniMaxH3ChainUpscalePixelConditioning()
+        schema = conditioner.INPUT_TYPES()
+        anchors = ("override_semantic_anchor_size", "override_semantic_anchor_mode")
+        assert list(schema["optional"])[-4:] == ["conditioning_width", "conditioning_height", *anchors]
+        assert list(schema["optional"])[:-4] == [
+            name for name in upscale.MiniMaxH3ChainUpscaleReferenceConditioning.INPUT_TYPES()["optional"]
+            if name not in ("video_vae", "target_video_latent", *anchors)]
+        for axis in ("width", "height"):
+            assert schema["optional"][f"conditioning_{axis}"][1]["default"] == 0
+        current = reader.current(state, VideoVAE())
+        assert current[1].shape == (5, 32, 32, 3)
+        assert current[2]["sample_rate"] == 8000 and current[4] == 1
+        source_tensors = upscale._load_source_tensors(manifest["segments"][0])
+        source_tensors.pop("delivered_audio")
+        with patch.object(upscale, "_load_source_tensors", return_value=source_tensors):
+            assert reader.current(state, VideoVAE())[2] is None
+        fails(lambda: reader.current({**state, "profile_config": {"backend": "h3_latent"}}, VideoVAE()),
+              "backend=pixel")
+        target = torch.zeros(5, 64, 96, 3)
+        result = conditioner.condition(state, Clip(), target, VideoVAE())
+        assert result[1] is target and result[2:4] == (96, 64)
+        assert "x3/y2" in result[-1] and result[5] is False
+        for bad, message in ((target[:4], "RAW RGB"), (target[..., :2], "RAW RGB"),
+                             (torch.zeros(5, 64, 80, 3), "multiples of 32")):
+            fails(lambda: conditioner.condition(state, Clip(), bad, VideoVAE()), message)
+        for axis in ("width", "height"):
+            for invalid in (-32, 1, 1080, 32.5, "64", None, 16416):
+                fails(lambda: conditioner.condition(state, Clip(), target, VideoVAE(),
+                      **{f"conditioning_{axis}":invalid}), f"conditioning_{axis} must be 0")
+
+        # Real cache-v2 RGB master rebuild, same canvas as latent counterpart,
+        # and no double scaling during the integrated sync step.
+        chain._cache_reference_scene(
+            fingerprint="pixel-test-cache", scene=1, scene_count=2,
+            prompt=source_segments[0]["prompt"], compiled_prompt="<Picture 1> in a quiet room.",
+            width=32, height=32, length=5, ref_image_size="match",
+            vae=VideoVAE(), audio_vae=None, pictures=[torch.ones(1, 64, 128, 3)],
+            videos=[], audios=[])
+        cached = conditioner.condition(state, Clip(), target, VideoVAE(), missing_cache="error")
+        assert cached[5] is True
+        latent_conditioning = upscale.MiniMaxH3ChainUpscaleReferenceConditioning().condition(
+            state, Clip(), "error", {"samples": torch.zeros(1, 24, 2, 4, 6)}, VideoVAE())
+        for actual, expected in zip(cached[0][0][1]["minimax_refs"],
+                                    latent_conditioning[0][0][1]["minimax_refs"]):
+            assert torch.equal(actual["latent"], expected["latent"])
+        assert torch.equal(cached[0][0][1]["tokens"]["presentation"][0]["data"],
+                           latent_conditioning[0][0][1]["tokens"]["presentation"][0]["data"])
+        auto = conditioner.condition(state, Clip(), target, VideoVAE(), missing_cache="error",
+                                     conditioning_width=0, conditioning_height=0)
+        assert auto[1] is target and auto[2:] == cached[2:]
+        assert torch.equal(auto[0][0][1]["minimax_refs"][0]["latent"],
+                           cached[0][0][1]["minimax_refs"][0]["latent"])
+        # Each zero is independent: manual dimensions size reference pictures
+        # while all image outputs continue to report the true target canvas.
+        for requested, expected_size in (((32, 32), (32, 32)),
+                                         ((64, 0), (64, 64)),
+                                         ((0, 32), (96, 32))):
+            custom = conditioner.condition(state, Clip(), target, VideoVAE(), missing_cache="error",
+                conditioning_width=requested[0], conditioning_height=requested[1])
+            expected = upscale.MiniMaxH3ChainUpscaleReferenceConditioning().condition(
+                state, Clip(), "error", video_vae=VideoVAE(), _target_size=expected_size)
+            assert custom[1] is target and custom[2:4] == (96, 64)
+            assert "conditioning canvas %dx%d" % expected_size in custom[-1]
+            assert torch.equal(custom[0][0][1]["minimax_refs"][0]["latent"],
+                               expected[0][0][1]["minimax_refs"][0]["latent"])
+            assert torch.equal(custom[0][0][1]["tokens"]["presentation"][0]["data"],
+                               expected[0][0][1]["tokens"]["presentation"][0]["data"])
+        assert custom[0][0][1]["minimax_refs"][0]["latent"].shape != \
+            cached[0][0][1]["minimax_refs"][0]["latent"].shape
+        # Connected references follow the same target path, not source size.
+        refs = chain.MiniMaxH3TaggedPictureReference().add(torch.ones(1, 64, 128, 3), "detail")[0]
+        connected = conditioner.condition(state, Clip(), target, VideoVAE(),
+            tagged_references=refs, prompt_override="@detail in a quiet room.", override_ref_image_size="match")
+        assert "canvas=96x64" in connected[-1]
+        assert torch.equal(connected[0][0][1]["minimax_refs"][0]["latent"],
+                           cached[0][0][1]["minimax_refs"][0]["latent"])
+        connected_custom = conditioner.condition(state, Clip(), target, VideoVAE(),
+            tagged_references=refs, prompt_override="@detail in a quiet room.",
+            override_ref_image_size="match", conditioning_width=32, conditioning_height=32)
+        cached_custom = conditioner.condition(state, Clip(), target, VideoVAE(), missing_cache="error",
+                                             conditioning_width=32, conditioning_height=32)
+        assert connected_custom[1] is target and connected_custom[2:4] == (96, 64)
+        assert "canvas=32x32" in connected_custom[-1]
+        assert torch.equal(connected_custom[0][0][1]["minimax_refs"][0]["latent"],
+                           cached_custom[0][0][1]["minimax_refs"][0]["latent"])
+        maximum = conditioner.condition(state, Clip(), target, VideoVAE(),
+            tagged_references=refs, prompt_override="@detail in a quiet room.", override_ref_image_size="max")
+        maximum_large = conditioner.condition(state, Clip(), torch.zeros(5, 96, 128, 3), VideoVAE(),
+            tagged_references=refs, prompt_override="@detail in a quiet room.", override_ref_image_size="max")
+        assert torch.equal(maximum[0][0][1]["minimax_refs"][0]["latent"],
+                           maximum_large[0][0][1]["minimax_refs"][0]["latent"])
+        maximum_custom = conditioner.condition(state, Clip(), target, VideoVAE(),
+            tagged_references=refs, prompt_override="@detail in a quiet room.", override_ref_image_size="max",
+            conditioning_width=32, conditioning_height=32)
+        assert torch.equal(maximum[0][0][1]["minimax_refs"][0]["latent"],
+                           maximum_custom[0][0][1]["minimax_refs"][0]["latent"])
+        # Keyframes/motion scale once; native audio tensor and time stay intact.
+        audio_ref = torch.ones(1, 32, 2, 9)
+        keyframe = torch.ones(1, 24, 2, 2, 2)
+        conditioning = [[torch.zeros(1), {"minimax_keyframes": [{"frame": 3, "latent": keyframe}],
+            "minimax_refs": [{"kind": "audio", "latent": audio_ref}]}]]
+        with patch.object(upscale.MiniMaxH3ChainUpscaleReferenceConditioning, "condition",
+                          return_value=(conditioning, "test", False, "test")):
+            synced = conditioner.condition(state, Clip(), target, VideoVAE(),
+                conditioning_width=32, conditioning_height=32)[0][0][1]
+        assert synced["minimax_keyframes"][0]["latent"].shape == (1, 24, 2, 4, 6)
+        assert synced["minimax_keyframes"][0]["frame"] == 3
+        assert synced["minimax_refs"][0]["latent"] is audio_ref
+        assert conditioning[0][1]["minimax_keyframes"][0]["latent"].shape[-2:] == (2, 2)
+
+        # Drift-Control in a parent must not require an unused pixel HQ latent.
+        drift = copy.deepcopy(state)
+        drift["source_manifest"]["segments"][1].update(
+            raw_frames=44, delivered_frames=5, context_length=39, continuation_mode="drift_control_av")
+        drift["profile"] = "pixel-drift"
+        assert upscale._next_drift_context_steps(drift, 1) == 0
+        assert upscale._load_previous_upscaled_context(drift, 2)[0] is None
+        upscale.MiniMaxH3ChainUpscaleSegmentSave().save(drift, target)
+        drift["profile_config"]["backend"] = "h3_latent"
+        fails(lambda: upscale.MiniMaxH3ChainUpscaleSegmentSave().save(drift, target), "must receive")
+
+        saver = upscale.MiniMaxH3ChainUpscaleSegmentSave()
+        saved = saver.save(state, target)["result"][0]
+        assert saved["context_steps"] == 0 and saved["latent_saved"] is False
+        end = upscale.MiniMaxH3ChainUpscaleLoopEnd()
+        with patch.object(end, "_recurse", side_effect=lambda flow, next_state, *a: next_state):
+            live_next = end.end(flow, state, target, saved)
+        assert live_next["index"] == 2 and live_next["previous_latent"] is None
+        # Exercise real GraphBuilder expansion with the distributed workflow.
+        # Every scene-dependent pixel node must recurse; the manager and model
+        # loaders stay bootstrap-only, and conditioning/images stay paired.
+        from comfy_execution.graph import DynamicPrompt
+        wf_path, = (ROOT / "example_workflows").glob(
+            "Deferred Upscale - Pixel DLSS5 + USDU - EXPERIMENTAL - MiniMax H3*.json")
+        wf = json.loads(wf_path.read_text())
+        links = {link[0]: link for link in wf["links"]}
+        prompt = {str(n["id"]): {"class_type": n["type"], "inputs": {
+            s["name"]: [str(links[s["link"]][1]), links[s["link"]][2]]
+            for s in n["inputs"] if s["link"] is not None}}
+            for n in wf["nodes"] if n["type"] != "Note"}
+        def node_id(kind):
+            return next(k for k, v in prompt.items() if v["class_type"] == kind)
+        expanded = end._recurse(
+            [node_id("MiniMaxH3ChainUpscaleAdapter"), 0], live_next,
+            DynamicPrompt(prompt), node_id("MiniMaxH3ChainUpscaleLoopEnd"))["expand"]
+        kinds = {v["class_type"]: k for k, v in expanded.items()}
+        assert {"MiniMaxH3ChainUpscalePixelCurrent", "MiniMaxH3ChainUpscalePixelConditioning",
+                "DLSS5EnhanceImages", "BasicGuider", "UltimateSDUpscaleNoUpscaleGuider",
+                "MiniMaxH3ChainUpscaleSegmentSave", "MiniMaxH3ChainUpscaleLoopEnd"} <= kinds.keys()
+        assert "MiniMaxH3ChainCheckpointManager" not in kinds and "UNETLoader" not in kinds
+        assert expanded[kinds["MiniMaxH3ChainUpscaleAdapter"]]["inputs"]["initial_state"]["index"] == 2
+        refinement_inputs = expanded[kinds["UltimateSDUpscaleNoUpscaleGuider"]]["inputs"]
+        assert refinement_inputs["upscaled_image"] == [kinds["MiniMaxH3ChainUpscalePixelConditioning"], 1]
+        assert expanded[kinds["BasicGuider"]]["inputs"]["conditioning"] == [
+            kinds["MiniMaxH3ChainUpscalePixelConditioning"], 0]
+        _, resumed, _, _ = adapter.adapt(manifest, "pixel", "pixel", "{}", 2, 0, False, 18)
+        assert resumed["segments"][0]["revision"] == saved["revision"]
+        fails(lambda: adapter.adapt(manifest, "pixel", "h3_latent", "{}", 2, 0, False, 18),
+              "different profile settings")
+        second = reader.current(resumed, VideoVAE())
+        assert second[7] > 0, "fixture must exercise repeated prefix trimming"
+        frames = second[1].repeat_interleave(2, dim=1).repeat_interleave(3, dim=2)
+        saved2 = saver.save(resumed, frames)["result"][0]
+        expected_audio = upscale._load_source_tensors(manifest["segments"][1])["delivered_audio"]
+        child_tensors = chain._st_load(chain._absolute_output_path(saved2["checkpoint"]))
+        assert torch.equal(child_tensors["delivered_audio"], expected_audio)
+        assert saved2["delivered_frames"] == 5 - second[7]
+        final = end.end(flow, resumed, frames, saved2)[0]
+        assert final["completed_clip_count"] == 2
+        assert final["total_delivered_frames"] == sum(s["delivered_frames"] for s in manifest["segments"])
+        assembled = chain.MiniMaxH3ChainAssemble().assemble(
+            final, "plan", "pixel_test_final", 128, False, "")
+        assert Path(chain._absolute_output_path(assembled["result"][0])).is_file()
+        streams = json.loads(subprocess.check_output([
+            "ffprobe", "-v", "error", "-show_streams", "-of", "json",
+            assembled["result"][0]]))["streams"]
+        video = next(s for s in streams if s["codec_type"] == "video")
+        assert (video["width"], video["height"]) == (96, 64)
+        assert int(video["nb_frames"]) == final["total_delivered_frames"]
+        assert any(s["codec_type"] == "audio" for s in streams)
+        # No original prompt, checkpoint, audio or selection metadata changed.
+        assert all(path.read_bytes() == content for path, content in original_files.items())
+        # A chapter is a non-1-based view. Exercise scenes 8..10 through the
+        # actual CPU decode/conditioning/save/resume/assembly path, reusing the
+        # tiny immutable artifacts above as source fixtures.
+        chapter_source = copy.deepcopy(manifest)
+        chapter_source.update({
+            "format":chain.CHAPTER_MANIFEST_FORMAT,
+            "scene_start":8, "scene_end":10, "clip_count":3,
+            "source_scene_count":12,
+            "chapter":{"number":2, "id":"two", "title":"Chapter 2",
+                       "start_scene":8, "end_scene":10, "planned_end_scene":12,
+                       "complete":False, "source_start_frame":120,
+                       "editorial_origin_frame":100},
+            "segments":[copy.deepcopy(manifest["segments"][offset]) for offset in (0, 1, 1)],
+        })
+        for index, segment in enumerate(chapter_source["segments"], start=8):
+            segment.update(index=index, id=f"chapter_scene_{index}")
+            if index > 8:
+                segment["visual_context_blocks"] = [{"source_scene":index - 1}]
+        chapter_source["total_delivered_frames"] = sum(s["delivered_frames"] for s in chapter_source["segments"])
+        chapter_source["duration_seconds"] = chapter_source["total_delivered_frames"] / 24
+        chapter_source["editorial"] = chain._normalize_run_editorial({
+            "scene_order":[{"scene":i,"scene_id":f"chapter_scene_{i}"} for i in (8, 9, 10)],
+            "chapters":[{"id":"two","start_scene_id":"chapter_scene_8"}],
+        }, manifest["run_name"])
+        assert_extended_selection_resume(chain, upscale, chapter_source, target)
+        before_chapter = {p:p.read_bytes() for p in Path(temporary).rglob("*") if p.is_file()}
+        _, scoped_state, _, _ = adapter.adapt(chapter_source, "pixel", "pixel", "{}", 1, 0, False, 18)
+        assert scoped_state["index"] == 8 and scoped_state["end_clip"] == 10
+        assert upscale._derope_state_view(scoped_state)[1:3] == (8, 10)
+        assert upscale._source_scene_count(chapter_source) == 12
+        assert upscale.MiniMaxH3ChainUpscaleCurrent().current(scoped_state)[4:6] == (8, 12)
+        assert upscale._derope_future_visual_consumers(scoped_state, 8) == [9]
+        with patch.object(chain, "_compile_tagged_reference_prompt",
+                          wraps=chain._compile_tagged_reference_prompt) as compile_prompt:
+            conditioner.condition(scoped_state, Clip(), target, VideoVAE(),
+                tagged_references=refs, prompt_override="@detail in a quiet room.")
+            assert compile_prompt.call_args.args[1:3] == (8, 12)
+        drift_chapter = copy.deepcopy(scoped_state)
+        drift_chapter["profile_config"]["backend"] = "h3_latent"
+        drift_chapter["source_manifest"]["segments"][1].update(
+            raw_frames=44, delivered_frames=5, continuation_mode="drift_control_av")
+        assert upscale._next_drift_context_steps(drift_chapter, 8) > 0
+        assert upscale._next_drift_context_steps(drift_chapter, 10) == 0
+        fails(lambda: adapter.adapt(chapter_source, "pixel", "pixel", "{}", 2, 0, False, 18), "start_clip")
+        for index in (8, 9, 10):
+            assert scoped_state["index"] == index
+            decoded = reader.current(scoped_state, VideoVAE())
+            assert decoded[5] == index
+            hq = decoded[1].repeat_interleave(2, dim=1).repeat_interleave(3, dim=2)
+            conditioned = conditioner.condition(scoped_state, Clip(), hq, VideoVAE())
+            assert conditioned[2:4] == (96, 64)
+            saved_chapter = saver.save(scoped_state, hq)["result"][0]
+            assert saved_chapter["index"] == index
+            assert f"chapters/02_two/upscaled/pixel/segments/clip_{index:04d}." in saved_chapter["segment"]
+            assert saved_chapter["delivered_frames"] == chapter_source["segments"][index - 8]["delivered_frames"]
+            if index == 10:
+                chapter_final = end.end(flow, scoped_state, hq, saved_chapter)[0]
+            else:
+                with patch.object(end, "_recurse", side_effect=lambda flow, next_state, *a: next_state):
+                    next_state = end.end(flow, scoped_state, hq, saved_chapter)
+                _, scoped_state, _, _ = adapter.adapt(chapter_source, "pixel", "pixel", "{}", index + 1, 0, False, 18)
+                assert scoped_state["index"] == next_state["index"]
+                assert scoped_state["segments"] == next_state["segments"]
+        assert chapter_final["format"] == "h3_chain_upscale_manifest_v1"
+        assert chapter_final["completed_clip_count"] == 3
+        assert (chapter_final["scene_start"], chapter_final["scene_end"]) == (8, 10)
+        upscale._validate_upscale_manifest(chapter_final)
+        broken = copy.deepcopy(chapter_final)
+        broken["segments"][1]["index"] = 2
+        fails(lambda: upscale._validate_upscale_manifest(broken), "wrong scene index")
+        chapter_assembly = upscale._assembly_manifest(chapter_final, chapter_final["segments"])
+        assert chapter_assembly["chapter"]["source_start_frame"] == 120
+        assert chapter_assembly["chapter"]["editorial_origin_frame"] == 100
+        assert chapter_assembly["chapter"]["complete"] is False
+        assert chapter_assembly["chapter"]["resolution"] == {"width":96,"height":64}
+        assert chapter_assembly["editorial"] == chapter_source["editorial"]
+        # Pixel export geometry need not be a multiple of the H3 latent grid.
+        arbitrary = [{**s, "width":1920, "height":1080} for s in chapter_final["segments"]]
+        assert upscale._assembly_manifest(chapter_final, arbitrary)["chapter"]["resolution"] == {"width":1920,"height":1080}
+        assembled_chapter = chain.MiniMaxH3ChainAssemble().assemble(
+            chapter_final, "plan", "chapter_test_final", 128, False, "")
+        final_path = assembled_chapter["result"][0]
+        assert "chapters/02_two/upscaled/pixel/final/" in final_path
+        streams = json.loads(subprocess.check_output([
+            "ffprobe", "-v", "error", "-show_streams", "-of", "json", final_path]))["streams"]
+        video = next(s for s in streams if s["codec_type"] == "video")
+        assert int(video["nb_frames"]) == chapter_source["total_delivered_frames"]
+        assert (video["width"], video["height"]) == (96, 64)
+        assert all(path.read_bytes() == content for path, content in before_chapter.items())
+        assert_independent_pixel_cleanup(chain, upscale, scoped_state, chapter_final, hq)
+    assert_attributed_branch_upscales(chain, upscale)
+    print("Pixel upscale: geometry, conditioning, RAW trim, Drift-Control isolation, attributed save/resume/assembly, independent cleanup/gap repair and immutable source pass")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_v05_contract_unit_test.py b/ComfyUI-MiniMaxH3-Context-Loop/tests/_v05_contract_unit_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..ed3c3b7943cab8b84405494da3b72cef829e8d43
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_v05_contract_unit_test.py
@@ -0,0 +1,379 @@
+#!/usr/bin/env python3
+"""Freeze the 0.5 contracts and the public 0.4 compatibility surface."""
+
+import ast
+import importlib.util
+import json
+import pathlib
+
+
+ROOT = pathlib.Path(__file__).resolve().parents[1]
+FIXTURE = json.loads((
+    ROOT / "tests" / "fixtures" / "v0_4_public_contract.json"
+).read_text(encoding="utf-8"))
+
+spec = importlib.util.spec_from_file_location(
+    "h3_contracts_v05", ROOT / "contracts_v05.py")
+contracts = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(contracts)
+
+
+def class_node(module, name):
+    return next(item for item in module.body
+                if isinstance(item, ast.ClassDef) and item.name == name)
+
+
+def literal_string_tuple(value):
+    assert isinstance(value, (ast.Tuple, ast.List))
+    return [ast.literal_eval(item) for item in value.elts]
+
+
+def return_names(module, name):
+    node = class_node(module, name)
+    assignment = next(item for item in node.body
+                      if isinstance(item, ast.Assign)
+                      and any(isinstance(target, ast.Name)
+                              and target.id == "RETURN_NAMES"
+                              for target in item.targets))
+    return literal_string_tuple(assignment.value)
+
+
+def plan_required_input_order(module):
+    node = class_node(module, "MiniMaxH3ChainPlan")
+    method = next(item for item in node.body
+                  if isinstance(item, ast.FunctionDef)
+                  and item.name == "INPUT_TYPES")
+    returned = next(item.value for item in ast.walk(method)
+                    if isinstance(item, ast.Return))
+    assert isinstance(returned, ast.Dict)
+    outer = {ast.literal_eval(key): value
+             for key, value in zip(returned.keys, returned.values)}
+    required = outer["required"]
+    assert isinstance(required, ast.Dict)
+    return [ast.literal_eval(key) for key in required.keys]
+
+
+def method_input_order(module, class_name, group):
+    node = class_node(module, class_name)
+    method = next(item for item in node.body
+                  if isinstance(item, ast.FunctionDef)
+                  and item.name == "INPUT_TYPES")
+    returned = next(item.value for item in ast.walk(method)
+                    if isinstance(item, ast.Return))
+    assert isinstance(returned, ast.Dict)
+    outer = {ast.literal_eval(key): value
+             for key, value in zip(returned.keys, returned.values)}
+    values = outer[group]
+    assert isinstance(values, ast.Dict)
+    return [ast.literal_eval(key) for key in values.keys]
+
+
+def main():
+    assert FIXTURE["format"] == "h3_v0_4_public_contract_fixture_v1"
+    assert contracts.SOURCE_TIMELINE_VERSION == "h3_source_timeline_v1"
+    assert contracts.AUDIO_POLICY_VERSION == "h3_audio_policy_v1"
+    assert contracts.TRANSITION_POLICY_VERSION == "h3_transition_policy_v1"
+    assert contracts.CHAIN_POLICY_VERSION == "h3_chain_policy_v1"
+    assert contracts.LIP_SYNC_OPTIONS_VERSION == "h3_lip_sync_options_v1"
+    assert contracts.SCENE_DEPENDENCY_VERSION == "h3_scene_dependency_v1"
+    assert contracts.PREFLIGHT_VERSION == "h3_preflight_v1"
+    assert contracts.ADVANCED_TRANSITION_PRESETS == (
+        "cut", "guide", "tone_guide", "latent_guide", "detail_guide",
+        "detail_av", "drift_av", "color_drift_av", "hard_av", "soft_av")
+    assert contracts.GENERATION_SCENE_PROFILES == {
+        "Visual continuity": "guide",
+        "Independent scenes": "cut",
+        "Hard picture + protected audio": "hard_av",
+        "Hard picture + smooth audio": "soft_av",
+    }
+    assert contracts.GENERATION_AUDIO_PROFILES[
+        "Generate audio"] == ("generated", "off", "on", False)
+    assert contracts.GENERATION_AUDIO_PROFILES[
+        "Lip-sync to source audio"] == ("source", "off", "off", True)
+    assert contracts.LATENT_COLOR_CARRY_RECIPE == {
+        "version": "h3_latent_color_delta_v1",
+        "context_frames": 39,
+        "video_steps": 12,
+        "anchor": "first_generated_scene_delivered_tail",
+        "source": "current_predecessor_delivered_tail",
+        "strength": 0.50,
+        "max_luma_shift_code_values": 6.0,
+        "max_saturation_change": 0.06,
+        "spatial_lowpass_kernel": 3,
+        "temporal_taper": "full_prefix_smoothstep_zero_to_one",
+        "delta_rule": "E(graded_D(z))-E(D(z))",
+        "audio": "unchanged",
+    }
+    assert contracts.CONTEXT_SPATIAL_PROXY_MODES == (
+        "off", "rgb_5_6", "latent_5_6")
+    assert contracts.CONTEXT_SPATIAL_PROXY_RECIPE[
+        "version"] == "h3_context_spatial_proxy_v2"
+    dependency_shape = contracts.scene_dependency_shape()
+    assert dependency_shape["version"] == contracts.SCENE_DEPENDENCY_VERSION
+    assert tuple(dependency_shape["scopes"]) == contracts.DEPENDENCY_SCOPES
+
+    for legacy, expected in FIXTURE["legacy_audio_modes"].items():
+        migrated = contracts.migrate_legacy_audio_mode(legacy)
+        assert migrated.pop("version") == contracts.AUDIO_POLICY_VERSION
+        assert migrated == expected
+    try:
+        contracts.migrate_legacy_audio_mode("ambiguous")
+    except ValueError as exc:
+        assert "Unknown legacy H3 audio mode" in str(exc)
+    else:
+        raise AssertionError("unknown legacy audio mode was accepted")
+
+    for final_audio in contracts.FINAL_AUDIO_POLICIES:
+        for source_reference in contracts.SOURCE_REFERENCE_POLICIES:
+            for continuity in contracts.GENERATED_CONTINUITY_POLICIES:
+                policy = contracts.audio_policy(
+                    final_audio, source_reference, continuity)
+                assert policy == {
+                    "version": contracts.AUDIO_POLICY_VERSION,
+                    "final_audio": final_audio,
+                    "source_reference": source_reference,
+                    "generated_continuity": continuity,
+                }
+    locked_audio = contracts.audio_policy(
+        "source", "on", "on", "locked")
+    assert locked_audio == {
+        "version": contracts.AUDIO_POLICY_VERSION,
+        "final_audio": "source",
+        "source_reference": "off",
+        "generated_continuity": "off",
+        "source_audio_target": "locked",
+    }
+    song_options = contracts.masked_song_options()
+    assert song_options == {
+        "version": contracts.LIP_SYNC_OPTIONS_VERSION,
+        "preroll_seconds": 1.0,
+        "lookahead_seconds": 0.2,
+        "audio_denoise": 0.0,
+        "gap_denoise": 0.15,
+        "gate_hold_seconds": 0.2,
+    }
+    vocal_hash = "ab" * 32
+    vocal_options = contracts.masked_song_options(
+        {**song_options, "voice_fingerprint": vocal_hash})
+    assert vocal_options["voice_fingerprint"] == vocal_hash
+    contextual_audio = contracts.audio_policy(
+        "source", "on", "on", "locked", vocal_options)
+    assert contextual_audio["lip_sync_options"] == vocal_options
+    assert "lip_sync_options" not in contracts.audio_policy(
+        "generated", "off", "on", "off", vocal_options)
+    try:
+        contracts.masked_song_options({**song_options, "gap_denoise": 1.1})
+    except ValueError as exc:
+        assert "gap denoise" in str(exc)
+    else:
+        raise AssertionError("out-of-range lip-sync denoise was accepted")
+    assert contracts.paired_audio_policy(True) == "embedded"
+    assert contracts.paired_audio_policy(False) == "off"
+    assert contracts.paired_audio_policy("embedded") == "embedded"
+    try:
+        contracts.audio_policy("copied", "off", "on")
+    except ValueError as exc:
+        assert "final-audio" in str(exc)
+    else:
+        raise AssertionError("unknown final-audio policy was accepted")
+    try:
+        contracts.paired_audio_policy("timeline")
+    except ValueError as exc:
+        assert "paired-audio" in str(exc)
+    else:
+        raise AssertionError("unknown paired-audio policy was accepted")
+
+    assert contracts.PRIMARY_TRANSITION_PRESETS == (
+        "cut", "guide", "hard_av", "soft_av")
+    compact = contracts.chain_policy(
+        "soft_av", "source", "on", "off")
+    assert compact == {
+        "version": contracts.CHAIN_POLICY_VERSION,
+        "audio_policy": {
+            "version": contracts.AUDIO_POLICY_VERSION,
+            "final_audio": "source",
+            "source_reference": "on",
+            "generated_continuity": "off",
+        },
+        "transition_policy": {
+            "version": contracts.TRANSITION_POLICY_VERSION,
+            "preset": "soft_av",
+            "label": "Soft continuation (hard picture, soft audio)",
+            "continuation_mode": "audio_feathered_av",
+            "context_length": 39,
+            "expert_override": False,
+        },
+        "audio_context_length": 39,
+    }
+    # Compact authoring derives the hidden audio overlap from the tested
+    # transition pair. The independent audio-policy axis gates it at runtime.
+    assert compact["audio_context_length"] == 39
+    locked_compact = contracts.chain_policy(
+        "soft_av", "source", "on", "on", True)
+    assert locked_compact["audio_policy"] == locked_audio
+    assert locked_compact["audio_context_length"] == 39
+    assert contracts.chain_policy(
+        "cut", "generated", "off", "on")["audio_context_length"] == 0
+    assert contracts.chain_policy(
+        "guide", "generated", "off", "on")["audio_context_length"] == 22
+    expert_transition = contracts.transition_policy(
+        "guide", expert_override=True,
+        continuation_mode="feathered_av", context_length=39)
+    composed = contracts.compose_chain_policy(
+        contracts.audio_policy("generated", "off", "on"),
+        expert_transition, audio_context_length=0)
+    assert composed["transition_policy"] == expert_transition
+    assert composed["audio_context_length"] == 0
+    try:
+        contracts.chain_policy(
+            "detail_av", "generated", "off", "on")
+    except ValueError as exc:
+        assert "incoming transition" in str(exc)
+    else:
+        raise AssertionError("advanced transition leaked into compact policy")
+    try:
+        contracts.compose_chain_policy(
+            compact["audio_policy"], compact["transition_policy"],
+            audio_context_length=241)
+    except ValueError as exc:
+        assert "between 0 and 240" in str(exc)
+    else:
+        raise AssertionError("invalid combined audio context was accepted")
+
+    expected_presets = {
+        "cut": ("guide", 0),
+        "guide": ("guide", 22),
+        "tone_guide": ("tone_carry_guide", 22),
+        "latent_guide": ("latent_guide", 22),
+        "detail_guide": ("tapered_guide", 22),
+        "detail_av": ("tapered_av", 39),
+        "drift_av": ("drift_control_av", 39),
+        "color_drift_av": ("color_stable_drift_av", 39),
+        "hard_av": ("masked_av", 39),
+        "soft_av": ("audio_feathered_av", 39),
+        "audio_feather_av": ("audio_feathered_av", 39),
+    }
+    for name, (mode, context) in expected_presets.items():
+        resolved = contracts.transition_preset(name)
+        assert resolved["preset"] == name
+        assert resolved["continuation_mode"] == mode
+        assert resolved["context_length"] == context
+        resolved["context_length"] = 999
+        assert contracts.transition_preset(name)["context_length"] == context
+        policy = contracts.transition_policy(name)
+        assert policy["continuation_mode"] == mode
+        assert policy["context_length"] == context
+        assert policy["expert_override"] is False
+    expert = contracts.transition_policy(
+        "guide", expert_override=True,
+        continuation_mode="feathered_av", context_length=39)
+    assert expert["preset"] == "guide"
+    assert expert["continuation_mode"] == "feathered_av"
+    assert expert["context_length"] == 39
+    assert expert["expert_override"] is True
+    migrated_expert = contracts.transition_policy(
+        "soft_av", expert_override=True,
+        continuation_mode="feathered_av_rgb", context_length=39)
+    assert migrated_expert["continuation_mode"] == "feathered_av"
+    assert migrated_expert["context_length"] == 39
+    video_only_five = contracts.transition_policy(
+        "soft_av", expert_override=True,
+        continuation_mode="audio_feathered_av", context_length=5)
+    assert video_only_five["context_length"] == 5
+    source_audio_policy = contracts.audio_policy("source", "on", "off")
+    video_only_policy = contracts.compose_chain_policy(
+        source_audio_policy, video_only_five, audio_context_length=5)
+    assert video_only_policy["transition_policy"]["context_length"] == 5
+    try:
+        contracts.compose_chain_policy(
+            contracts.audio_policy("generated", "off", "on"),
+            video_only_five, audio_context_length=5)
+    except ValueError as exc:
+        assert "exact shared" in str(exc)
+    else:
+        raise AssertionError(
+            "five-frame AV accepted generated predecessor audio carry")
+    try:
+        contracts.transition_policy(
+            "guide", expert_override=True,
+            continuation_mode="masked_av", context_length=1)
+    except ValueError as exc:
+        assert "at least 5" in str(exc)
+    else:
+        raise AssertionError("one-frame AV transition was accepted")
+    try:
+        contracts.transition_policy(
+            "guide", expert_override=True,
+            continuation_mode="audio_feathered_av", context_length=1)
+    except ValueError as exc:
+        assert "at least 5" in str(exc)
+    else:
+        raise AssertionError("one-frame audio-feather AV transition was accepted")
+    try:
+        contracts.transition_policy(
+            "detail_av", expert_override=True,
+            continuation_mode="tapered_av", context_length=90)
+    except ValueError as exc:
+        assert "exactly 39" in str(exc)
+    else:
+        raise AssertionError("90-frame Detail AV transition was accepted")
+    try:
+        contracts.transition_policy(
+            "drift_av", expert_override=True,
+            continuation_mode="drift_control_av", context_length=90)
+    except ValueError as exc:
+        assert "exactly 39" in str(exc)
+    else:
+        raise AssertionError("90-frame Drift-Control AV transition was accepted")
+    try:
+        contracts.transition_policy(
+            "color_drift_av", expert_override=True,
+            continuation_mode="color_stable_drift_av", context_length=90)
+    except ValueError as exc:
+        assert "exactly 39" in str(exc)
+    else:
+        raise AssertionError(
+            "90-frame Color-Stable Drift AV transition was accepted")
+    try:
+        contracts.transition_policy(
+            "guide", expert_override=True,
+            continuation_mode="latent_guide", context_length=1)
+    except ValueError as exc:
+        assert "at least 5" in str(exc)
+    else:
+        raise AssertionError("one-frame Latent Guide transition was accepted")
+    shape = contracts.source_timeline_shape()
+    assert shape["version"] == contracts.SOURCE_TIMELINE_VERSION
+    assert set(shape) == {
+        "version", "video", "audio", "origin", "fingerprints", "recovery"
+    }
+    assert set(contracts.DEPENDENCY_SCOPES) == {
+        "global_generation", "scene_generation", "incoming_boundary",
+        "assembly_only",
+    }
+
+    source = (ROOT / "chain_nodes.py").read_text(encoding="utf-8")
+    module = ast.parse(source)
+    assert plan_required_input_order(module) == FIXTURE[
+        "plan_required_input_order"]
+    loop_optional = method_input_order(
+        module, "MiniMaxH3ChainLoopStart", "optional")
+    assert loop_optional[:4] == FIXTURE["loop_start_optional_input_order"]
+    assert loop_optional[4:] == ["source_timeline"]
+    appended_outputs = {
+        "MiniMaxH3ChainCurrent": ["video_blend_frames"],
+        "MiniMaxH3ChainContext": ["model"],
+    }
+    for node_name, output_names in FIXTURE["positional_outputs"].items():
+        observed = return_names(module, node_name)
+        assert observed[:len(output_names)] == output_names, node_name
+        assert observed[len(output_names):] == appended_outputs.get(
+            node_name, []), node_name
+    for format_name in FIXTURE["checkpoint_formats"]:
+        assert format_name in source, format_name
+
+    print("v0.5 contracts and v0.4 compatibility fixture passed")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_v05_workflow_migration_unit_test.py b/ComfyUI-MiniMaxH3-Context-Loop/tests/_v05_workflow_migration_unit_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..ac785e393d2660628a1eec768c30a5dab0b6c271
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_v05_workflow_migration_unit_test.py
@@ -0,0 +1,221 @@
+#!/usr/bin/env python3
+"""Exercise the compact, exact, and idempotent 0.5 workflow migration."""
+
+import copy
+import importlib.util
+import json
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+spec = importlib.util.spec_from_file_location(
+    "h3_migrate_v05", ROOT / "tools" / "migrate_v05_workflows.py")
+migration = importlib.util.module_from_spec(spec)
+spec.loader.exec_module(migration)
+
+
+def load(relative):
+    return json.loads((ROOT / relative).read_text(encoding="utf-8"))
+
+
+def nodes(workflow, node_type):
+    return [node for node in workflow["nodes"] if node.get("type") == node_type]
+
+
+def input_names(node):
+    return [item["name"] for item in node.get("inputs", [])]
+
+
+def socket(items, name):
+    return next(item for item in items if item.get("name") == name)
+
+
+def origin_for_input(workflow, input_socket):
+    link = next(item for item in workflow["links"]
+                if item[0] == input_socket["link"])
+    return next(item for item in workflow["nodes"] if item["id"] == link[1])
+
+
+def assert_original_names_first(workflow):
+    for item in workflow["nodes"]:
+        title = item.get("title")
+        if title is None:
+            continue
+        original = migration.original_node_name(item["type"])
+        assert title == original or title.startswith(original + " — "), (
+            item["id"], item["type"], title, original)
+
+
+def main():
+    archived = load(
+        "example_workflows/Archive/"
+        "Ref2V Studio Legacy Scheduled - MiniMax H3.json")
+    original_identity = {
+        node["id"]: node["type"] for node in archived["nodes"]}
+    migrated = migration.migrate(
+        copy.deepcopy(archived), "custom-v0.4-studio.json")
+    assert_original_names_first(migrated)
+
+    for node_id, node_type in original_identity.items():
+        match = next(node for node in migrated["nodes"]
+                     if node["id"] == node_id)
+        assert match["type"] == node_type
+    assert len(nodes(migrated, "MiniMaxH3AudioPolicy")) == 0
+    assert len(nodes(migrated, "MiniMaxH3TransitionPolicy")) == 0
+    compact = nodes(migrated, "MiniMaxH3ChainPolicy")
+    assert len(compact) == 1
+    assert compact[0]["widgets_values"] == [
+        "guide", "generated", "off", "on"]
+    plan = nodes(migrated, "MiniMaxH3ChainPlan")[0]
+    assert "audio_policy" not in input_names(plan)
+    assert "transition_policy" not in input_names(plan)
+    assert next(item for item in plan["inputs"]
+                if item["name"] == "chain_policy")["link"] is not None
+    studio = nodes(migrated, "MiniMaxH3ChainPlanStudio")[0]
+    assert {"source_timeline", "source_audio", "tagged_references",
+            "reference_schedule"}.issubset(input_names(studio))
+    current = nodes(migrated, "MiniMaxH3ChainCurrent")[0]
+    trim = nodes(migrated, "MiniMaxH3LoopTrim")[0]
+    state_input = next(item for item in trim["inputs"]
+                       if item["name"] == "state")
+    state_link = next(item for item in migrated["links"]
+                      if item[0] == state_input["link"])
+    assert state_link[1:3] == [current["id"], 0]
+    assert next(item for item in trim["inputs"]
+                if item["name"] == "retain_overlap_frames")["link"] is None
+
+    stable = copy.deepcopy(migrated)
+    migration.migrate(migrated, "custom-v0.4-studio.json")
+    assert migrated == stable
+
+    source_demo = load(
+        "example_workflows/Archive/0.5/"
+        "Ref2V Studio Tagged Source Audio - MiniMax H3.json")
+    migration.migrate(source_demo, migration.SOURCE_AUDIO_DEMO)
+    assert_original_names_first(source_demo)
+    stable_demo = copy.deepcopy(source_demo)
+    migration.migrate(source_demo, migration.SOURCE_AUDIO_DEMO)
+    assert source_demo == stable_demo
+
+    # Recreate issue #38's old topology and verify migration repairs it: the
+    # dynamic Current Shot slice must become the static full Load Audio track,
+    # and the complete registry fingerprint must return to Plan.
+    legacy_source_demo = copy.deepcopy(stable_demo)
+    legacy_loader = nodes(legacy_source_demo, "LoadAudio")[0]
+    legacy_audio_ref = nodes(
+        legacy_source_demo, "MiniMaxH3TaggedAudioReference")[0]
+    legacy_current = nodes(legacy_source_demo, "MiniMaxH3ChainCurrent")[0]
+    legacy_plan = nodes(legacy_source_demo, "MiniMaxH3ChainPlan")[0]
+    legacy_conditioner = nodes(
+        legacy_source_demo, "MiniMaxH3TaggedReferenceToVideo")[0]
+    audio_link_id = socket(legacy_audio_ref["inputs"], "audio")["link"]
+    audio_link = next(item for item in legacy_source_demo["links"]
+                      if item[0] == audio_link_id)
+    audio_link[1:3] = [legacy_current["id"], 12]
+    socket(legacy_loader["outputs"], "AUDIO")["links"].remove(audio_link_id)
+    socket(legacy_current["outputs"],
+           "source_audio_slice")["links"] = [audio_link_id]
+    legacy_audio_ref["widgets_values"] = ["audio_1", "standalone", False]
+
+    previous_link_id = socket(
+        legacy_audio_ref["inputs"], "previous")["link"]
+    previous_link = next(item for item in legacy_source_demo["links"]
+                         if item[0] == previous_link_id)
+    legacy_picture = next(item for item in legacy_source_demo["nodes"]
+                          if item["id"] == previous_link[1])
+    fingerprint_link_id = socket(
+        legacy_plan["inputs"], "generation_fingerprint")["link"]
+    fingerprint_link = next(item for item in legacy_source_demo["links"]
+                            if item[0] == fingerprint_link_id)
+    fingerprint_link[1:3] = [legacy_picture["id"], 1]
+    socket(legacy_audio_ref["outputs"],
+           "reference_fingerprint")["links"] = None
+    socket(legacy_picture["outputs"],
+           "reference_fingerprint")["links"] = [fingerprint_link_id]
+    legacy_conditioner["widgets_values"].pop()
+    legacy_conditioner["outputs"] = [
+        item for item in legacy_conditioner["outputs"]
+        if item["name"] != "refmod_sources"]
+    legacy_studio = nodes(
+        legacy_source_demo, "MiniMaxH3ChainPlanStudio")[0]
+    preflight_link_id = socket(
+        legacy_studio["inputs"], "tagged_references")["link"]
+    legacy_source_demo["links"] = [
+        item for item in legacy_source_demo["links"]
+        if item[0] != preflight_link_id]
+    socket(legacy_audio_ref["outputs"], "references")["links"].remove(
+        preflight_link_id)
+    socket(legacy_studio["inputs"], "tagged_references")["link"] = None
+    legacy_source_demo["last_link_id"] = preflight_link_id - 1
+
+    migration.migrate(legacy_source_demo, migration.SOURCE_AUDIO_DEMO)
+    assert legacy_source_demo == stable_demo
+    assert len(nodes(source_demo, "MiniMaxH3SourceTimeline")) == 1
+    assert len(nodes(source_demo, "MiniMaxH3AudioPolicy")) == 0
+    assert len(nodes(source_demo, "MiniMaxH3TransitionPolicy")) == 0
+    compact = nodes(source_demo, "MiniMaxH3ChainPolicy")
+    assert len(compact) == 1
+    assert compact[0]["widgets_values"] == [
+        "guide", "source", "on", "off"]
+    audio_loader = nodes(source_demo, "LoadAudio")[0]
+    audio_ref = nodes(source_demo, "MiniMaxH3TaggedAudioReference")[0]
+    source_current = nodes(source_demo, "MiniMaxH3ChainCurrent")[0]
+    source_plan = nodes(source_demo, "MiniMaxH3ChainPlan")[0]
+    source_studio = nodes(source_demo, "MiniMaxH3ChainPlanStudio")[0]
+    source_conditioner = nodes(
+        source_demo, "MiniMaxH3TaggedReferenceToVideo")[0]
+    assert audio_ref["widgets_values"] == [
+        "audio_1", "source_timeline", True]
+    assert origin_for_input(
+        source_demo, socket(audio_ref["inputs"], "audio")) == audio_loader
+    assert socket(source_current["outputs"],
+                  "source_audio_slice")["links"] is None
+    assert origin_for_input(
+        source_demo,
+        socket(source_plan["inputs"], "generation_fingerprint")) == audio_ref
+    assert origin_for_input(
+        source_demo,
+        socket(source_studio["inputs"], "tagged_references")) == audio_ref
+    assert source_conditioner["widgets_values"][-1] == "native_ref2va"
+    assert socket(source_conditioner["outputs"],
+                  "refmod_sources")["type"] == "H3_REF_LIST"
+
+    drift_plan = {
+        "pos": [100, 200],
+        "widgets_values": [
+            "{}", "drift", "", 960, 544, 39, "video", "head",
+            "disabled", "generated_audio", 39, 15.0, 20, 0, 18, 0,
+            "drift_control_av",
+        ],
+    }
+    drift_policy, drift_output = migration._chain_policy_node(
+        drift_plan, ("generated", "off", "on"),
+        "drift_control_av", 39, 39)
+    assert drift_policy["type"] == "MiniMaxH3Legacy04PolicyAdapter"
+    assert drift_policy["widgets_values"] == [
+        "generated_audio", "drift_control_av", 39, 39]
+    assert drift_output == 0
+
+    mismatched_audio, mismatch_output = migration._chain_policy_node(
+        drift_plan, ("generated", "off", "on"), "masked_av", 39, 22)
+    assert mismatched_audio["type"] == "MiniMaxH3Legacy04PolicyAdapter"
+    assert mismatched_audio["widgets_values"] == [
+        "generated_audio", "masked_av", 39, 22]
+    assert mismatch_output == 0
+
+    archived_paths = [
+        ROOT / "example_workflows" / "Archive" / "0.5" / name
+        for name in migration.MAINTAINED_DEMOS]
+    assert all(path.is_file() for path in archived_paths)
+    for path in archived_paths:
+        maintained = json.loads(path.read_text(encoding="utf-8"))
+        stable_maintained = copy.deepcopy(maintained)
+        migration.migrate(maintained, path.name)
+        assert maintained == stable_maintained, path.name
+        assert_original_names_first(maintained)
+
+    print("v0.5 workflow migration: compact, exact, and idempotent")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_video_blend_unit_test.py b/ComfyUI-MiniMaxH3-Context-Loop/tests/_video_blend_unit_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..90f089be33924048df8d87284bd0546ad893cacb
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_video_blend_unit_test.py
@@ -0,0 +1,612 @@
+#!/usr/bin/env python3
+"""Frame-exact cumulative video blend and Plan compatibility regression."""
+
+import importlib.util
+import pathlib
+import shutil
+import sys
+import tempfile
+import types
+
+import av
+import numpy as np
+import torch
+
+
+ROOT = pathlib.Path(__file__).resolve().parents[1]
+PACKAGE = "h3_video_blend_unit"
+
+folder_paths = types.ModuleType("folder_paths")
+folder_paths.get_output_directory = lambda: folder_paths.output_directory
+folder_paths.get_temp_directory = lambda: folder_paths.output_directory
+folder_paths.get_input_directory = lambda: folder_paths.output_directory
+folder_paths.get_annotated_filepath = lambda value: str(value)
+folder_paths.output_directory = str(ROOT)
+sys.modules["folder_paths"] = folder_paths
+
+package = types.ModuleType(PACKAGE)
+package.__path__ = [str(ROOT)]
+sys.modules[PACKAGE] = package
+
+shared_nodes = types.ModuleType(PACKAGE + ".nodes")
+shared_nodes.MiniMaxH3MotionContext = object
+shared_nodes._claim_inline_patch_ownership = lambda _conditioning=None: "test patch owner"
+shared_nodes._prepare_native_guide_conditioning = lambda *args: None
+shared_nodes._resize = lambda *args: None
+shared_nodes._streams_from_latent = lambda *args: None
+sys.modules[shared_nodes.__name__] = shared_nodes
+
+spec = importlib.util.spec_from_file_location(
+    PACKAGE + ".chain_nodes", ROOT / "chain_nodes.py")
+chain = importlib.util.module_from_spec(spec)
+sys.modules[spec.name] = chain
+spec.loader.exec_module(chain)
+
+
+def frames(count, rgb):
+    value = torch.zeros((count, 32, 32, 3), dtype=torch.float32)
+    value[..., 0] = rgb[0]
+    value[..., 1] = rgb[1]
+    value[..., 2] = rgb[2]
+    return value
+
+
+def decode(path):
+    with av.open(str(path), mode="r") as container:
+        return [frame.to_ndarray(format="rgb24")
+                for frame in container.decode(container.streams.video[0])]
+
+
+def normalized(context=90, blend=39, anchor="head"):
+    return chain._normalize_plan(
+        '{"shots":[{"id":"one","prompt":"one","length":124},'
+        '{"id":"two","prompt":"two","length":124}]}',
+        "blend_test", 64, 64, context, "video", anchor, "disabled",
+        "generated_audio", 22, 5.0, 20, 0, 18,
+        generation_fingerprint="test", video_blend_frames=blend)
+
+
+def main():
+    assemble_optional = chain.MiniMaxH3ChainAssemble.INPUT_TYPES()["optional"]
+    assert assemble_optional["color_stabilization"][0] == (
+        "off", "scene_1_anchor")
+    assert assemble_optional["color_stabilization"][1]["default"] == "off"
+    brightness, saturation = chain._scene_color_transform(
+        {
+            "luma_percentiles": [80.0, 130.0, 190.0],
+            "saturation_percentiles": [40.0, 60.0, 80.0],
+        }, {
+            "luma_percentiles": [70.0, 120.0, 180.0],
+            "saturation_percentiles": [44.444, 66.667, 88.889],
+        })
+    assert abs(brightness - (5.0 / 255.0)) < 1e-6
+    assert abs(saturation - 0.95) < 1e-3
+
+    plan = normalized()
+    assert plan["compatibility"]["context_length"] == 90
+    assert plan["compatibility"]["video_blend_frames"] == 39
+    assert plan["shots"][1]["delivered_frames"] == 34
+    assert "blend=39" in plan["summary"]
+    per_scene = chain._normalize_plan(
+        '{"shots":[{"id":"one","prompt":"one","length":124},'
+        '{"id":"two","prompt":"two","length":124,'
+        '"context_length":39,"video_blend_frames":5},'
+        '{"id":"three","prompt":"three","length":124,'
+        '"context_length":22,"video_blend_frames":0}]}',
+        "scene_blend_test", 64, 64, 90, "video", "head", "disabled",
+        "generated_audio", 22, 5.0, 20, 0, 18,
+        generation_fingerprint="test", video_blend_frames=39)
+    assert per_scene["shots"][1]["video_blend_frames"] == 5
+    assert per_scene["shots"][2]["video_blend_frames"] == 0
+    assert chain._shot_video_blend_frames(
+        per_scene["shots"][1], 39, 39) == 5
+    assert chain._scene_dependency_record(
+        per_scene, 2)["scopes"]["assembly_only"][
+            "video_blend_frames"] == 5
+    inherited = {"context_length": 22}
+    assert chain._shot_video_blend_frames(inherited, 39, 22) == 22
+    history_variant = chain._normalize_plan(
+        '{"shots":[{"id":"one","prompt":"one","length":124},'
+        '{"id":"two","prompt":"two","length":124,'
+        '"context_length":39,"video_blend_frames":30},'
+        '{"id":"three","prompt":"three","length":124,'
+        '"context_length":22,"video_blend_frames":0}]}',
+        "scene_blend_test", 64, 64, 90, "video", "head", "disabled",
+        "generated_audio", 22, 5.0, 20, 0, 18,
+        generation_fingerprint="test", video_blend_frames=39)
+    assert chain._history_hash(per_scene, 2) == chain._history_hash(
+        history_variant, 2)
+    try:
+        chain._normalize_plan(
+            '{"shots":[{"prompt":"one","length":124},'
+            '{"prompt":"two","length":124,"context_length":22,'
+            '"video_blend_frames":23}]}',
+            "bad_scene_blend", 64, 64, 90, "video", "head", "disabled",
+            "generated_audio", 22, 5.0, 20, 0, 18,
+            video_blend_frames=0)
+    except ValueError as exc:
+        assert "Shot 2" in str(exc)
+        assert "between 0 and its context length (22)" in str(exc)
+    else:
+        raise AssertionError("scene blend larger than scene context was accepted")
+    try:
+        normalized(context=22, blend=23)
+    except ValueError as exc:
+        assert "between 0 and context_length" in str(exc)
+    else:
+        raise AssertionError("blend larger than context was accepted")
+    try:
+        normalized(context=22, blend=5, anchor="before")
+    except ValueError as exc:
+        assert "requires anchor_mode=head" in str(exc)
+    else:
+        raise AssertionError("before-mode blend was accepted")
+    assert chain._scheduled_blend_frames("plan", 3, 5) == [5, 5, 5]
+    assert chain._scheduled_blend_frames("5,30", 4, 0) == [5, 30, 30, 30]
+    assert chain._scheduled_blend_frames("0", 2, 39) == [0, 0]
+    assert chain._partial_boundary_tone_match_mode({
+        "compatibility": {"continuation_mode": "guide"},
+        "segments": [],
+    }) == "off"
+    assert chain._partial_boundary_tone_match_mode({
+        "compatibility": {"continuation_mode": "tone_carry_guide"},
+        "segments": [],
+    }) == "auto"
+    assert chain._partial_boundary_tone_match_mode({
+        "compatibility": {"continuation_mode": "guide"},
+        "segments": [{"guide_tone_input_applied": True}],
+    }) == "auto"
+    try:
+        chain._scheduled_blend_frames("5,nope", 2, 0)
+    except ValueError as exc:
+        assert "integer frame counts" in str(exc)
+    else:
+        raise AssertionError("invalid blend schedule was accepted")
+
+    with tempfile.TemporaryDirectory() as temporary:
+        folder_paths.output_directory = temporary
+        root = pathlib.Path(temporary)
+        base = root / "base.mp4"
+        extension = root / "extension.mp4"
+        # The extension contains two regenerated context frames followed by
+        # four genuinely delivered frames.
+        chain._write_segment_video(frames(5, (1, 0, 0)), str(base), 24, 0)
+        overlap = torch.cat((frames(2, (0, 1, 0)),
+                             frames(4, (0, 0, 1))), dim=0)
+        chain._write_segment_video(overlap, str(extension), 24, 0)
+        streamed_prefix = root / "streamed_prefix.mp4"
+        disposable = frames(3, (0, 0, 1))
+        clean_prefix = frames(1, (1, 0, 0))
+        chain._write_segment_video(
+            disposable, str(streamed_prefix), 24, 0,
+            replacement_prefix=clean_prefix)
+        streamed_frames = decode(streamed_prefix)
+        assert streamed_frames[0][0, 0, 0] > 200
+        assert streamed_frames[0][0, 0, 2] < 20
+        assert streamed_frames[1][0, 0, 2] > 200
+        assert torch.all(disposable[..., 2] == 1.0)
+        records = [
+            {"path": str(base), "input_frames": 5,
+             "delivered_frames": 5, "blend_frames": 0},
+            {"path": str(extension), "input_frames": 6,
+             "delivered_frames": 4, "blend_frames": 2},
+        ]
+
+        pyav_output = root / "pyav.mp4"
+        chain._pyav_blend_video(
+            records, str(pyav_output), {"title": "blend test"}, 9, 0)
+        pyav_frames = decode(pyav_output)
+        assert len(pyav_frames) == 9
+        # The two join frames contain both old red and regenerated green.
+        assert pyav_frames[3][0, 0, 0] > 20
+        assert pyav_frames[3][0, 0, 1] > 20
+        assert pyav_frames[4][0, 0, 0] > 20
+        assert pyav_frames[4][0, 0, 1] > 20
+        assert pyav_frames[-1][0, 0, 2] > 200
+
+        # Automatic tone matching detects a coherent exposure step only after
+        # the protected overlap, fits a capped percentile curve, and applies
+        # it from that generated frame onward. The preceding context remains
+        # bit-for-bit on the uncorrected path.
+        gradient = torch.linspace(
+            0.03, 0.73, 32, dtype=torch.float32).reshape(1, 1, 32, 1)
+        gradient = gradient.expand(1, 32, 32, 3).contiguous()
+        darker = torch.clamp(gradient - (4.0 / 255.0), 0.0, 1.0)
+        tone_base_frames = gradient.repeat(10, 1, 1, 1)
+        tone_incoming_frames = torch.cat((
+            gradient.repeat(8, 1, 1, 1),
+            gradient,
+            darker.repeat(3, 1, 1, 1),
+        ), dim=0)
+        tone_base = root / "tone_base.mkv"
+        tone_incoming = root / "tone_incoming.mkv"
+        chain._write_lossless_rgb_video(
+            tone_base_frames, str(tone_base), 24)
+        chain._write_lossless_rgb_video(
+            tone_incoming_frames, str(tone_incoming), 24)
+        tone_records = [
+            {"path": str(tone_base), "input_frames": 10,
+             "delivered_frames": 10, "blend_frames": 0,
+             "skip_frames": 0},
+            {"path": str(tone_incoming), "input_frames": 12,
+             "delivered_frames": 4, "blend_frames": 8,
+             "skip_frames": 0},
+        ]
+        matched_records = chain._auto_boundary_tone_match_records(
+            tone_records)
+        tone_match = matched_records[1].get("tone_match")
+        assert tone_match is not None
+        assert tone_match["start_frame"] == 9
+        assert max(abs(value) for value in
+                   tone_match["applied_shifts"]) <= 6.0
+        assert "curves=all=" in chain._ffmpeg_boundary_tone_filter(
+            tone_match)
+
+        # Optional temporal stabilization anchors generated scene one, keeps
+        # the exact boundary at the predecessor's accepted transform, then
+        # ramps a capped correction through the incoming delivered frames.
+        color_records = chain._auto_scene_color_stabilization_records(
+            tone_records)
+        color_schedule = color_records[1].get(
+            "scene_color_stabilization")
+        assert color_schedule is not None
+        assert color_schedule["start_frame"] == 8
+        assert color_schedule["ramp_frames"] == 4
+        assert color_schedule["previous_brightness"] == 0.0
+        assert color_schedule["previous_saturation"] == 1.0
+        assert 0.0 < color_schedule["brightness"] <= 6.0 / 255.0
+        assert "hue=b=" in chain._ffmpeg_scene_color_filter(
+            color_schedule)
+        probe = np.full((8, 8, 3), 100, dtype=np.uint8)
+        unchanged = chain._apply_scene_color_stabilization(
+            probe, color_schedule, color_schedule["start_frame"])
+        assert np.array_equal(unchanged, probe)
+        corrected = chain._apply_scene_color_stabilization(
+            probe, color_schedule,
+            color_schedule["start_frame"] + color_schedule["ramp_frames"])
+        assert float(corrected.mean()) > float(probe.mean())
+        color_probe = np.full((8, 8, 3), (180, 100, 50), dtype=np.uint8)
+        saturation_probe = {
+            **color_schedule,
+            "previous_brightness": 0.0,
+            "brightness": 0.0,
+            "previous_saturation": 1.0,
+            "saturation": 0.94,
+        }
+        desaturated = chain._apply_scene_color_stabilization(
+            color_probe, saturation_probe,
+            saturation_probe["start_frame"] +
+            saturation_probe["ramp_frames"])
+        assert int(np.ptp(desaturated[0, 0])) < int(np.ptp(color_probe[0, 0]))
+
+        # An existing-video prelude is not the color reference. The first
+        # generated segment remains scene one and receives no grade schedule.
+        with_prelude = chain._auto_scene_color_stabilization_records([
+            {**tone_records[0], "kind": "prelude"},
+            {**tone_records[0], "kind": "segment", "scene_index": 1},
+            {**tone_records[1], "kind": "segment", "scene_index": 2},
+        ])
+        assert "scene_color_stabilization" not in with_prelude[0]
+        assert "scene_color_stabilization" not in with_prelude[1]
+        assert "scene_color_stabilization" in with_prelude[2]
+
+        color_pyav = root / "color_stabilized_pyav.mp4"
+        chain._pyav_blend_video(
+            color_records, str(color_pyav), {"title": "color anchor"},
+            14, 0)
+        assert len(decode(color_pyav)) == 14
+
+        # A resume made before Tone Carry metadata existed recovers the same
+        # small curve from its two immutable scene videos. The segment record
+        # is enriched in memory; its checkpoint/latent is not touched.
+        tone_delivered = root / "tone_delivered.mkv"
+        chain._write_lossless_rgb_video(
+            torch.cat((gradient, darker.repeat(3, 1, 1, 1))),
+            str(tone_delivered), 24)
+        legacy_state = {
+            "segments": [
+                {"index": 1, "segment": str(tone_base)},
+                {"index": 2, "segment": str(tone_delivered)},
+            ],
+        }
+        recovered_tone = chain._recover_state_guide_tone_carry(legacy_state)
+        assert recovered_tone is not None
+        assert recovered_tone["version"] == "h3_guide_tone_carry_v1"
+        assert recovered_tone["recovered_from"] == "saved_scene_videos"
+        assert recovered_tone["start_frame"] == 1
+        assert legacy_state["segments"][1][
+            "guide_tone_carry"] is recovered_tone
+        assert chain._recover_state_guide_tone_carry(
+            legacy_state) is recovered_tone
+        tone_third = root / "tone_third.mkv"
+        chain._write_lossless_rgb_video(
+            darker.repeat(8, 1, 1, 1), str(tone_third), 24)
+        propagated_records = chain._auto_boundary_tone_match_records(
+            tone_records + [{
+                "path": str(tone_third), "input_frames": 8,
+                "delivered_frames": 4, "blend_frames": 4,
+                "skip_frames": 0,
+            }])
+        assert len(propagated_records[2]["tone_match_prefix"]) == 1
+        assert propagated_records[2].get("tone_match") is None
+        tone_carried = root / "tone_carried.mkv"
+        chain._write_lossless_rgb_video(
+            gradient.repeat(8, 1, 1, 1), str(tone_carried), 24)
+        generation_carried_records = chain._auto_boundary_tone_match_records(
+            tone_records + [{
+                "path": str(tone_carried), "input_frames": 8,
+                "delivered_frames": 4, "blend_frames": 4,
+                "skip_frames": 0, "generation_tone_carry": True,
+            }])
+        assert not generation_carried_records[2].get("tone_match_prefix")
+        assert generation_carried_records[2].get("tone_match") is None
+
+        def mean_luma(array):
+            return float(np.mean(
+                array[..., 0] * 0.2126 + array[..., 1] * 0.7152 +
+                array[..., 2] * 0.0722))
+
+        tone_off = root / "tone_off.mp4"
+        tone_auto = root / "tone_auto.mp4"
+        chain._pyav_blend_video(
+            tone_records, str(tone_off), {"title": "tone off"}, 14, 0)
+        chain._pyav_blend_video(
+            matched_records, str(tone_auto), {"title": "tone auto"}, 14, 0)
+        tone_off_frames = decode(tone_off)
+        tone_auto_frames = decode(tone_auto)
+        assert abs(mean_luma(tone_off_frames[11]) -
+                   mean_luma(tone_off_frames[10])) > 2.0
+        assert abs(mean_luma(tone_auto_frames[11]) -
+                   mean_luma(tone_auto_frames[10])) < 1.0
+        tone_propagated = root / "tone_propagated.mp4"
+        chain._pyav_blend_video(
+            propagated_records, str(tone_propagated),
+            {"title": "tone propagated"}, 18, 0)
+        tone_propagated_frames = decode(tone_propagated)
+        assert abs(mean_luma(tone_propagated_frames[14]) -
+                   mean_luma(tone_propagated_frames[13])) < 1.0
+
+        ffmpeg = shutil.which("ffmpeg")
+        if ffmpeg:
+            metadata = root / "metadata.txt"
+            chain._write_ffmetadata(str(metadata), {"title": "blend test"})
+            ffmpeg_output = root / "ffmpeg.mp4"
+            chain._ffmpeg_blend_video(
+                ffmpeg, records, str(ffmpeg_output), str(metadata), 9, 0)
+            assert len(decode(ffmpeg_output)) == 9
+            # A first xfade may advertise 1/0 FPS. The second xfade used to
+            # reject that intermediate even though every source was CFR.
+            chained_output = root / "ffmpeg_three_segments.mp4"
+            chained_records = records + [{**records[1]}]
+            chain._ffmpeg_blend_video(
+                ffmpeg, chained_records, str(chained_output), str(metadata),
+                13, 0)
+            assert len(decode(chained_output)) == 13
+            ffmpeg_tone = root / "ffmpeg_tone_auto.mp4"
+            chain._ffmpeg_blend_video(
+                ffmpeg, matched_records, str(ffmpeg_tone), str(metadata),
+                14, 0)
+            ffmpeg_tone_frames = decode(ffmpeg_tone)
+            ffmpeg_tone_delta = abs(
+                mean_luma(ffmpeg_tone_frames[11]) -
+                mean_luma(ffmpeg_tone_frames[10]))
+            assert ffmpeg_tone_delta < 1.5, ffmpeg_tone_delta
+            ffmpeg_color = root / "ffmpeg_color_anchor.mp4"
+            ffmpeg_color_baseline = root / "ffmpeg_color_baseline.mp4"
+            chain._ffmpeg_blend_video(
+                ffmpeg, tone_records, str(ffmpeg_color_baseline),
+                str(metadata), 14, 0)
+            chain._ffmpeg_blend_video(
+                ffmpeg, color_records, str(ffmpeg_color), str(metadata),
+                14, 0)
+            ffmpeg_color_baseline_frames = decode(ffmpeg_color_baseline)
+            ffmpeg_color_frames = decode(ffmpeg_color)
+            assert len(ffmpeg_color_frames) == 14
+            assert mean_luma(ffmpeg_color_frames[-1]) > (
+                mean_luma(ffmpeg_color_baseline_frames[-1]) + 0.2)
+            seam_mad = float(np.abs(
+                ffmpeg_color_frames[10].astype(np.int16) -
+                ffmpeg_color_baseline_frames[10].astype(np.int16)).mean())
+            assert seam_mad < 1.0, seam_mad
+
+        checkpoint_one = root / "one.safetensors"
+        checkpoint_two = root / "two.safetensors"
+        checkpoint_one.write_bytes(b"one")
+        checkpoint_two.write_bytes(b"two")
+
+        def segment(index, video, checkpoint, delivered, raw, blend_video=None):
+            value = {
+                "index": index,
+                "id": "clip_%04d" % index,
+                "segment": str(video),
+                "checkpoint": str(checkpoint),
+                "raw_frames": raw,
+                "delivered_frames": delivered,
+                "segment_sha256": chain._file_sha256(str(video)),
+                "checkpoint_sha256": chain._file_sha256(str(checkpoint)),
+            }
+            if blend_video is not None:
+                value.update({
+                    "blend_segment": str(blend_video),
+                    "blend_segment_sha256": chain._file_sha256(
+                        str(blend_video)),
+                    "blend_frames": raw - delivered,
+                })
+            return value
+
+        blended_manifest = {
+            "format": "h3_chain_manifest_v2",
+            "run_name": "assembled_blend",
+            "clip_count": 2,
+            "total_delivered_frames": 9,
+            "compatibility": {
+                "audio_mode": "generated_audio", "segment_crf": 0,
+                "video_blend_frames": 2,
+            },
+            "segments": [
+                segment(1, base, checkpoint_one, 5, 5),
+                segment(2, extension, checkpoint_two, 4, 6, extension),
+            ],
+        }
+        assembled = chain.MiniMaxH3ChainAssemble().assemble(
+            blended_manifest, "none", "final", 128)["result"][0]
+        assert len(decode(assembled)) == 9
+
+        scheduled_records = chain._blend_video_records(
+            blended_manifest, blended_manifest["segments"], None,
+            blend_schedule="1")
+        assert scheduled_records[1]["blend_frames"] == 1
+        assert scheduled_records[1]["skip_frames"] == 1
+        assert scheduled_records[1]["input_frames"] == 5
+        per_scene_overlap = root / "per_scene_overlap.mp4"
+        chain._write_segment_video(
+            torch.cat((frames(1, (0, 1, 0)), frames(4, (0, 0, 1))),
+                      dim=0),
+            str(per_scene_overlap), 24, 0)
+        per_scene_manifest = {
+            **blended_manifest,
+            "segments": [
+                blended_manifest["segments"][0],
+                {**blended_manifest["segments"][1],
+                 "blend_segment": str(per_scene_overlap),
+                 "blend_segment_sha256": chain._file_sha256(
+                     str(per_scene_overlap)),
+                 "blend_frames": 1},
+            ],
+        }
+        plan_records = chain._blend_video_records(
+            per_scene_manifest, per_scene_manifest["segments"], None,
+            blend_schedule="plan")
+        assert plan_records[1]["blend_frames"] == 1
+        assert plan_records[1]["skip_frames"] == 0
+        scheduled = chain.MiniMaxH3ChainAssemble().assemble(
+            blended_manifest, "none", "scheduled_one", 128,
+            blend_schedule="1")["result"][0]
+        assert len(decode(scheduled)) == 9
+
+        # A larger recovery blend is reconstructed from the existing raw
+        # checkpoint latent through the optional VAE. The intermediate is
+        # lossless RGB and is deleted after final assembly.
+        narrow_overlap = root / "narrow_overlap.mp4"
+        chain._write_segment_video(
+            torch.cat((frames(1, (0, 1, 0)), frames(4, (0, 0, 1))),
+                      dim=0),
+            str(narrow_overlap), 24, 0)
+        recoverable_checkpoint = root / "recoverable.safetensors"
+        chain._st_save(
+            {"video": torch.zeros((1, 1), dtype=torch.float32)},
+            str(recoverable_checkpoint))
+        recoverable_delivered = root / "recoverable_delivered.mp4"
+        chain._write_segment_video(
+            frames(4, (0, 0, 1)), str(recoverable_delivered), 24, 0)
+        recoverable_two = segment(
+            2, recoverable_delivered,
+            recoverable_checkpoint, 4, 6)
+        recoverable_two.update({
+            "blend_segment": str(narrow_overlap),
+            "blend_segment_sha256": chain._file_sha256(str(narrow_overlap)),
+            "blend_frames": 1,
+        })
+        recoverable_manifest = {
+            **blended_manifest,
+            "run_name": "assembled_recovered_schedule",
+            "compatibility": {
+                **blended_manifest["compatibility"],
+                "video_blend_frames": 1,
+            },
+            "segments": [
+                segment(1, base, checkpoint_one, 5, 5),
+                recoverable_two,
+            ],
+        }
+
+        class FakeVideoVAE:
+            def decode(self, _video):
+                return overlap.clone()
+
+        recovered = chain.MiniMaxH3ChainAssemble().assemble(
+            recoverable_manifest, "none", "scheduled_recovered", 128,
+            blend_schedule="2", blend_video_vae=FakeVideoVAE())["result"][0]
+        assert len(decode(recovered)) == 9
+        assert not list((root / "h3_chains" /
+                         "assembled_recovered_schedule" / "final").glob(
+                             ".scheduled_blend_clip_*"))
+
+        delivered_two = root / "delivered_two.mp4"
+        chain._write_segment_video(
+            frames(4, (0, 0, 1)), str(delivered_two), 24, 0)
+        hard_manifest = {
+            **blended_manifest,
+            "run_name": "assembled_hard",
+            "compatibility": {
+                **blended_manifest["compatibility"],
+                "video_blend_frames": 0,
+            },
+            "segments": [
+                segment(1, base, checkpoint_one, 5, 5),
+                segment(2, delivered_two, checkpoint_two, 4, 6),
+            ],
+        }
+        hard = chain.MiniMaxH3ChainAssemble().assemble(
+            hard_manifest, "none", "final", 128)["result"][0]
+        assert len(decode(hard)) == 9
+        forced_hard_records = chain._blend_video_records(
+            hard_manifest, hard_manifest["segments"], None,
+            force_records=True)
+        assert len(forced_hard_records) == 2
+        assert not any(record["blend_frames"]
+                       for record in forced_hard_records)
+        stabilized_hard = chain.MiniMaxH3ChainAssemble().assemble(
+            hard_manifest, "none", "color_anchor", 128,
+            color_stabilization="scene_1_anchor")["result"][0]
+        assert len(decode(stabilized_hard)) == 9
+
+        # Editorial placement does not alter the saved chain. Assemble inserts
+        # exact black track time before the later scene and keeps its frames.
+        chain._save_run_editorial_document({
+            "run_name": "assembled_hard",
+            "scene_order": [
+                {"scene": 1, "scene_id": "clip_0001"},
+                {"scene": 2, "scene_id": "clip_0002"},
+            ],
+            "chapters": [],
+            "placements": [{
+                "scene": 2, "scene_id": "clip_0002", "start_frame": 8,
+            }],
+        })
+        editorial_output = chain.MiniMaxH3ChainAssemble().assemble(
+            hard_manifest, "none", "editorial_gap", 128)["result"][0]
+        editorial_frames = decode(editorial_output)
+        assert len(editorial_frames) == 12
+        assert all(np.max(frame) == 0 for frame in editorial_frames[5:8])
+        assert np.mean(editorial_frames[8][..., 2]) > 200
+
+        # Reordering has no duration delta, so it must not depend on a black
+        # gap to activate editorial assembly. Scene-owned video follows the
+        # edit order and invalid generation-boundary blends become hard cuts.
+        chain._save_run_editorial_document({
+            "run_name": "assembled_hard",
+            "scene_order": [
+                {"scene": 1, "scene_id": "clip_0001"},
+                {"scene": 2, "scene_id": "clip_0002"},
+            ],
+            "chapters": [],
+            "placements": [{
+                "scene": 2, "scene_id": "clip_0002", "start_frame": 0,
+            }],
+        })
+        reordered_output = chain.MiniMaxH3ChainAssemble().assemble(
+            hard_manifest, "none", "editorial_reordered", 128)["result"][0]
+        reordered_frames = decode(reordered_output)
+        assert len(reordered_frames) == 9
+        assert np.mean(reordered_frames[0][..., 2]) > 200
+        assert np.mean(reordered_frames[-1][..., 0]) > 200
+
+    print("H3 video blend: extended context validation, scheduled recovery, "
+          "automatic boundary tone matching, scene-one temporal color "
+          "stabilization, chained xfade CFR, and frame-exact PyAV/ffmpeg "
+          "assembly pass")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_web_cache_bust_unit_test.py b/ComfyUI-MiniMaxH3-Context-Loop/tests/_web_cache_bust_unit_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..fd2daa7a87250bdc1981bd94b34e9ba48cdb6668
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_web_cache_bust_unit_test.py
@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""Keep browser-cached .mjs helpers fresh across package and patch updates."""
+
+import pathlib
+import re
+
+
+ROOT = pathlib.Path(__file__).resolve().parents[1]
+PROJECT = (ROOT / "pyproject.toml").read_text(encoding="utf-8")
+VERSION_MATCH = re.search(r'^version\s*=\s*"([^"]+)"', PROJECT, re.MULTILINE)
+assert VERSION_MATCH, "pyproject.toml does not declare the project version"
+VERSION = VERSION_MATCH.group(1)
+MINIMUM_CACHE_VERSION = {
+    "h3_policy_core.mjs": "0.6.6",
+    "h3_project_asset_editor_core.mjs": "0.6.6",
+    "h3_plan_restore_core.mjs": "0.6.6",
+    "h3_socket_presentation_core.mjs": "0.6.6",
+    "h3_chain_plan_core.mjs": "0.6.5",
+    "h3_chain_review_core.mjs": "0.6.5",
+    "h3_chain_cancel_reroll_core.mjs": "0.6.5",
+    "h3_prompt_assistant_core.mjs": "0.6.5",
+    "h3_chain_plan_studio_core.mjs": "0.6.3",
+    "h3_checkpoint_manager_core.mjs": "0.6.6",
+    "h3_prompt_companion_sync.mjs": "0.6.2",
+    "h3_project_asset_sync_core.mjs": "0.6.2",
+    "h3_reference_preview_core.mjs": "0.6.2",
+    "h3_prompt_completion_core.mjs": "0.6.5",
+    "h3_prompt_schema_core.mjs": "0.6.5",
+    "h3_prompt_schema_ui.mjs": "0.6.5",
+    "h3_rich_prompt_editor_core.mjs": "0.6.5",
+    "h3_prompt_editor_settings_core.mjs": "0.6.5",
+    "h3_prompt_marker_ui.mjs": "0.6.5",
+}
+
+
+def version_key(value):
+    assert re.fullmatch(r"\d+\.\d+\.\d+", str(value or "")), (
+        "Invalid web cache token %r" % value)
+    return tuple(int(part) for part in value.split("."))
+
+
+IMPORT = re.compile(
+    r'''["'](\./[^"']+\.mjs)(?:\?v=([^"']+))?["']''')
+
+
+def main():
+    imports = []
+    for path in sorted((ROOT / "web").iterdir()):
+        if path.suffix not in (".js", ".mjs"):
+            continue
+        source = path.read_text(encoding="utf-8")
+        for relative, cache_version in IMPORT.findall(source):
+            target = (path.parent / relative).resolve()
+            assert target.is_file(), "%s imports missing %s" % (
+                path.name, relative)
+            minimum = max(
+                version_key(VERSION),
+                version_key(MINIMUM_CACHE_VERSION.get(target.name, VERSION)))
+            assert version_key(cache_version) >= minimum, (
+                "%s imports %s with stale cache token %r; expected at least %s"
+                % (path.name, relative, cache_version, minimum))
+            imports.append((path.name, relative))
+
+    assert imports, "No production .mjs imports were checked."
+    print("H3 web cache bust: %d .mjs imports meet their minimum "
+          "fresh-cache versions" % len(imports))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_windows_output_path_unit_test.py b/ComfyUI-MiniMaxH3-Context-Loop/tests/_windows_output_path_unit_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..6b2db6fd15f0784beade1e0010849c80b018c18c
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_windows_output_path_unit_test.py
@@ -0,0 +1,164 @@
+#!/usr/bin/env python3
+"""Issue #45: mapped-drive and UNC spellings must share artifact identities."""
+
+import ast
+import contextlib
+import ntpath
+import os
+import pathlib
+import sys
+import tempfile
+import types
+from unittest.mock import patch
+
+
+ROOT = pathlib.Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+import asset_store  # noqa: E402
+import checkpoint_manager  # noqa: E402
+import project_assets  # noqa: E402
+import run_manager  # noqa: E402
+
+
+def chain_paths(os_module, output_root, input_root):
+    # Exercise the production path helpers without importing ComfyUI or models.
+    names = {
+        "_output_root", "_input_root", "_relative_output_path",
+        "_absolute_output_path", "_png_export_checkpoint_cache_key",
+    }
+    source = ast.parse((ROOT / "chain_nodes.py").read_text(encoding="utf-8"))
+    functions = [node for node in source.body
+                 if isinstance(node, ast.FunctionDef) and node.name in names]
+    namespace = {
+        "os": os_module,
+        "folder_paths": types.SimpleNamespace(
+            get_output_directory=lambda: output_root,
+            get_input_directory=lambda: input_root),
+    }
+    exec(compile(ast.Module(body=functions, type_ignores=[]),
+                 str(ROOT / "chain_nodes.py"), "exec"), namespace)
+    return namespace
+
+
+def windows_os():
+    # Use ntpath's real drive/UNC parsing on every test platform. Only the OS's
+    # network-drive lookup is substituted: R: and S: map to the same share.
+    paths = types.SimpleNamespace(**{
+        name: getattr(ntpath, name) for name in dir(ntpath)
+        if not name.startswith("__")})
+    mappings = {
+        "r:": r"\\mightyjobs\Resources",
+        "s:": r"\\mightyjobs\Resources",
+        "i:": r"\\mightyjobs\Inputs",
+    }
+
+    def realpath(value):
+        absolute = ntpath.abspath(os.fspath(value))
+        drive, tail = ntpath.splitdrive(absolute)
+        return ntpath.normpath(mappings.get(drive.lower(), drive) + tail)
+
+    paths.realpath = realpath
+    return types.SimpleNamespace(path=paths, sep="\\")
+
+
+def expect_escape(action):
+    try:
+        action()
+    except ValueError as exc:
+        assert "escapes" in str(exc), str(exc)
+    else:
+        raise AssertionError("An artifact outside the output root was accepted")
+
+
+def windows_checks():
+    win = windows_os()
+    relative = r"h3_chains\demo\plan.json"
+    mapped = r"R:\comfyui_output"
+    unc = r"\\mightyjobs\Resources\comfyui_output"
+    # This is the exact failing relpath combination from the issue report.
+    try:
+        ntpath.relpath(ntpath.join(unc, relative), mapped)
+    except ValueError:
+        pass
+    else:
+        raise AssertionError("The Windows mixed-mount reproduction did not fail")
+
+    for output, inputs in (
+        (mapped, r"I:\comfyui_input"),
+        (unc, r"\\mightyjobs\Inputs\comfyui_input"),
+        (r"D:\ComfyUI\output", r"D:\ComfyUI\input"),
+    ):
+        helpers = chain_paths(win, output, inputs)
+        canonical_root = win.path.realpath(output)
+        assert helpers["_output_root"]() == canonical_root
+        assert helpers["_input_root"]() == win.path.realpath(inputs)
+        for artifact in (ntpath.join(output, relative),
+                         ntpath.join(canonical_root, relative)):
+            saved = helpers["_relative_output_path"](artifact)
+            assert saved == relative
+            assert helpers["_absolute_output_path"](saved) == (
+                ntpath.join(canonical_root, relative))
+            assert helpers["_absolute_output_path"](artifact) == (
+                ntpath.join(canonical_root, relative))
+            cache_key = helpers.get("_png_export_checkpoint_cache_key")
+            if cache_key is not None:
+                assert cache_key(artifact) == relative.replace("\\", "/")
+        expect_escape(lambda: helpers["_absolute_output_path"](r"..\outside.mp4"))
+        expect_escape(lambda: helpers["_absolute_output_path"](
+            r"\\another-server\share\outside.mp4"))
+        expect_escape(lambda: helpers["_absolute_output_path"](
+            canonical_root + r"_other\outside.mp4"))
+
+        with contextlib.ExitStack() as stack:
+            for module in (asset_store, run_manager, project_assets,
+                           checkpoint_manager):
+                stack.enter_context(patch.object(module, "os", win))
+            assets = asset_store.RunAssetStore(output, inputs)
+            runs = run_manager.RunArchiveManager(output, inputs)
+            carousel = project_assets.ProjectAssetStore(inputs, output)
+            checkpoints = checkpoint_manager.CheckpointGraphManager(output)
+            for store in (assets, runs, carousel, checkpoints):
+                assert store.output_root == canonical_root
+            manifest_path = assets._manifest_path("demo")[0]
+            assert ntpath.relpath(manifest_path, assets.output_root) == (
+                r"h3_chains\demo\references\manifest.json")
+            assert runs._run_dir("demo")[0] == ntpath.join(
+                canonical_root, "h3_chains", "demo")
+            project_dir = carousel._project_dir("demo")[0]
+            assert ntpath.relpath(project_dir, carousel.input_root) == (
+                r"h3_projects\demo")
+
+    # A different mapping of the same share must still load saved relative data.
+    remapped = chain_paths(win, r"S:\comfyui_output", r"I:\comfyui_input")
+    assert remapped["_absolute_output_path"](relative) == ntpath.join(unc, relative)
+    assert remapped["_relative_output_path"](ntpath.join(mapped, relative)) == relative
+
+
+def filesystem_checks():
+    # Real filesystem alias test also protects Linux symlinks and macOS paths.
+    with tempfile.TemporaryDirectory() as temporary:
+        root = pathlib.Path(temporary)
+        physical = root / "physical output"
+        physical.mkdir()
+        alias = root / "configured output"
+        try:
+            alias.symlink_to(physical, target_is_directory=True)
+        except OSError:
+            print("Symlink check skipped: this host cannot create symlinks")
+            return
+        helpers = chain_paths(os, str(alias), str(alias))
+        relative = os.path.join("h3_chains", "demo", "plan.json")
+        artifact = physical / relative
+        artifact.parent.mkdir(parents=True)
+        artifact.write_text("{}", encoding="utf-8")
+        assert helpers["_relative_output_path"](str(artifact)) == relative
+        assert helpers["_relative_output_path"](str(alias / relative)) == relative
+        assert pathlib.Path(helpers["_absolute_output_path"](relative)).samefile(artifact)
+
+
+if __name__ == "__main__":
+    windows_checks()
+    filesystem_checks()
+    print("Windows output paths: mapped drives, UNC, local disks, remapping, "
+          "artifact round trips, asset roots, and containment checks pass")
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_workflow_catalog_unit_test.py b/ComfyUI-MiniMaxH3-Context-Loop/tests/_workflow_catalog_unit_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..fdf18cd6fc64c76989c851d846060e1a2d111c09
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_workflow_catalog_unit_test.py
@@ -0,0 +1,405 @@
+#!/usr/bin/env python3
+"""Release-level checks for the clean 0.6 workflow catalog."""
+
+from __future__ import annotations
+
+import hashlib
+import json
+from pathlib import Path
+
+
+ROOT = Path(__file__).resolve().parents[1]
+EXAMPLES = ROOT / "example_workflows"
+ARCHIVE_05 = EXAMPLES / "Archive" / "0.5"
+WORKFLOWS = {
+    "Deferred Upscale + De-Rope - H3 LBH 3D - MiniMax H3 0.6.json",
+    "Deferred Upscale - H3 LBH 3D - MiniMax H3 0.6.json",
+    "Deferred Upscale - Pixel DLSS5 + USDU - EXPERIMENTAL - MiniMax H3 0.6.json",
+    "Deferred Upscale - SeedVR2 Full Chain - MiniMax H3 0.6.json",
+    "FL2V Normal - MiniMax H3 0.6.json",
+    "I2V Normal - MiniMax H3 0.6.json",
+    "I2V Studio - MiniMax H3 0.6.json",
+    "Masked AV Bridge - Two Clips - MiniMax H3 0.6.json",
+    "Masked AV Extension - Chain + Reference Image - MiniMax H3 0.6.json",
+    "Masked AV Extension - Single Clip - MiniMax H3 0.6.json",
+    "Masked Video Inpaint - MiniMax H3 0.6.json",
+    "Ref2V Basic - MiniMax H3 0.6.json",
+    "Ref2V Masked Video Inpaint - MiniMax H3 0.6.json",
+    "Ref2V Sequential Motion - EXPERIMENTAL - MiniMax H3 0.6.json",
+    "Ref2V Studio - MiniMax H3 0.6.json",
+    "Ref2V Studio Source Audio - MiniMax H3 0.6.json",
+    "Ref2V Tagged - MiniMax H3 0.6.json",
+    "T2V Normal - MiniMax H3 0.6.json",
+    "T2V Studio - MiniMax H3 0.6.json",
+}
+LEGACY_NAMES = {
+    "Ref2V Studio Tagged - MiniMax H3.json",
+    "Ref2V Studio Tagged Source Audio - MiniMax H3.json",
+}
+ARRIVAL_SHA256 = (
+    "1e7b02dbf5d4f3d51f6e65e1c8cbf6f35b542995a7b27f278889efa32ef9462c")
+DELIVERY_SHA256 = (
+    "d225b876063e9fe7c611f8b0217dc961f2ed34eaee4445a0c895d9b6e30b5b76")
+CRAB_HASHES = {
+    "soldier_crabs_bribie_island_cc0.webm":
+        "aacef1ac138445311eb61734f8ca92f8dc438b8d9ca3210fd8893aa5e925ee47",
+    "soldier_crabs_inpaint_mask.png":
+        "95cf18228cd3559ad980339fe9d8fccdcef25799368719b8e044cd61c6691fe4",
+    "soldier_crabs_reference_cc0.png":
+        "432dc2c9b0b9d0c33ed33217247fefcbe551d240959f6eefb7c04dfc99378047",
+}
+STALE_KEYS = {"cnr_id", "ver", "aux_id", "frontendVersion",
+              "ue_links", "links_added_by_ue"}
+BASE_SECTIONS = (
+    "integrated_multimodal_description:",
+    "overall_soundscape:",
+    "non_diegetic_music:",
+)
+REF_SECTIONS = (
+    "subject_definitions:", "summary:", "retention_analysis:",
+    "detailed_description:", "overall_soundscape:",
+    "non_diegetic_music:",
+)
+CANONICAL_H3_MODELS = {
+    "minimax_h3_fl2va_pruned_int8_convrot.safetensors",
+    "minimax_h3_ref2va_pruned_int8_convrot.safetensors",
+    "qwen3vl_32b_minimax_h3_int8_convrot.safetensors",
+    "minimax_h3_video_vae_fp16.safetensors",
+    "minimax_h3_audio_vae_fp32.safetensors",
+}
+
+
+def load(path: Path) -> dict:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def nodes(workflow: dict, node_type: str) -> list[dict]:
+    return [node for node in workflow["nodes"]
+            if node.get("type") == node_type]
+
+
+def one(workflow: dict, node_type: str) -> dict:
+    result = nodes(workflow, node_type)
+    assert len(result) == 1, (node_type, len(result))
+    return result[0]
+
+
+def input_socket(node: dict, name: str) -> dict:
+    return next(value for value in node.get("inputs", [])
+                if value.get("name") == name)
+
+
+def output_socket(node: dict, name: str) -> dict:
+    return next(value for value in node.get("outputs", [])
+                if value.get("name") == name)
+
+
+def link(workflow: dict, link_id: int) -> list:
+    return next(value for value in workflow["links"] if value[0] == link_id)
+
+
+def origin(workflow: dict, target: dict, input_name: str) -> dict:
+    linked = link(workflow, input_socket(target, input_name)["link"])
+    return next(node for node in workflow["nodes"] if node["id"] == linked[1])
+
+
+def validate_links(workflow: dict) -> None:
+    node_map = {node["id"]: node for node in workflow["nodes"]}
+    link_map = {item[0]: item for item in workflow["links"]}
+    assert sorted(node_map) == list(range(1, len(node_map) + 1))
+    assert sorted(link_map) == list(range(1, len(link_map) + 1))
+    assert workflow["last_node_id"] == len(node_map)
+    assert workflow["last_link_id"] == len(link_map)
+    for link_id, value in link_map.items():
+        _, source_id, source_slot, target_id, target_slot, kind = value
+        assert source_id in node_map and target_id in node_map
+        source = node_map[source_id]["outputs"][source_slot]
+        target = node_map[target_id]["inputs"][target_slot]
+        assert link_id in (source.get("links") or [])
+        assert target.get("link") == link_id
+        assert isinstance(kind, str) and kind
+    for node in node_map.values():
+        for value in node.get("inputs", []):
+            if value.get("link") is not None:
+                assert value["link"] in link_map
+        for value in node.get("outputs", []):
+            assert all(item in link_map for item in (value.get("links") or []))
+
+
+def validate_layout(workflow: dict) -> None:
+    rectangles = []
+    for node in workflow["nodes"]:
+        assert len(node.get("pos", [])) >= 2
+        assert len(node.get("size", [])) >= 2
+        x, y = map(float, node["pos"][:2])
+        width, height = map(float, node["size"][:2])
+        assert width > 0 and height > 0
+        # LiteGraph position starts below the title. The former body-only check
+        # missed title clipping when two nodes were stacked too closely.
+        rectangles.append((node["id"], node["type"], x, y - 30, width, height + 30))
+    left = min(item[2] for item in rectangles)
+    top = min(item[3] for item in rectangles)
+    right = max(item[2] + item[4] for item in rectangles)
+    bottom = max(item[3] + item[5] for item in rectangles)
+    assert right - left <= 10000, "workflow layout is excessively wide"
+    assert bottom - top <= 4600, "workflow layout is excessively tall"
+    for index, first in enumerate(rectangles):
+        _, _, ax, ay, aw, ah = first
+        for second in rectangles[index + 1:]:
+            _, _, bx, by, bw, bh = second
+            assert not (ax < bx + bw and bx < ax + aw
+                        and ay < by + bh and by < ay + ah), (first, second)
+    assert workflow["groups"][0]["title"] == "01 • PROJECT & SCENES"
+    membership = {item[0]: 0 for item in rectangles}
+    for group in workflow["groups"]:
+        gx, gy, gw, gh = map(float, group["bounding"])
+        members = [item for item in rectangles
+                   if gx <= item[2] and gy <= item[3]
+                   and item[2] + item[4] <= gx + gw
+                   and item[3] + item[5] <= gy + gh]
+        assert members, group["title"]
+        for member in members:
+            membership[member[0]] += 1
+    assert set(membership.values()) == {1}, "Every node must fit inside exactly one group, including its title"
+    groups = {group["title"]: group for group in workflow["groups"]}
+    author_x, _, author_width, _ = map(float, groups["01 • PROJECT & SCENES"]["bounding"])
+    for title, runtime in groups.items():
+        if title != "01 • PROJECT & SCENES":
+            assert author_x + author_width <= runtime["bounding"][0], "Project controls must precede runtime"
+    for index, first in enumerate(workflow["groups"]):
+        ax, ay, aw, ah = first["bounding"]
+        for second in workflow["groups"][index + 1:]:
+            bx, by, bw, bh = second["bounding"]
+            assert not (ax < bx + bw and bx < ax + aw and ay < by + bh and by < ay + ah), (first["title"], second["title"])
+    recovery_loaders = [n for n in workflow["nodes"]
+                        if n["type"] == "MiniMaxH3ChainManifestLoad" and n["mode"] == 2]
+    recovery_assemblers = [n for n in workflow["nodes"]
+                           if n["type"] == "MiniMaxH3ChainAssemble" and n["mode"] == 2]
+    if recovery_loaders and recovery_assemblers:
+        assert recovery_loaders[0]["pos"][0] < recovery_assemblers[0]["pos"][0]
+    assert not any(n.get("title", "").startswith("RECOVERY") and n["mode"] != 2
+                   for n in workflow["nodes"]), "Bypassed runtime controls are not a recovery path"
+
+
+def validate_clean_metadata(workflow: dict) -> None:
+    assert workflow["revision"] == 0
+    assert workflow["version"] == 0.4  # ComfyUI UI-workflow schema version.
+    assert set(workflow["extra"]) == {"ds", "comfyui_mcp"}
+    assert workflow["id"] == workflow["extra"]["comfyui_mcp"][
+        "workflow_uuid"]
+
+    def walk(value):
+        if isinstance(value, dict):
+            assert not (set(value) & STALE_KEYS), set(value) & STALE_KEYS
+            for child in value.values():
+                walk(child)
+        elif isinstance(value, list):
+            for child in value:
+                walk(child)
+
+    walk(workflow)
+    serialized = json.dumps(workflow, ensure_ascii=False)
+    for stale_text in (
+            "jigen_market_garden", "@style_base", "@interior",
+            "Classic Doom", "0.5 PREFLIGHT", "MiniMaxH3ChainRunManager",
+            "MiniMax-H3/", "MiniMaw-H3/"):
+        assert stale_text not in serialized, stale_text
+    for node in workflow["nodes"]:
+        assert node.get("properties") == {
+            "Node name for S&R": node["type"]}
+
+
+def validate_modern_authoring(workflow: dict, path: Path) -> None:
+    legacy = {"MiniMaxH3ChainPlan", "MiniMaxH3ChainPolicy",
+              "MiniMaxH3ChainRunManager", "MiniMaxH3Legacy04PolicyAdapter"}
+    assert not [node for node in workflow["nodes"]
+                if node["type"] in legacy], path.name
+    plans = nodes(workflow, "MiniMaxH3ChainPlanModern")
+    if not plans:
+        return
+    plan = one(workflow, "MiniMaxH3ChainPlanModern")
+    profile = one(workflow, "MiniMaxH3GenerationProfile")
+    assert origin(workflow, plan, "chain_policy") == profile
+    assert len(plan["widgets_values"]) == 12
+    assert plan["widgets_values"][8] == 20
+    document = json.loads(plan["widgets_values"][0])
+    assert document["shots"]
+    assert all(shot.get("steps") == 20 for shot in document["shots"])
+    assert all(str(shot.get("seed", "")) for shot in document["shots"])
+
+    if path.name.startswith(("T2V", "I2V", "FL2V")):
+        for shot in document["shots"]:
+            text = str(shot["prompt"])
+            positions = [text.index(section) for section in BASE_SECTIONS]
+            assert positions == sorted(positions) and positions[0] == 0
+            assert "Doom" not in text and "Market Garden" not in text
+    if path.name.startswith("Ref2V") and "Masked" not in path.name:
+        for shot in document["shots"]:
+            text = str(shot["prompt"])
+            positions = [text.index(section) for section in REF_SECTIONS]
+            assert positions == sorted(positions) and positions[0] == 0
+            assert "<Subject 1>" in text
+            assert "Doom" not in text and "Market Garden" not in text
+
+
+def validate_studio(workflow: dict, path: Path) -> None:
+    studios = nodes(workflow, "MiniMaxH3ChainPlanStudio")
+    if not studios:
+        return
+    studio = one(workflow, "MiniMaxH3ChainPlanStudio")
+    carousel = one(workflow, "MiniMaxH3ProjectAssetManager")
+    manager = one(workflow, "MiniMaxH3ChainCheckpointManager")
+    plan = one(workflow, "MiniMaxH3ChainPlanModern")
+    loop_start = one(workflow, "MiniMaxH3ChainLoopStart")
+    assert origin(workflow, plan, "project_assets") == carousel
+    assert origin(workflow, studio, "project_assets") == carousel
+    assert origin(workflow, studio, "tagged_references") == carousel
+    assert origin(workflow, manager, "plan") == studio
+    assert origin(workflow, loop_start, "plan") == studio
+    for external in nodes(workflow, "MiniMaxH3ChainExternalVideo"):
+        assert origin(workflow, external, "plan") == studio
+    assert manager["size"][0] >= 1200 and manager["size"][1] >= 900
+    assert carousel["size"][0] >= 760 and carousel["size"][1] >= 700
+    author_group = next(group for group in workflow["groups"]
+                        if group["title"] == "01 • PROJECT & SCENES")
+    assert float(author_group["bounding"][2]) <= 4300
+    assert not nodes(workflow, "MiniMaxH3ChainRunManager")
+    if path.name.startswith("Ref2V Studio"):
+        assert not nodes(workflow, "MiniMaxH3TaggedPictureReference")
+        wrapper = one(workflow, "MiniMaxH3TaggedReferenceToVideo")
+        assert origin(workflow, wrapper, "references") == carousel
+    if "Source Audio" in path.name:
+        note = one(workflow, "Note")
+        instructions = note["widgets_values"][0]
+        for required in ("IMPORT YOUR SOUNDTRACK HERE", "Project Asset Carousel",
+                         "Audio use → Project timeline source", "Lip-sync to source audio",
+                         "preset alone does not load an audio file", "Carousel.project_assets"):
+            assert required in instructions, f"Missing source-audio setup note: {required}"
+        assert note["size"][1] >= 70 + 20 * len(instructions.splitlines())
+        profile = one(workflow, "MiniMaxH3GenerationProfile")
+        assert profile["widgets_values"][1] == "Lip-sync to source audio"
+        assert not nodes(workflow, "LoadAudio")
+        assert not nodes(workflow, "MiniMaxH3SourceTimeline")
+        context = one(workflow, "MiniMaxH3ChainContext")
+        audio_vae = origin(workflow, context, "audio_vae")
+        assert audio_vae["type"] == "VAELoader"
+        assert "audio_vae" in audio_vae["widgets_values"][0]
+
+
+def validate_execution_regressions(workflow: dict, path: Path) -> None:
+    for start in nodes(workflow, "MiniMaxH3ChainLoopStart"):
+        assert start["widgets_values"][0] == 1, "Release examples must start a fresh project"
+    for external in nodes(workflow, "MiniMaxH3ChainExternalVideo"):
+        assert origin(workflow, external, "source_video")["type"] == "LoadVideo"
+        assert input_socket(external, "source_frames")["link"] is None
+        assert input_socket(external, "source_audio")["link"] is None
+    for target in nodes(workflow, "MiniMaxH3ContexLoopSourceAVTarget"):
+        components = origin(workflow, target, "source_frames")
+        assert components["type"] == "GetVideoComponents"
+        assert origin(workflow, components, "video")["type"] == "LoadVideo"
+        # The core loader's native frame rate is not necessarily H3's 24 fps.
+        assert origin(workflow, target, "source_audio") == components
+        assert origin(workflow, target, "source_fps") == components
+        for field, output in (("source_frames", "images"), ("source_audio", "audio"),
+                              ("source_fps", "fps")):
+            wire = link(workflow, input_socket(target, field)["link"])
+            assert components["outputs"][wire[2]]["name"] == output
+    for bridge in nodes(workflow, "MiniMaxH3ContexMaskedAVBridge"):
+        assert not nodes(workflow, "VHS_LoadVideo")
+        prepare = one(workflow, "MiniMaxH3ReferenceVideoPrepare")
+        assert prepare["widgets_values"][0] == 311
+        resize = one(workflow, "ImageScale")
+        conditioning = one(workflow, "MiniMaxH3ImageToVideo")
+        assert resize["widgets_values"][1:3] == conditioning["widgets_values"][1:3]
+        assert conditioning["widgets_values"][3] == 192  # 39 + 114 + 39
+        for side, start, duration in (("start", 0, 99 / 24), ("end", 213 / 24, 0)):
+            components = origin(workflow, bridge, side + "_frames")
+            assert components["type"] == "GetVideoComponents"
+            assert origin(workflow, bridge, side + "_audio") == components
+            sliced = origin(workflow, components, "video")
+            assert sliced["type"] == "Video Slice"
+            assert sliced["widgets_values"] == [start, duration, True]
+            source = origin(workflow, sliced, "video")
+            assert source["type"] == "CreateVideo" and source["widgets_values"][0] == 24
+            assert origin(workflow, source, "images") == resize
+            assert origin(workflow, source, "audio") == prepare
+            assert any(origin(workflow, concat, field) == components
+                       for concat in nodes(workflow, "AudioConcat")
+                       for field in ("audio1", "audio2"))
+
+
+def validate_assets() -> None:
+    assets = EXAMPLES / "assets"
+    expected = {
+        "h3_v06_courier_greenhouse_arrival.png": ARRIVAL_SHA256,
+        "h3_v06_courier_greenhouse_delivery.png": DELIVERY_SHA256,
+        **CRAB_HASHES,
+    }
+    for name, digest in expected.items():
+        path = assets / name
+        assert path.is_file(), path
+        assert hashlib.sha256(path.read_bytes()).hexdigest() == digest
+
+
+def main() -> None:
+    paths = sorted(EXAMPLES.glob("*.json"))
+    assert {path.name for path in paths} == WORKFLOWS
+    assert all("MiniMax H3 0.6.json" in path.name for path in paths)
+    assert not (LEGACY_NAMES & {path.name for path in paths})
+    assert ARCHIVE_05.is_dir()
+    assert LEGACY_NAMES <= {path.name for path in ARCHIVE_05.glob("*.json")}
+    uuids = set()
+    for path in paths:
+        workflow = load(path)
+        validate_links(workflow)
+        validate_layout(workflow)
+        validate_clean_metadata(workflow)
+        validate_modern_authoring(workflow, path)
+        validate_studio(workflow, path)
+        validate_execution_regressions(workflow, path)
+        uuids.add(workflow["id"])
+        pixel = bool(nodes(workflow, "MiniMaxH3ChainUpscalePixelConditioning"))
+        for node in workflow["nodes"]:
+            if node["type"] in {"UNETLoader", "CLIPLoader", "VAELoader"}:
+                values = node.get("widgets_values") or []
+                if values and values[0] in CANONICAL_H3_MODELS:
+                    assert "/" not in values[0] and "\\" not in values[0]
+            if node["type"] == "KSamplerSelect":
+                assert node["widgets_values"] == (["er_sde"] if pixel else ["res_multistep"])
+            elif node["type"] == "BasicScheduler":
+                assert node["widgets_values"][:2] == (["beta", 3] if pixel else ["simple", 20])
+            elif node["type"] == "H3InjectSchedule":
+                assert node["widgets_values"][:2] == ["simple", 20]
+    assert len(uuids) == len(paths)
+
+    i2v = load(EXAMPLES / "I2V Normal - MiniMax H3 0.6.json")
+    i2v_load = one(i2v, "LoadImage")
+    assert i2v_load["widgets_values"][0] == (
+        "h3_v06_courier_greenhouse_arrival.png")
+    fl2v = load(EXAMPLES / "FL2V Normal - MiniMax H3 0.6.json")
+    assert {node["widgets_values"][0] for node in nodes(fl2v, "LoadImage")} == {
+        "h3_v06_courier_greenhouse_arrival.png",
+        "h3_v06_courier_greenhouse_delivery.png",
+    }
+    tagged = load(EXAMPLES / "Ref2V Tagged - MiniMax H3 0.6.json")
+    assert {node["widgets_values"][0]
+            for node in nodes(tagged, "MiniMaxH3TaggedPictureReference")} == {
+        "courier_arrival", "greenhouse_delivery"}
+    sequential = load(
+        EXAMPLES / "Ref2V Sequential Motion - EXPERIMENTAL - MiniMax H3 0.6.json")
+    video_ref = one(sequential, "MiniMaxH3TaggedVideoReference")
+    assert video_ref["widgets_values"] == [
+        "courier_motion", "courier_motion_audio", "sequential"]
+    sequential_plan = json.loads(one(
+        sequential, "MiniMaxH3ChainPlanModern")["widgets_values"][0])
+    assert all("@courier_motion" in shot["prompt"]
+               and "@courier_motion_audio" in shot["prompt"]
+               for shot in sequential_plan["shots"])
+    validate_assets()
+    print(f"H3 0.6 workflow catalog: {len(paths)} clean UI documents, current Plan/Profile "
+          "authoring, Studio Carousel + Checkpoint Manager, fresh prompts and "
+          "references, valid links, collision-free layouts, and legacy archive pass")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/_workflow_schema_unit_test.py b/ComfyUI-MiniMaxH3-Context-Loop/tests/_workflow_schema_unit_test.py
new file mode 100644
index 0000000000000000000000000000000000000000..9f8c6e53fc1d540dd7b54360cb8ea947712d939a
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/_workflow_schema_unit_test.py
@@ -0,0 +1,75 @@
+#!/usr/bin/env python3
+"""Validate release widgets and socket wiring against this checkout, offline."""
+from __future__ import annotations
+import json
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT / "tools"))
+from workflow_schema import load_schemas, fields, is_widget, widget_fields, validate_value
+
+
+def validate_workflow(workflow, schemas):
+    links = {link[0]: link for link in workflow["links"]}
+    for node in workflow["nodes"]:
+        if node["type"] == "Note":
+            continue
+        schema = schemas[node["type"]]
+        saved = node["widgets_values"]
+        values = {}
+        index = 0
+        for name, spec in widget_fields(schema, values):
+            if isinstance(saved, dict):
+                assert name in saved, (node["type"], name, "missing widget")
+                value = saved[name]
+            else:
+                assert index < len(saved), (node["type"], name, "missing widget")
+                value = saved[index]
+            validate_value(value, spec, (node["id"], node["type"], name))
+            values[name] = value
+            index += 1
+        assert len(saved) == index, (node["type"], "stale extra widgets")
+        inputs = {s["name"]: s for s in node["inputs"]}
+        specs = fields(schema)
+        for name, socket in inputs.items():
+            if "." in name and name.split(".")[0] in specs:
+                assert specs[name.split(".")[0]][0] == "COMFY_AUTOGROW_V3"
+                continue
+            assert name in specs, (node["type"], name, "unknown input")
+            if is_widget(specs[name]):
+                assert socket.get("widget") == {"name": name}, (node["type"], name, "converted widget metadata")
+            if socket["link"] is not None:
+                link = links[socket["link"]]
+                assert link[3] == node["id"] and node["inputs"][link[4]] is socket
+        for name, spec in schema["input"].get("required", {}).items():
+            if not is_widget(spec):
+                assert name in inputs and inputs[name]["link"] is not None, (node["type"], name, "missing required connection")
+        assert [o["name"] for o in node["outputs"]] == schema["output_name"], node["type"]
+        assert [o["type"] for o in node["outputs"]] == schema["output"], node["type"]
+
+
+def main():
+    schemas = load_schemas()
+    paths = sorted((ROOT / "example_workflows").glob("*.json"))
+    for path in paths:
+        try:
+            validate_workflow(json.loads(path.read_text()), schemas)
+        except Exception as exc:
+            raise AssertionError(path.name) from exc
+    # The old audit passed this real broken array: prompt -> clip_index,
+    # "match" -> height. Ensure it can never pass release checks again.
+    wf = json.loads((ROOT / "example_workflows/Ref2V Studio - MiniMax H3 0.6.json").read_text())
+    tagged = next(n for n in wf["nodes"] if n["type"] == "MiniMaxH3TaggedReferenceToVideo")
+    tagged["widgets_values"] = tagged["widgets_values"][2:]
+    try:
+        validate_workflow(wf, schemas)
+    except AssertionError:
+        pass
+    else:
+        raise AssertionError("Shifted Tagged Ref2VA widget regression was not caught")
+    print(f"H3 0.6 schemas: all {len(paths)} workflows; local H3 + external contracts, widget types/choices/ranges, required sockets and converted inputs pass")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/fixtures/v0_4_public_contract.json b/ComfyUI-MiniMaxH3-Context-Loop/tests/fixtures/v0_4_public_contract.json
new file mode 100644
index 0000000000000000000000000000000000000000..3ead392edb0bcc7e7f6e7690d0dec7f5c309d3d6
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/fixtures/v0_4_public_contract.json
@@ -0,0 +1,94 @@
+{
+  "format": "h3_v0_4_public_contract_fixture_v1",
+  "project_version": "0.4.9",
+  "plan_required_input_order": [
+    "plan_json",
+    "run_name",
+    "generation_fingerprint",
+    "width",
+    "height",
+    "context_length",
+    "encode_mode",
+    "anchor_mode",
+    "crop",
+    "audio_mode",
+    "audio_context_length",
+    "default_duration_seconds",
+    "default_steps",
+    "base_seed",
+    "segment_crf",
+    "video_blend_frames",
+    "continuation_mode"
+  ],
+  "loop_start_optional_input_order": [
+    "scene_range",
+    "verify_resume_history",
+    "source_audio",
+    "external_context"
+  ],
+  "legacy_audio_modes": {
+    "source_track": {
+      "final_audio": "source",
+      "source_reference": "on",
+      "generated_continuity": "off"
+    },
+    "generated_audio": {
+      "final_audio": "generated",
+      "source_reference": "off",
+      "generated_continuity": "on"
+    },
+    "source_plus_timeline": {
+      "final_audio": "source",
+      "source_reference": "on",
+      "generated_continuity": "on"
+    }
+  },
+  "positional_outputs": {
+    "MiniMaxH3ChainPlan": [
+      "plan",
+      "summary",
+      "clip_count",
+      "width",
+      "height",
+      "video_blend_frames"
+    ],
+    "MiniMaxH3ChainLoopStart": ["flow", "state", "status"],
+    "MiniMaxH3ChainCurrent": [
+      "state",
+      "clip_index",
+      "clip_count",
+      "shot_id",
+      "prompt",
+      "noise_seed",
+      "length",
+      "steps",
+      "width",
+      "height",
+      "audio_start",
+      "audio_duration",
+      "source_audio_slice",
+      "status"
+    ],
+    "MiniMaxH3ChainContext": [
+      "conditioning",
+      "trim_frames",
+      "is_continuation",
+      "latent"
+    ],
+    "MiniMaxH3ChainLoopEnd": [
+      "manifest",
+      "manifest_json",
+      "last_context_frames",
+      "last_context_latent"
+    ],
+    "MiniMaxH3ChainManifestLoad": ["manifest", "manifest_json", "status"],
+    "MiniMaxH3ChainAssemble": ["video_path"]
+  },
+  "checkpoint_formats": [
+    "h3_chain_plan_archive_v1",
+    "h3_chain_checkpoint_v3",
+    "h3_chain_segment_v3",
+    "h3_chain_manifest_v3",
+    "h3_chain_partial_manifest_v3"
+  ]
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tests/seam_probe.py b/ComfyUI-MiniMaxH3-Context-Loop/tests/seam_probe.py
new file mode 100644
index 0000000000000000000000000000000000000000..e2d1226c165b5ef276371d1eef683de8bbef92af
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tests/seam_probe.py
@@ -0,0 +1,236 @@
+"""Seam probe: is clip B's regenerated head audio a drifting copy of clip
+A's tail, or unrelated noise?
+
+Usage:
+    python seam_probe.py clip_A.flac clip_B_UNTRIMMED.flac [--frames 22] [--fps 24]
+
+clip_B_UNTRIMMED must be B's audio BEFORE the trim node -- branch the audio
+VAE decode output to a Save Audio node in parallel with the trim. clip_A is
+the previous clip as delivered (tail-matched is fine; match_tail only
+removes ~8ms and the probe aligns on content, not file length).
+
+The pinned video covers B's frames 0..N-1, which the model generates as a
+reconstruction of A's last N frames. This script slides short windows of
+B's head over the corresponding region of A's tail and reports, per window:
+
+    t_B      window position in B (seconds from B's start)
+    lag_ms   how far B runs behind A (positive = B is LATE: its copy of
+             the bassline arrives after A's original did). Tracked with
+             period-ambiguity handling, so a repeating bassline does not
+             fake a drift by cycle-hopping.
+    corr     normalised cross-correlation peak (1.0 = identical shape,
+             ~0 = unrelated)
+
+Reading the result:
+    corr high (>0.6) and lag ~0 throughout        clean continuation; the
+                                                  blip is something else
+    corr high, lag grows/shifts toward the seam   PHASE DRIFT -- crossfade
+                                                  at the join is the fix,
+                                                  shorter video window
+                                                  should shrink it
+    corr low from the start                       the ref path is not
+                                                  continuing A's audio at
+                                                  all; windowing will never
+                                                  fix it (idea 4 territory)
+
+Dependencies: numpy, plus ONE of torchaudio / soundfile / stdlib wave
+(16/32-bit PCM wav). ComfyUI's embedded python has numpy and torchaudio.
+Run it with that interpreter if your system python lacks them, e.g.:
+    python_embeded\\python.exe seam_probe.py A.flac B_untrimmed.flac
+"""
+
+import argparse
+import sys
+
+import numpy as np
+
+
+def load_audio(path):
+    """Return (mono float64 array, sample_rate)."""
+    try:
+        import torchaudio
+        wav, sr = torchaudio.load(path)
+        return wav.mean(dim=0).numpy().astype(np.float64), int(sr)
+    except Exception:
+        pass
+    try:
+        import soundfile as sf
+        data, sr = sf.read(path, always_2d=True)
+        return data.mean(axis=1).astype(np.float64), int(sr)
+    except Exception:
+        pass
+    import wave
+    with wave.open(path, "rb") as w:
+        sr = w.getframerate()
+        n = w.getnframes()
+        width = w.getsampwidth()
+        ch = w.getnchannels()
+        raw = w.readframes(n)
+    dtype = {1: np.uint8, 2: np.int16, 4: np.int32}.get(width)
+    if dtype is None:
+        raise RuntimeError("unsupported wav sample width %d" % width)
+    data = np.frombuffer(raw, dtype=dtype).astype(np.float64)
+    if width == 1:
+        data -= 128.0
+    data = data.reshape(-1, ch).mean(axis=1)
+    return data, sr
+
+
+def norm_xcorr(win, ref):
+    """Slide `win` across `ref`; return (offsets, ncc) where offsets index
+    positions of the window's start within ref."""
+    win = win - win.mean()
+    ref = ref - ref.mean()
+    wn = np.sqrt((win ** 2).sum())
+    if wn < 1e-12:
+        return None, None
+    corr = np.correlate(ref, win, mode="valid")
+    csum = np.concatenate(([0.0], np.cumsum(ref ** 2)))
+    seg = csum[len(win):] - csum[:-len(win)]
+    denom = wn * np.sqrt(np.maximum(seg, 1e-12))
+    return np.arange(len(corr)), corr / denom
+
+
+def tracked_peak(ncc, expect_idx):
+    """Pick this window's alignment with period-ambiguity handling.
+
+    Music is periodic -- a 100 Hz bassline repeats every 10 ms -- so the
+    global NCC argmax can hop a whole cycle between windows and fake a
+    drift. Instead: take every local maximum within 10% of the global
+    peak, and follow the one CLOSEST to the alignment predicted by the
+    previous window (starting from zero lag). Genuine drift moves far
+    less than a period per 25 ms hop, so continuity keeps the true peak
+    and discards cycle aliases.
+    """
+    best = float(ncc.max())
+    i = np.arange(1, len(ncc) - 1)
+    peaks = i[(ncc[i] >= ncc[i - 1]) & (ncc[i] >= ncc[i + 1]) &
+              (ncc[i] >= 0.9 * best)]
+    if len(peaks) == 0:
+        peaks = np.array([int(np.argmax(ncc))])
+    pick = int(peaks[np.argmin(np.abs(peaks - expect_idx))])
+    return pick, float(ncc[pick])
+
+
+def main():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("clip_a")
+    ap.add_argument("clip_b_untrimmed")
+    ap.add_argument("--frames", type=int, default=22,
+                    help="pinned video frames (the span the model regenerates)")
+    ap.add_argument("--fps", type=float, default=24.0)
+    ap.add_argument("--win-ms", type=float, default=50.0,
+                    help="analysis window length")
+    ap.add_argument("--hop-ms", type=float, default=25.0,
+                    help="hop between windows (25ms = one audio latent step)")
+    ap.add_argument("--search-ms", type=float, default=40.0,
+                    help="max lag searched either side")
+    args = ap.parse_args()
+
+    a, sr_a = load_audio(args.clip_a)
+    b, sr_b = load_audio(args.clip_b_untrimmed)
+    if sr_a != sr_b:
+        sys.exit("sample rates differ (%d vs %d); resample first" % (sr_a, sr_b))
+    sr = sr_a
+
+    span_s = args.frames / args.fps
+    span = int(round(span_s * sr))
+    if len(b) < span:
+        sys.exit("clip B shorter than the pinned span -- is this the "
+                 "UNTRIMMED audio?")
+    if len(a) < span:
+        sys.exit("clip A shorter than the pinned span")
+
+    # B[0:span] should reconstruct A[-span:]
+    a_tail_start = len(a) - span
+    win = int(round(args.win_ms / 1000.0 * sr))
+    hop = int(round(args.hop_ms / 1000.0 * sr))
+    search = int(round(args.search_ms / 1000.0 * sr))
+
+    print("clip A: %.3fs   clip B (untrimmed): %.3fs   sr %d" %
+          (len(a) / sr, len(b) / sr, sr))
+    print("pinned span: %d frames = %.4fs = %d samples" %
+          (args.frames, span_s, span))
+    print("window %.0fms, hop %.0fms, search +/-%.0fms" %
+          (args.win_ms, args.hop_ms, args.search_ms))
+    print()
+    print("%8s  %9s  %6s   region" % ("t_B (s)", "lag (ms)", "corr"))
+
+    lags, corrs = [], []
+    t = 0
+    prev_lag = 0  # samples; tracking starts from perfect alignment
+    # continue a little past the seam to see whether alignment against
+    # A's (now nonexistent) continuation collapses, as it should
+    while t + win <= span + int(0.2 * sr) and t + win <= len(b):
+        centre_in_a = a_tail_start + t
+        lo = max(0, centre_in_a - search)
+        hi = min(len(a), centre_in_a + win + search)
+        ref = a[lo:hi]
+        if len(ref) <= win:
+            break
+        offsets, ncc = norm_xcorr(b[t:t + win], ref)
+        if ncc is None:
+            t += hop
+            continue
+        # index in the ncc curve where lag == prev_lag; sign convention:
+        # positive lag = B is LATE (its content matches an EARLIER part
+        # of A than the nominal position), so match offset = centre - lag
+        expect_idx = (centre_in_a - prev_lag) - lo
+        pick, corr = tracked_peak(ncc, expect_idx)
+        lag = centre_in_a - (lo + pick)
+        in_span = t + win <= span
+        tag = "reconstruction" if in_span else "past seam"
+        print("%8.3f  %9.2f  %6.3f   %s" %
+              (t / sr, lag / sr * 1000.0, corr, tag))
+        if in_span:
+            lags.append(lag / sr * 1000.0)
+            corrs.append(corr)
+            if corr > 0.6:
+                prev_lag = lag  # only track when the match is credible
+        t += hop
+
+    print()
+    if not corrs:
+        sys.exit("no windows analysed")
+    corrs = np.array(corrs)
+    lags = np.array(lags)
+    strong = corrs > 0.6
+    at_edge = np.abs(lags) >= (args.search_ms - 1.0)
+    print("summary over the reconstruction span:")
+    print("  mean corr %.3f   windows with corr>0.6: %d/%d   "
+          "lags pinned at search edge: %d" %
+          (corrs.mean(), int(strong.sum()), len(corrs), int(at_edge.sum())))
+    usable = strong & ~at_edge
+    if usable.sum() >= 5 and corrs.mean() > 0.55:
+        # fit lag = a*t + b over the credible windows; drift is a coherent
+        # trend, so demand small residuals before calling it that
+        idx = np.nonzero(usable)[0].astype(np.float64)
+        sl = lags[usable]
+        a_fit, b_fit = np.polyfit(idx, sl, 1)
+        resid = sl - (a_fit * idx + b_fit)
+        rms = float(np.sqrt((resid ** 2).mean()))
+        total = a_fit * (len(corrs) - 1)
+        print("  lag trend: %.2fms across the span, residual rms %.2fms" %
+              (total, rms))
+        if rms < 2.0 and corrs.mean() > 0.75 and abs(total) > 2.0:
+            print("  -> DRIFT: B tracks A with a coherent %.1fms slide. A "
+                  "~40ms crossfade at the join should mask it; a shorter "
+                  "video window should shrink it." % total)
+        elif rms < 2.0 and corrs.mean() > 0.75:
+            print("  -> B tracks A with stable phase. The blip is not "
+                  "accumulated drift; look at the first generated steps "
+                  "past the seam instead.")
+        else:
+            print("  -> PARTIAL RESEMBLANCE: B resembles A's tail but does "
+                  "not phase-lock to it (mean corr %.2f, lag rms %.1fms). "
+                  "Imitation, not continuation -- idea 4 territory."
+                  % (corrs.mean(), rms))
+    else:
+        print("  -> LOW/INCOHERENT CORRELATION: the regenerated head does "
+              "not phase-track A's tail. The ref path is imitating, not "
+              "continuing; no window length will fix the seam. Idea 4 "
+              "(audio on the keyframe path) is the direction.")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tokenizer_compat.py b/ComfyUI-MiniMaxH3-Context-Loop/tokenizer_compat.py
new file mode 100644
index 0000000000000000000000000000000000000000..d5c2f89d4b1ea2b10af980b5424a945148f30dba
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tokenizer_compat.py
@@ -0,0 +1,125 @@
+"""Backport MiniMax H3's released additional special tokens.
+
+ComfyUI PR #15808 teaches the MiniMax-specific Qwen tokenizer about seven
+tokens declared only by the released ``tokenizer_config.json``.  Older core
+builds instantiate the generic Qwen tokenizer directly and therefore split
+those markers into ordinary sub-tokens.
+
+The compatibility hook below replaces only the module-local tokenizer alias
+used by ``comfy.text_encoders.minimax.MiniMaxH3Tokenizer``.  It leaves the
+shared Qwen tokenizer class untouched, chains any existing module-local
+subclass, and stands down when core already exposes the native implementation.
+"""
+
+from __future__ import annotations
+
+import importlib
+import logging
+from typing import Any
+
+
+_LOG = logging.getLogger(__name__)
+
+MINIMAX_EXTRA_TOKENS = (
+    "<d>",
+    "</d>",
+    "<|cutoff|>",
+    "<|lyrics_start|>",
+    "<|lyrics_end|>",
+    "<|caption_start|>",
+    "<|caption_end|>",
+)
+MINIMAX_EXTRA_TOKEN_IDS = dict(zip(
+    MINIMAX_EXTRA_TOKENS,
+    range(151669, 151676),
+))
+
+_PATCH_MARKER = "_h3_minimax_extra_tokens_compat"
+
+
+def _status(state: str, message: str) -> dict[str, str]:
+    return {"state": state, "message": message}
+
+
+def install_minimax_tokenizer_compat(
+        minimax_module: Any | None = None) -> dict[str, str]:
+    """Install PR #15808 behavior on pre-PR MiniMax tokenizer modules.
+
+    The optional module argument keeps capability detection independently
+    testable without importing ComfyUI.  Startup callers normally omit it.
+    """
+
+    if minimax_module is None:
+        try:
+            minimax_module = importlib.import_module(
+                "comfy.text_encoders.minimax")
+        except Exception as exc:  # ComfyUI may not include H3 yet.
+            return _status("unavailable", "MiniMax tokenizer unavailable: %s" % exc)
+
+    native = getattr(minimax_module, "MiniMaxQwenSDTokenizer", None)
+    if native is not None:
+        return _status(
+            "native",
+            "ComfyUI owns MiniMax H3 additional special tokens",
+        )
+
+    base = getattr(minimax_module, "Qwen3VLSDTokenizer", None)
+    h3_tokenizer = getattr(minimax_module, "MiniMaxH3Tokenizer", None)
+    if not isinstance(base, type) or h3_tokenizer is None:
+        return _status(
+            "unavailable",
+            "MiniMax tokenizer API is not compatible with the guarded backport",
+        )
+    if getattr(base, _PATCH_MARKER, False):
+        return _status(
+            "compat",
+            "MiniMax H3 additional special-token backport is already active",
+        )
+
+    class MiniMaxQwenSDTokenizerCompat(base):
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            tokenizer = getattr(self, "tokenizer", None)
+            add_special_tokens = getattr(tokenizer, "add_special_tokens", None)
+            get_vocab = getattr(tokenizer, "get_vocab", None)
+            if not callable(add_special_tokens) or not callable(get_vocab):
+                raise RuntimeError(
+                    "MiniMax H3 tokenizer compatibility requires a tokenizer "
+                    "with add_special_tokens() and get_vocab().")
+
+            add_special_tokens({
+                "additional_special_tokens": list(MINIMAX_EXTRA_TOKENS),
+            })
+            vocab = get_vocab()
+            self.inv_vocab = {token_id: token for token, token_id in vocab.items()}
+
+            mismatched = {
+                token: (vocab.get(token), expected)
+                for token, expected in MINIMAX_EXTRA_TOKEN_IDS.items()
+                if vocab.get(token) != expected
+            }
+            if mismatched:
+                _LOG.warning(
+                    "MiniMax H3 additional special-token ids differ from the "
+                    "released tokenizer: %s", mismatched)
+
+    MiniMaxQwenSDTokenizerCompat.__name__ = "MiniMaxQwenSDTokenizer"
+    MiniMaxQwenSDTokenizerCompat.__qualname__ = "MiniMaxQwenSDTokenizer"
+    setattr(MiniMaxQwenSDTokenizerCompat, _PATCH_MARKER, True)
+    setattr(
+        MiniMaxQwenSDTokenizerCompat,
+        "_h3_minimax_extra_tokens",
+        MINIMAX_EXTRA_TOKENS,
+    )
+
+    # MiniMaxH3Tokenizer's factory resolves this module global at runtime.
+    # Replacing the alias avoids modifying the shared Qwen tokenizer class.
+    minimax_module.Qwen3VLSDTokenizer = MiniMaxQwenSDTokenizerCompat
+    if not hasattr(minimax_module, "MINIMAX_EXTRA_TOKENS"):
+        minimax_module.MINIMAX_EXTRA_TOKENS = list(MINIMAX_EXTRA_TOKENS)
+    _LOG.info(
+        "MiniMax H3 tokenizer: enabled PR #15808 special-token compatibility")
+    return _status(
+        "compat",
+        "Installed MiniMax H3 additional special-token backport",
+    )
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tools/build_v06_workflows.py b/ComfyUI-MiniMaxH3-Context-Loop/tools/build_v06_workflows.py
new file mode 100644
index 0000000000000000000000000000000000000000..a023f5069694dd2ecb5bc7be5bb3f111b66b546d
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tools/build_v06_workflows.py
@@ -0,0 +1,246 @@
+#!/usr/bin/env python3
+"""Compile fresh 0.6 workflows from named recipes and this branch's schemas.
+
+No archived workflow, widget array, position, or frontend metadata is an input.
+Settings and wires use names. --check detects stale generated documents.
+"""
+from __future__ import annotations
+import argparse
+import copy
+import json
+import re
+import uuid
+from pathlib import Path
+from workflow_schema import DATA, ROOT, fields, is_widget, widget_fields, validate_value, load_schemas, options
+
+EXAMPLES = ROOT / 'example_workflows'
+NAMESPACE = uuid.UUID('aedf0e28-4e77-4ec8-98d8-7662561e4cf4')
+TITLE_HEIGHT, GAP = 30, 70
+AUTHOR = {'MiniMaxH3ChainPlanModern', 'MiniMaxH3GenerationProfile', 'MiniMaxH3ChainPlanStudio',
+          'MiniMaxH3ProjectAssetManager', 'MiniMaxH3ChainScenePromptEditor',
+          'MiniMaxH3ChainRichScenePromptEditor', 'MiniMaxH3ChainCheckpointManager'}
+SIZES = {
+    'MiniMaxH3ChainPlanModern': (1000,900), 'MiniMaxH3ChainPlanStudio': (1080,940),
+    'MiniMaxH3ProjectAssetManager': (1080,880), 'MiniMaxH3ChainCheckpointManager': (1200,900),
+    'MiniMaxH3ChainScenePromptEditor': (1000,840), 'MiniMaxH3ChainRichScenePromptEditor': (1200,940),
+    'MiniMaxH3ChainReview': (760,880), 'MiniMaxH3ChainCurrent': (460,400),
+    'MiniMaxH3ChainUpscaleCurrent': (480,520), 'MiniMaxH3TaggedReferenceToVideo': (520,540),
+    'MiniMaxH3ReferenceToVideo': (520,420), 'MiniMaxH3ImageToVideo': (500,380),
+    'MiniMaxH3ChainSegmentSave': (460,220), 'MiniMaxH3ChainAssemble': (440,360),
+    'MiniMaxH3ChainContext': (420,260), 'MiniMaxH3LoopTrim': (420,250),
+    'MiniMaxH3ChainLoopEnd': (420,220), 'MiniMaxH3ChainManifestLoad': (440,200),
+    'LoadImage': (400,420), 'LoadImageMask': (400,420), 'LoadVideo': (400,380),
+    'VHS_LoadVideo': (400,580), 'PreviewImage': (420,380), 'PreviewAny': (420,180), 'SaveVideo': (480,440),
+    'SeedVR2VideoPathUpscaler': (520,580), 'Note': (1000,330),
+    'MiniMaxH3ChainUpscalePixelConditioning': (600,520),
+    'MiniMaxH3ChainUpscalePixelCurrent': (500,300),
+    'UltimateSDUpscaleNoUpscaleGuider': (500,720),
+}
+LABELS = {
+    'MiniMaxH3ChainPlanModern':'Production Plan', 'MiniMaxH3ChainPlanStudio':'Plan Studio',
+    'MiniMaxH3ProjectAssetManager':'Project Asset Carousel', 'MiniMaxH3ChainCheckpointManager':'Checkpoint Manager',
+    'MiniMaxH3ChainScenePromptEditor':'Scene Prompts', 'MiniMaxH3ChainRichScenePromptEditor':'Scene Prompts + References',
+    'MiniMaxH3GenerationProfile':'Generation Profile', 'MiniMaxH3ChainLoopStart':'Loop Start',
+    'MiniMaxH3ChainCurrent':'Current Scene', 'MiniMaxH3ChainContext':'Apply Scene Context',
+    'MiniMaxH3TaggedReferenceToVideo':'Tagged Ref2VA Conditioning', 'MiniMaxH3LoopTrim':'Trim Carried Overlap',
+    'MiniMaxH3ChainSegmentSave':'Save Segment + Checkpoint', 'MiniMaxH3ChainReview':'Review Candidates',
+    'MiniMaxH3ChainLoopEnd':'Loop End', 'MiniMaxH3ChainAssemble':'Assemble Final Video',
+    'MiniMaxH3ChainManifestLoad':'Load Saved Clips', 'MiniMaxH3ImageToVideo':'Image / Keyframe Conditioning',
+    'MiniMaxH3ReferenceToVideo':'Reference Conditioning', 'UNETLoader':'H3 Diffusion Model',
+    'CLIPLoader':'H3 Text Encoder', 'RandomNoise':'Scene Seed', 'SamplerCustomAdvanced':'Sample Video + Audio',
+    'BasicScheduler':'Sampling Schedule', 'KSamplerSelect':'Sampler',
+    'MinimaxH3LatentUpscaler3D':'LBH 3D Latent Upscaler', 'SeedVR2VideoPathUpscaler':'SeedVR2 Video Path Upscaler',
+    'MiniMaxH3ChainUpscalePixelCurrent':'Pixel Current Scene • Experimental',
+    'MiniMaxH3ChainUpscalePixelConditioning':'Pixel Conditioning • Actual Image Size',
+    'UltimateSDUpscaleNoUpscaleGuider':'USDU H3 • Refine Upscaled Images',
+}
+
+
+def socket_type(spec):
+    return 'COMBO' if isinstance(spec[0], (list,tuple)) else spec[0]
+
+
+def make_node(recipe, schema, number):
+    typ, settings = recipe['type'], recipe['settings']
+    controls = list(widget_fields(schema, settings))
+    assert not (set(settings)-{key for key,_ in controls}), (typ,'unknown settings')
+    values=[]
+    for key,spec in controls:
+        assert key in settings, (typ,key,'recipe must explicitly name every widget')
+        validate_value(settings[key],spec,(typ,key))
+        values.append(copy.deepcopy(settings[key]))
+    inputs=[]
+    for name,spec in fields(schema).items():
+        if spec[0]=='COMFY_AUTOGROW_V3':
+            template=options(spec)['template']
+            item_spec=next(iter(template['input']['required'].values()))
+            names=[key for key in recipe['inputs'] if key.startswith(name+'.')]
+            names.append(name+'.'+template['prefix']+str(len(names)))
+            inputs.extend({'name':key,'type':socket_type(item_spec),'link':None} for key in names)
+        elif not is_widget(spec) or name in recipe['inputs']:
+            value={'name':name,'type':socket_type(spec),'link':None}
+            if is_widget(spec): value['widget']={'name':name}
+            inputs.append(value)
+    label=LABELS.get(typ) or re.sub(r'(?<=[a-z])(?=[A-Z])',' ',typ.replace('MiniMaxH3','').replace('Contex','Context'))
+    if typ=='VAELoader': label='Audio VAE' if 'audio' in settings['vae_name'] else 'Video VAE'
+    if typ in ('LoadImage','LoadVideo','LoadImageMask'):
+        label={'LoadImage':'Reference Image','LoadVideo':'Source Video','LoadImageMask':'Edit Mask'}[typ]
+    if recipe.get('mode')==2:label='RECOVERY • '+label
+    elif recipe.get('mode')==4:label='OPTIONAL • '+label
+    outputs=[dict(name=name,type=kind,links=None) for name,kind in zip(schema['output_name'],schema['output'])]
+    input_width=max((len(i['name']) for i in inputs),default=0)*7
+    output_width=max((len(o['name']) for o in outputs),default=0)*7
+    width=max(360,len(label)*8+48,input_width+output_width+80)
+    height=64+max(len(inputs),len(outputs))*20+len(controls)*24
+    if any(options(spec).get('multiline') for _,spec in controls):height+=180
+    explicit=SIZES.get(typ,(width,height))
+    width,height=max(width,explicit[0]),max(height,explicit[1])
+    if typ=='VHS_LoadVideo':values=copy.deepcopy(settings)  # VHS uses a named serializer.
+    return dict(id=number,type=typ,pos=[0,0],size=[width,height],flags={},order=number-1,
+                mode=recipe.get('mode',0),inputs=inputs,outputs=outputs,title=label,
+                properties={'Node name for S&R':typ},widgets_values=values)
+
+
+def group(title,members,color):
+    left=min(n['pos'][0] for n in members)-40
+    top=min(n['pos'][1] for n in members)-90
+    right=max(n['pos'][0]+n['size'][0] for n in members)+40
+    bottom=max(n['pos'][1]+n['size'][1] for n in members)+40
+    return dict(title=title,bounding=[left,top,right-left,bottom-top],color=color,font_size=24,flags={})
+
+
+def stack(nodes,x,y):
+    for node in nodes:
+        node['pos']=[x,y]
+        y+=node['size'][1]+TITLE_HEIGHT+GAP
+    return y
+
+
+def layout(nodes,links):
+    groups=[]
+    author=[n for n in nodes if n['type'] in AUTHOR or n['type']=='Note']
+    studio=any(n['type']=='MiniMaxH3ChainPlanStudio' for n in author)
+    columns=[[],[],[]] if studio else [[],[]]
+    priority={'Note':0,'MiniMaxH3GenerationProfile':1,'MiniMaxH3ChainPlanModern':2,
+              'MiniMaxH3ChainPlanStudio':3,'MiniMaxH3ChainScenePromptEditor':3,
+              'MiniMaxH3ChainRichScenePromptEditor':3,'MiniMaxH3ProjectAssetManager':4,
+              'MiniMaxH3ChainCheckpointManager':5}
+    for n in sorted(author,key=lambda n:priority.get(n['type'],9)):
+        t=n['type']; col=0
+        if studio:
+            if t in ('MiniMaxH3ChainPlanStudio','MiniMaxH3ProjectAssetManager'):col=1
+            elif t in ('MiniMaxH3ChainRichScenePromptEditor','MiniMaxH3ChainCheckpointManager'):col=2
+        elif t in ('MiniMaxH3ChainScenePromptEditor','MiniMaxH3ChainRichScenePromptEditor'):col=1
+        columns[col].append(n)
+    x=80
+    for col in columns:
+        if not col:continue
+        stack(col,x,180); x+=max(n['size'][0] for n in col)+120
+    if author:groups.append(group('01 • PROJECT & SCENES',author,'#315566'))
+    x+=100
+    runtime=[n for n in nodes if n not in author and n['mode']!=2]
+    recovery=sorted([n for n in nodes if n not in author and n['mode']==2],
+                    key=lambda n:n['type']!='MiniMaxH3ChainManifestLoad')
+    runtime_ids={n['id'] for n in runtime}
+    predecessors={n['id']:set() for n in runtime}
+    for _,source,_,target,_,_ in links:
+        if source in runtime_ids and target in runtime_ids:predecessors[target].add(source)
+    depths={}
+    while len(depths)<len(runtime):
+        ready=[n for n in runtime if n['id'] not in depths and predecessors[n['id']]<=depths.keys()]
+        assert ready,'Cycle in generation graph'
+        for n in ready:depths[n['id']]=max((depths[p]+1 for p in predecessors[n['id']]),default=0)
+    # Adjacent dependency depths share a column, stacked in topological order.
+    column_numbers=sorted({depths[n['id']]//2 for n in runtime})
+    runtime_left=x
+    for index,layer in enumerate(column_numbers):
+        col=sorted([n for n in runtime if depths[n['id']]//2==layer],key=lambda n:(depths[n['id']],n['id']))
+        stack(col,x,180)
+        types={n['type'] for n in col}; heading='PREPARE SCENE'
+        if index==0:heading='MODELS & INPUTS'
+        if 'SamplerCustomAdvanced' in types:heading='SAMPLE & DECODE'
+        if types & {'MiniMaxH3ChainSegmentSave','MiniMaxH3ChainUpscaleSegmentSave'}:heading='SAVE & REVIEW'
+        if 'MiniMaxH3ChainReview' in types:heading='REVIEW & CONTINUE'
+        if types & {'MiniMaxH3ChainAssemble','SaveVideo'}:heading='DELIVER'
+        groups.append(group(f'{index+2:02d} • {heading}',col,'#393f58' if index%2==0 else '#394c49'))
+        x+=max(n['size'][0] for n in col)+150
+    if recovery:
+        y=max((n['pos'][1]+n['size'][1] for n in runtime),default=180)+180
+        rx=runtime_left
+        for n in recovery:
+            n['pos']=[rx,y];rx+=n['size'][0]+130
+        groups.append(group('RECOVERY • DISABLED / NO SAMPLING',recovery,'#665135'))
+    return groups
+
+
+def build(recipe,filename,schemas):
+    recipe=copy.deepcopy(recipe)
+    guides=[n['settings']['text'] for n in recipe['nodes'] if n['type']=='Note']
+    records=[n for n in recipe['nodes'] if n['type']!='Note']
+    plans=[n for n in records if n['type']=='MiniMaxH3ChainPlanModern']
+    for n in records:
+        if n['type']=='MiniMaxH3ChainPlanStudio' and plans:
+            n['settings'].update({k:v for k,v in plans[0]['settings'].items() if k in n['settings']})
+    nodes=[make_node(n,schemas[n['type']],i+1) for i,n in enumerate(records)]
+    by_key={r['key']:n for r,n in zip(records,nodes)}
+    links=[]
+    for record,node in zip(records,nodes):
+        for input_name,(source_key,output_name) in record['inputs'].items():
+            source=by_key[source_key]
+            source_slots=[i for i,s in enumerate(source['outputs']) if s['name'].lower()==output_name.lower()]
+            assert len(source_slots)==1,(filename,source_key,output_name,'missing/ambiguous output')
+            origin_slot=source_slots[0]
+            target_slot=next(i for i,s in enumerate(node['inputs']) if s['name']==input_name)
+            inp=node['inputs'][target_slot];out=source['outputs'][origin_slot]
+            assert (set(out['type'].split(',')) & set(inp['type'].split(','))
+                    or '*' in (out['type'],inp['type'])), (filename,source['type'],out,node['type'],inp)
+            link_id=len(links)+1
+            links.append([link_id,source['id'],origin_slot,node['id'],target_slot,out['type']])
+            inp['link']=link_id;out['links']=(out['links'] or [])+[link_id]
+    project_step='Set a unique project run name, then edit scenes and the Generation Profile.'
+    if filename.startswith('Deferred'):
+        project_step='Select a saved run and lineage in Checkpoint Manager, then set the upscale profile / target size.'
+    elif filename.startswith('Masked AV Bridge'):
+        project_step='Check both source intervals and the bridge target length; this standalone graph does not use a Plan.'
+    recovery_note=('Recovery is disabled by default. Enable it only to assemble saved clips without sampling.\n'
+                   if any(n['mode']==2 for n in nodes) else '')
+    setup_steps=recipe.get('setup_steps',
+        '1. Install models and extra packs listed in example_workflows/README.md.\n'
+        '2. Copy the supplied assets to ComfyUI/input; select source media where requested.\n'
+        '3. '+project_step+'\n'
+        '4. Follow the numbered columns left → right and inspect the saved results.')
+    note_text=('0.6 RELEASE • '+filename.removesuffix(' - MiniMax H3 0.6.json')+'\n\n'
+        +setup_steps+'\n\n'
+        +recovery_note+
+        'Workflow-specific setup and detailed wiring notes:\nexample_workflows/guides/'+filename.removesuffix('.json')+'.md')
+    note_size=[SIZES['Note'][0],max(SIZES['Note'][1],70+20*len(note_text.splitlines()))]
+    nodes.append(dict(id=len(nodes)+1,type='Note',pos=[0,0],size=note_size,flags={},order=len(nodes),mode=0,
+        inputs=[],outputs=[],title='START HERE • 0.6',properties={'Node name for S&R':'Note'},widgets_values=[note_text]))
+    identity=str(uuid.uuid5(NAMESPACE,filename))
+    workflow=dict(id=identity,revision=0,last_node_id=len(nodes),last_link_id=len(links),nodes=nodes,links=links,
+        groups=layout(nodes,links),config={},extra={'ds':{'scale':0.65,'offset':[30,0]},
+        'comfyui_mcp':{'workflow_uuid':identity}},version=0.4)
+    compatibility_note=recipe.get('compatibility_note','Built for the **0.6 branch**, not nightly.')
+    guide='# '+filename.removesuffix('.json')+'\n\n'+compatibility_note+'\n\n'
+    guide+=('Setup controls come first, followed by numbered generation columns. '+recovery_note).rstrip()+'\n\n'
+    guide+='\n\n---\n\n'.join(guides)+'\n'
+    return workflow,guide
+
+
+def main():
+    parser=argparse.ArgumentParser(description=__doc__)
+    parser.add_argument('--check',action='store_true')
+    parser.add_argument('--output-dir',type=Path,default=EXAMPLES)
+    args=parser.parse_args();schemas=load_schemas()
+    for path in sorted((DATA/'recipes').glob('*.json')):
+        workflow,guide=build(json.loads(path.read_text()),path.name,schemas)
+        outputs={args.output_dir/path.name:json.dumps(workflow,ensure_ascii=False,indent=2)+'\n',
+                 args.output_dir/'guides'/path.with_suffix('.md').name:guide}
+        for target,content in outputs.items():
+            if args.check:assert target.read_text()==content, f'Stale generated file: {target}'
+            else:
+                target.parent.mkdir(parents=True,exist_ok=True);target.write_text(content,encoding='utf-8')
+        print(path.name)
+
+
+if __name__=='__main__':main()
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tools/convert_reference_caches.py b/ComfyUI-MiniMaxH3-Context-Loop/tools/convert_reference_caches.py
new file mode 100644
index 0000000000000000000000000000000000000000..83d63a33b36b6d764818c637de30631fb5779e61
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tools/convert_reference_caches.py
@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""Convert H3 V1/V2 reference bundles without rendering or deleting them."""
+
+import argparse
+import json
+from pathlib import Path
+import sys
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+from reference_cache_migration import LEGACY_FORMATS, ReferenceCacheMigrator
+
+
+def main(argv=None):
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--output-root", required=True, type=Path,
+                        help="ComfyUI output directory containing h3_reference_cache/h3_chains")
+    scope = parser.add_mutually_exclusive_group(required=True)
+    scope.add_argument("--metadata", action="append", help="Exact scene cache JSON (repeatable)")
+    scope.add_argument("--run", help="Convert only this project's reference_cache directory")
+    scope.add_argument("--all", action="store_true", help="Scan shared and project-local reference caches")
+    mode = parser.add_mutually_exclusive_group()
+    mode.add_argument("--apply", action="store_true", help="Write resumable V3 conversions; bundles retire only after a successful H3 render save")
+    mode.add_argument("--dry-run", action="store_true", help="Read-only report (the default)")
+    args = parser.parse_args(argv)
+    migrator = ReferenceCacheMigrator(args.output_root)
+    if not migrator.root.is_dir():
+        parser.error("output root does not exist")
+    if args.run and (Path(args.run).name != args.run or args.run in (".", "..")):
+        parser.error("--run must be one project directory name")
+    if args.run:
+        parent = migrator.absolute(Path("h3_chains") / args.run / "reference_cache")
+        if not parent.is_dir():
+            parser.error("project reference_cache directory does not exist")
+        paths = [path for path in parent.glob("scene_*.json")
+                 if not path.name.endswith((".converted.json", ".retired.json"))]
+    else:
+        paths = [migrator.absolute(path) for path in args.metadata] if args.metadata else list(migrator.legacy_manifests())
+    failures = 0
+    for path in sorted(set(paths)):
+        try:
+            if migrator.read(path).get("format") not in LEGACY_FORMATS:
+                continue
+            result = migrator.convert(path, apply=args.apply)
+            print(json.dumps(result))
+        except Exception as exc:
+            failures += 1
+            print(json.dumps({"status": "error", "metadata": str(path), "error": str(exc)}))
+    print(json.dumps({"mode": "apply" if args.apply else "dry_run", "errors": failures,
+                      "legacy_bundles_deleted": 0}))
+    return 1 if failures else 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tools/migrate_v05_workflows.py b/ComfyUI-MiniMaxH3-Context-Loop/tools/migrate_v05_workflows.py
new file mode 100644
index 0000000000000000000000000000000000000000..e1e907165cb52ad86ae751985c098f310db96633
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tools/migrate_v05_workflows.py
@@ -0,0 +1,656 @@
+#!/usr/bin/env python3
+"""Migrate maintained H3 demo workflow JSON to the compact 0.5 topology.
+
+The sampling body and existing generation settings stay untouched. Normal
+audio and boundary intent is collapsed to one Chain Policy wire. Settings that
+cannot be represented by the four supported compact transition presets are
+preserved exactly through one Legacy 0.4 Policy Adapter node. The source-audio
+reference demo also adopts the single typed Source Timeline route. Every
+custom demo title starts with the node's registered display name so the graph
+still teaches the real node names.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+from typing import Any
+
+
+ROOT = Path(__file__).resolve().parents[1]
+EXAMPLES = ROOT / "example_workflows"
+ARCHIVE_05 = EXAMPLES / "Archive" / "0.5"
+SOURCE_AUDIO_DEMO = "Ref2V Studio Tagged Source Audio - MiniMax H3.json"
+MAINTAINED_DEMOS = (
+    "Ref2V Sequential Motion - EXPERIMENTAL - MiniMax H3.json",
+    "Masked AV Bridge - Two Clips - MiniMax H3.json",
+    "Masked AV Extension - Chain + Reference Image - MiniMax H3.json",
+    "Masked AV Extension - Single Clip - MiniMax H3.json",
+    "Masked Video Inpaint - MiniMax H3.json",
+    "FL2V Normal - MiniMax H3.json",
+    "I2V Normal - MiniMax H3.json",
+    "I2V Studio - MiniMax H3.json",
+    "Ref2V Basic - MiniMax H3.json",
+    "Ref2V Masked Video Inpaint - MiniMax H3.json",
+    SOURCE_AUDIO_DEMO,
+    "Ref2V Studio Tagged - MiniMax H3.json",
+    "Ref2V Tagged - MiniMax H3.json",
+    "T2V Normal - MiniMax H3.json",
+    "T2V Studio - MiniMax H3.json",
+)
+
+# Exact display names exposed by ComfyUI's /object_info for every node type
+# used by the maintained demos when this migration was authored. Types whose
+# display_name is null (and frontend-only nodes such as Note) intentionally
+# fall back to their canonical class type below.
+NODE_DISPLAY_NAMES = {
+    "BasicGuider": "Basic Guider",
+    "CLIPLoader": "Load CLIP",
+    "LoadAudio": "Load Audio",
+    "LoadImage": "Load Image",
+    "LoadImageMask": "Load Image (as Mask)",
+    "LoadVideo": "Load Video",
+    "LoraLoaderModelOnly": "Load LoRA",
+    "MiniMaxH3ChainAssemble": "MiniMax H3 Context Loop Assemble",
+    "MiniMaxH3ChainContext": "MiniMax H3 Context Loop Context",
+    "MiniMaxH3ChainCurrent": "MiniMax H3 Context Loop Current Shot",
+    "MiniMaxH3ChainExternalVideo": "MiniMax H3 Existing Video Context",
+    "MiniMaxH3ChainFirstSceneImage": "MiniMax H3 Frame Gate",
+    "MiniMaxH3ChainFrameIndexSwitch": "MiniMax H3 Frame Index Switch",
+    "MiniMaxH3ChainLoopEnd": "MiniMax H3 Context Loop End",
+    "MiniMaxH3ChainLoopStart": "MiniMax H3 Context Loop Start",
+    "MiniMaxH3ChainManifestLoad": "MiniMax H3 Context Loop Load Manifest",
+    "MiniMaxH3ChainPlan": "MiniMax H3 Context Loop Plan",
+    "MiniMaxH3ChainPlanStudio": "MiniMax H3 Plan Studio (Experimental)",
+    "MiniMaxH3ChainPolicy": "MiniMax H3 Manual Chain Policy (Legacy)",
+    "MiniMaxH3AdvancedPolicy": "MiniMax H3 Advanced Policy Override",
+    "MiniMaxH3Legacy04PolicyAdapter": (
+        "MiniMax H3 Legacy 0.4 Policy Adapter"),
+    "MiniMaxH3ChainPreflight": "MiniMax H3 Chain Preflight",
+    "MiniMaxH3ChainReview": "MiniMax H3 Context Loop Review Gate",
+    "MiniMaxH3ChainRunManager": "MiniMax H3 Run Manager",
+    "MiniMaxH3ChainScenePromptEditor": "MiniMax H3 Scene Prompt Editor",
+    "MiniMaxH3ChainSegmentSave": (
+        "MiniMax H3 Context Loop Segment + Checkpoint"),
+    "MiniMaxH3ContexLoopMaskSlice": (
+        "MiniMax H3 Masking · Loop Mask Slice"),
+    "MiniMaxH3ContexLoopSourceAVTarget": (
+        "MiniMax H3 Masking · Loop Source AV Target"),
+    "MiniMaxH3ContexMaskGridPreview": (
+        "MiniMax H3 Masking · Grid Preview"),
+    "MiniMaxH3ContexMaskedAVBridge": (
+        "MiniMax H3 Masking · Two-Clip AV Bridge"),
+    "MiniMaxH3ContexMaskedTarget": (
+        "MiniMax H3 Masking · Apply Target Mask"),
+    "MiniMaxH3ImageToVideo": "MiniMax H3 Image to Video",
+    "MiniMaxH3LoopTrim": "MiniMax H3 Context Loop Trim",
+    "MiniMaxH3PatchPriority": "MiniMax H3 Patch Priority",
+    "MiniMaxH3ReferenceToVideo": "MiniMax H3 Reference to Video",
+    "MiniMaxH3ReferenceVideoPrepare": "MiniMax H3 Reference Video Prep",
+    "MiniMaxH3SourceTimeline": "MiniMax H3 Source Timeline",
+    "MiniMaxH3TaggedAudioReference": "MiniMax H3 Tagged Audio Ref",
+    "MiniMaxH3TaggedPictureReference": "MiniMax H3 Tagged Picture Ref",
+    "MiniMaxH3TaggedReferenceToVideo": "MiniMax H3 Tagged Ref2VA",
+    "MiniMaxH3TaggedVideoReference": "MiniMax H3 Tagged Video Ref",
+    "PreviewAny": "Preview as Text",
+    "PreviewImage": "Preview Image",
+    "UNETLoader": "Load Diffusion Model",
+    "VAEDecode": "VAE Decode",
+    "VAEDecodeAudio": "VAE Decode Audio",
+    "VAELoader": "Load VAE",
+    "VHS_LoadVideo": "Load Video (Upload) 🎥🅥🅗🅢",
+}
+
+
+def original_node_name(node_type: str) -> str:
+    """Return the registered display name, or the canonical class type."""
+    return NODE_DISPLAY_NAMES.get(node_type, node_type)
+
+
+def _prefix_custom_titles(workflow: dict[str, Any]) -> None:
+    """Keep demo guidance while making the real node name visible first."""
+    for node in workflow.get("nodes", []):
+        if "title" not in node:
+            continue
+        original = original_node_name(str(node.get("type", "Node")))
+        custom = str(node.get("title", "")).strip()
+        prefix = original + " — "
+        if custom == original or custom.startswith(prefix):
+            continue
+        node["title"] = original if not custom else prefix + custom
+
+
+def _node(workflow: dict[str, Any], node_type: str) -> dict[str, Any] | None:
+    return next((item for item in workflow["nodes"]
+                 if item.get("type") == node_type), None)
+
+
+def _input(node: dict[str, Any], name: str) -> dict[str, Any]:
+    return next(item for item in node.get("inputs", [])
+                if item.get("name") == name)
+
+
+def _output(node: dict[str, Any], name: str) -> dict[str, Any]:
+    return next(item for item in node.get("outputs", [])
+                if item.get("name") == name)
+
+
+class Graph:
+    def __init__(self, workflow: dict[str, Any]):
+        self.workflow = workflow
+        self.nodes = {item["id"]: item for item in workflow["nodes"]}
+        self.links = {item[0]: item for item in workflow["links"]}
+        self.next_node = max(self.nodes, default=0) + 1
+        self.next_link = max(self.links, default=0) + 1
+        self.order = max((int(item.get("order", 0))
+                          for item in self.nodes.values()), default=0) + 1
+
+    def add_node(self, node: dict[str, Any]) -> dict[str, Any]:
+        node["id"] = self.next_node
+        node["order"] = self.order
+        self.next_node += 1
+        self.order += 1
+        self.workflow["nodes"].append(node)
+        self.nodes[node["id"]] = node
+        return node
+
+    def add_input(self, node: dict[str, Any], name: str, kind: str,
+                  *, shape: int | None = 7) -> dict[str, Any]:
+        existing = next((item for item in node.get("inputs", [])
+                         if item.get("name") == name), None)
+        if existing is not None:
+            return existing
+        value: dict[str, Any] = {"name": name, "type": kind, "link": None}
+        if shape is not None:
+            value["shape"] = shape
+        node.setdefault("inputs", []).append(value)
+        return value
+
+    def connect(self, origin: dict[str, Any], origin_slot: int,
+                target: dict[str, Any], target_slot: int,
+                kind: str) -> int:
+        target_input = target["inputs"][target_slot]
+        if target_input.get("link") is not None:
+            self.remove_link(int(target_input["link"]))
+        link_id = self.next_link
+        self.next_link += 1
+        link = [link_id, origin["id"], origin_slot,
+                target["id"], target_slot, kind]
+        self.workflow["links"].append(link)
+        self.links[link_id] = link
+        if origin["outputs"][origin_slot].get("links") is None:
+            origin["outputs"][origin_slot]["links"] = []
+        origin["outputs"][origin_slot]["links"].append(link_id)
+        target_input["link"] = link_id
+        return link_id
+
+    def remove_link(self, link_id: int) -> None:
+        link = self.links.pop(link_id, None)
+        if link is None:
+            return
+        _link_id, origin_id, origin_slot, target_id, target_slot, _kind = link
+        origin_links = self.nodes[origin_id]["outputs"][origin_slot].get(
+            "links") or []
+        self.nodes[origin_id]["outputs"][origin_slot]["links"] = [
+            item for item in origin_links if item != link_id] or None
+        self.nodes[target_id]["inputs"][target_slot]["link"] = None
+        self.workflow["links"] = [
+            item for item in self.workflow["links"] if item[0] != link_id]
+
+    def remove_input(self, node: dict[str, Any], name: str) -> None:
+        index = next((slot for slot, item in enumerate(node.get("inputs", []))
+                      if item.get("name") == name), None)
+        if index is None:
+            return
+        value = node["inputs"][index]
+        if value.get("link") is not None:
+            self.remove_link(int(value["link"]))
+        del node["inputs"][index]
+        for link in self.workflow["links"]:
+            if int(link[3]) == int(node["id"]) and int(link[4]) > index:
+                link[4] = int(link[4]) - 1
+
+    def retarget(self, link_id: int, target: dict[str, Any],
+                 target_slot: int) -> None:
+        link = self.links[link_id]
+        old_target = self.nodes[link[3]]
+        old_target["inputs"][link[4]]["link"] = None
+        link[3] = target["id"]
+        link[4] = target_slot
+        target["inputs"][target_slot]["link"] = link_id
+
+    def reorigin(self, link_id: int, origin: dict[str, Any],
+                 origin_slot: int) -> None:
+        link = self.links[link_id]
+        old_origin = self.nodes[link[1]]
+        old_links = old_origin["outputs"][link[2]].get("links") or []
+        old_origin["outputs"][link[2]]["links"] = [
+            item for item in old_links if item != link_id] or None
+        link[1] = origin["id"]
+        link[2] = origin_slot
+        if origin["outputs"][origin_slot].get("links") is None:
+            origin["outputs"][origin_slot]["links"] = []
+        origin["outputs"][origin_slot]["links"].append(link_id)
+
+    def finish(self) -> None:
+        self.workflow["last_node_id"] = max(self.nodes)
+        self.workflow["last_link_id"] = max(self.links, default=0)
+
+
+def _base_node(node_type: str, title: str, pos: list[float],
+               size: list[float]) -> dict[str, Any]:
+    return {
+        "id": 0,
+        "type": node_type,
+        "pos": pos,
+        "size": size,
+        "flags": {},
+        "order": 0,
+        "mode": 0,
+        "inputs": [],
+        "outputs": [],
+        "title": title,
+        "properties": {"Node name for S&R": node_type},
+        "widgets_values": [],
+    }
+
+
+_AUDIO_FROM_LEGACY = {
+    "source_track": ("source", "on", "off"),
+    "generated_audio": ("generated", "off", "on"),
+    "source_plus_timeline": ("source", "on", "on"),
+}
+_LEGACY_FROM_AUDIO = {value: key for key, value in _AUDIO_FROM_LEGACY.items()}
+_PRIMARY_TRANSITIONS = {
+    "cut": ("guide", 0),
+    "guide": ("guide", 22),
+    "hard_av": ("masked_av", 39),
+    "soft_av": ("audio_feathered_av", 39),
+}
+
+
+def _resolved_policy_values(plan: dict[str, Any]) -> tuple[
+                                tuple[str, str, str], str, int, int]:
+    audio = _AUDIO_FROM_LEGACY[str(plan["widgets_values"][9])]
+    context = int(plan["widgets_values"][5])
+    mode = (str(plan["widgets_values"][16])
+            if len(plan["widgets_values"]) > 16 else "guide")
+    audio_context = int(plan["widgets_values"][10])
+    return audio, mode, context, audio_context
+
+
+def _chain_policy_node(plan: dict[str, Any], audio: tuple[str, str, str],
+                       mode: str, context: int,
+                       audio_context: int) -> tuple[dict[str, Any], int]:
+    primary = next((name for name, pair in _PRIMARY_TRANSITIONS.items()
+                    if pair == (mode, context)), None)
+    x, y = plan["pos"]
+    if primary is not None and audio_context == context:
+        result = _base_node(
+            "MiniMaxH3ChainPolicy", "0.5 CHAIN POLICY",
+            [x - 420, y + 160], [340, 190])
+        result["outputs"] = [
+            {"name": "chain_policy", "type": "H3_CHAIN_POLICY", "links": []},
+            {"name": "status", "type": "STRING", "links": None},
+        ]
+        result["widgets_values"] = [primary, *audio]
+        return result, 0
+
+    legacy_mode = _LEGACY_FROM_AUDIO.get(audio)
+    if legacy_mode is None:
+        raise ValueError("Cannot preserve unsupported legacy audio policy %r." %
+                         (audio,))
+    result = _base_node(
+        "MiniMaxH3Legacy04PolicyAdapter", "0.4 LEGACY POLICY ADAPTER",
+        [x - 420, y + 160], [360, 220])
+    result["outputs"] = [
+        {"name": "chain_policy", "type": "H3_CHAIN_POLICY", "links": []},
+        {"name": "status", "type": "STRING", "links": None},
+    ]
+    result["widgets_values"] = [
+        legacy_mode, mode, int(context), int(audio_context)]
+    return result, 0
+
+
+def _preflight_node(start: dict[str, Any]) -> dict[str, Any]:
+    x, y = start["pos"]
+    result = _base_node(
+        "MiniMaxH3ChainPreflight", "0.5 PREFLIGHT — BLOCKS BEFORE MODELS",
+        [x - 448, y + 256], [384, 260])
+    result["inputs"] = [
+        {"name": "plan", "type": "H3_CHAIN_PLAN", "link": None},
+        {"name": "source_timeline", "shape": 7,
+         "type": "H3_SOURCE_TIMELINE", "link": None},
+        {"name": "source_audio", "shape": 7,
+         "type": "AUDIO", "link": None},
+        {"name": "tagged_references", "shape": 7,
+         "type": "H3_TAGGED_REFERENCES", "link": None},
+        {"name": "reference_schedule", "shape": 7,
+         "type": "H3_REFERENCE_SCHEDULE", "link": None},
+    ]
+    result["outputs"] = [
+        {"name": "plan", "type": "H3_CHAIN_PLAN", "links": []},
+        {"name": "preflight", "type": "H3_PREFLIGHT", "links": None},
+        {"name": "ready", "type": "BOOLEAN", "links": None},
+        {"name": "status", "type": "STRING", "links": None},
+        {"name": "report_json", "type": "STRING", "links": None},
+    ]
+    result["widgets_values"] = [1, "", True]
+    return result
+
+
+def _source_timeline_node(audio_loader: dict[str, Any]) -> dict[str, Any]:
+    x, y = audio_loader["pos"]
+    result = _base_node(
+        "MiniMaxH3SourceTimeline", "0.5 SOURCE TIMELINE — SELECT ONCE",
+        [x + 416, y], [352, 230])
+    result["inputs"] = [
+        {"name": "source_video", "shape": 7, "type": "VIDEO", "link": None},
+        {"name": "source_audio", "shape": 7, "type": "AUDIO", "link": None},
+    ]
+    result["outputs"] = [
+        {"name": "source_timeline", "type": "H3_SOURCE_TIMELINE", "links": []},
+        {"name": "status", "type": "STRING", "links": None},
+    ]
+    result["widgets_values"] = ["", "", "ignore", 0]
+    return result
+
+
+def _replace_text(value: Any, old: str, new: str) -> Any:
+    if isinstance(value, str):
+        return value.replace(old, new)
+    if isinstance(value, list):
+        return [_replace_text(item, old, new) for item in value]
+    if isinstance(value, dict):
+        return {key: _replace_text(item, old, new)
+                for key, item in value.items()}
+    return value
+
+
+def _reference_registry(workflow: dict[str, Any], graph: Graph
+                        ) -> tuple[dict[str, Any], int, str] | None:
+    for wrapper_type, input_name, kind in (
+        ("MiniMaxH3TaggedReferenceToVideo", "references",
+         "H3_TAGGED_REFERENCES"),
+        ("MiniMaxH3ScheduledReferenceToVideo", "reference_schedule",
+         "H3_REFERENCE_SCHEDULE"),
+    ):
+        wrapper = _node(workflow, wrapper_type)
+        if wrapper is None:
+            continue
+        value = _input(wrapper, input_name)
+        if value.get("link") is None:
+            continue
+        link = graph.links[int(value["link"])]
+        origin = graph.nodes[link[1]]
+        # Legacy timeline demos fed Current Shot's dynamic slice into Tagged
+        # Audio. Returning that registry to preflight or Plan would close an
+        # execution cycle. A current source_timeline node instead receives the
+        # static full Load Audio track and is safe to return.
+        if origin.get("type") == "MiniMaxH3TaggedAudioReference":
+            values = origin.get("widgets_values") or []
+            if len(values) < 2 or values[1] != "source_timeline":
+                return None
+            audio_input = _input(origin, "audio")
+            audio_link_id = audio_input.get("link")
+            if audio_link_id is None:
+                return None
+            audio_link = graph.links.get(int(audio_link_id))
+            if audio_link is None:
+                return None
+            audio_origin = graph.nodes[int(audio_link[1])]
+            if audio_origin.get("type") == "MiniMaxH3ChainCurrent":
+                return None
+        return origin, int(link[2]), kind
+    return None
+
+
+def _add_chain_policy(workflow: dict[str, Any], graph: Graph) -> None:
+    plan = _node(workflow, "MiniMaxH3ChainPlan")
+    assert plan is not None
+    compact_input = graph.add_input(
+        plan, "chain_policy", "H3_CHAIN_POLICY")
+    graph.remove_input(plan, "audio_policy")
+    graph.remove_input(plan, "transition_policy")
+    if compact_input.get("link") is not None:
+        return
+
+    audio, mode, context, audio_context = _resolved_policy_values(plan)
+    policy, output_slot = _chain_policy_node(
+        plan, audio, mode, context, audio_context)
+
+    policy = graph.add_node(policy)
+    graph.connect(policy, output_slot, plan,
+                  plan["inputs"].index(compact_input), "H3_CHAIN_POLICY")
+
+
+def _add_preflight(workflow: dict[str, Any], graph: Graph) -> None:
+    start = _node(workflow, "MiniMaxH3ChainLoopStart")
+    assert start is not None
+    studio = _node(workflow, "MiniMaxH3ChainPlanStudio")
+    registry = _reference_registry(workflow, graph)
+    if studio is not None:
+        for name, kind in (
+            ("source_timeline", "H3_SOURCE_TIMELINE"),
+            ("source_audio", "AUDIO"),
+            ("tagged_references", "H3_TAGGED_REFERENCES"),
+            ("reference_schedule", "H3_REFERENCE_SCHEDULE"),
+        ):
+            graph.add_input(studio, name, kind)
+        if len(studio.get("widgets_values", [])) < 3:
+            studio["widgets_values"] = [1, "", True]
+        if registry is not None:
+            origin, slot, kind = registry
+            name = ("tagged_references" if kind == "H3_TAGGED_REFERENCES"
+                    else "reference_schedule")
+            target_input = _input(studio, name)
+            if target_input.get("link") is None:
+                graph.connect(origin, slot, studio,
+                              studio["inputs"].index(target_input), kind)
+        return
+
+    if _node(workflow, "MiniMaxH3ChainPreflight") is not None:
+        return
+    preflight = graph.add_node(_preflight_node(start))
+    plan_socket = _input(start, "plan")
+    old_link = int(plan_socket["link"])
+    graph.retarget(old_link, preflight, 0)
+    graph.connect(preflight, 0, start, start["inputs"].index(plan_socket),
+                  "H3_CHAIN_PLAN")
+    if registry is not None:
+        origin, slot, kind = registry
+        target_name = ("tagged_references"
+                       if kind == "H3_TAGGED_REFERENCES"
+                       else "reference_schedule")
+        graph.connect(origin, slot, preflight,
+                      preflight["inputs"].index(_input(preflight, target_name)),
+                      kind)
+
+
+def _wire_scene_resolved_trim(
+        workflow: dict[str, Any], graph: Graph) -> None:
+    """Make Loop Trim resolve blend policy from the active scene state.
+
+    Plan's integer output is only the inherited default. Current Shot's old
+    integer output is scene-resolved, but maintaining two same-typed wires made
+    it easy to connect the default and silently lose a scene override. The 0.5
+    route carries state instead, so Loop Trim owns the one authoritative
+    resolution step.
+    """
+    current = _node(workflow, "MiniMaxH3ChainCurrent")
+    trim = _node(workflow, "MiniMaxH3LoopTrim")
+    if current is None or trim is None:
+        return
+    state_input = graph.add_input(trim, "state", "H3_CHAIN_STATE")
+    state_link_id = state_input.get("link")
+    state_link = (graph.links.get(int(state_link_id))
+                  if state_link_id is not None else None)
+    already_resolved = bool(
+        state_link is not None
+        and int(state_link[1]) == int(current["id"])
+        and int(state_link[2]) == 0)
+    if not already_resolved:
+        graph.connect(
+            current, 0, trim, trim["inputs"].index(state_input),
+            "H3_CHAIN_STATE")
+    retain = next((item for item in trim.get("inputs", [])
+                   if item.get("name") == "retain_overlap_frames"), None)
+    if retain is not None and retain.get("link") is not None:
+        graph.remove_link(int(retain["link"]))
+    trim["title"] = "TRIM CONTEXT / AUTO-RESOLVE SCENE BLEND"
+
+
+def _migrate_source_audio_demo(workflow: dict[str, Any], graph: Graph) -> None:
+    revised = _replace_text(
+        workflow,
+        "@audio_1 is the full source-track audio reference; preserve its exact "
+        "scene-local timing and performance identity.",
+        "@audio_1 is the exact current-scene source-track slice; preserve its "
+        "timing and performance identity.",
+    )
+    workflow.clear()
+    workflow.update(revised)
+    graph.workflow = workflow
+    graph.nodes = {item["id"]: item for item in workflow["nodes"]}
+    graph.links = {item[0]: item for item in workflow["links"]}
+    loader = _node(workflow, "LoadAudio")
+    audio_ref = _node(workflow, "MiniMaxH3TaggedAudioReference")
+    conditioner = _node(workflow, "MiniMaxH3TaggedReferenceToVideo")
+    current = _node(workflow, "MiniMaxH3ChainCurrent")
+    start = _node(workflow, "MiniMaxH3ChainLoopStart")
+    studio = _node(workflow, "MiniMaxH3ChainPlanStudio")
+    manifest = _node(workflow, "MiniMaxH3ChainManifestLoad")
+    plan = _node(workflow, "MiniMaxH3ChainPlan")
+    assert all(item is not None for item in (
+        loader, audio_ref, conditioner, current, start, studio, manifest,
+        plan))
+
+    timeline = _node(workflow, "MiniMaxH3SourceTimeline")
+    if timeline is None:
+        timeline = graph.add_node(_source_timeline_node(loader))
+    timeline_audio = _input(timeline, "source_audio")
+    timeline_audio_link = timeline_audio.get("link")
+    if timeline_audio_link is None:
+        graph.connect(loader, 0, timeline,
+                      timeline["inputs"].index(timeline_audio), "AUDIO")
+    else:
+        link = graph.links[int(timeline_audio_link)]
+        if int(link[1]) != int(loader["id"]) or int(link[2]) != 0:
+            graph.reorigin(int(timeline_audio_link), loader, 0)
+
+    # Replace the legacy full-track fan-out. The typed descriptor is carried
+    # in recursive state and saved metadata; Current Shot exposes only the
+    # scene-local reference window.
+    for consumer in (start, current, manifest, *[
+            item for item in workflow["nodes"]
+            if item.get("type") == "MiniMaxH3ChainAssemble"]):
+        legacy = next((item for item in consumer.get("inputs", [])
+                       if item.get("name") == "source_audio"), None)
+        if legacy is not None and legacy.get("link") is not None:
+            graph.remove_link(int(legacy["link"]))
+
+    for consumer in (start, studio, manifest):
+        timeline_input = graph.add_input(
+            consumer, "source_timeline", "H3_SOURCE_TIMELINE")
+        timeline_link_id = timeline_input.get("link")
+        timeline_link = (graph.links.get(int(timeline_link_id))
+                         if timeline_link_id is not None else None)
+        if not (timeline_link is not None
+                and int(timeline_link[1]) == int(timeline["id"])
+                and int(timeline_link[2]) == 0):
+            graph.connect(
+                timeline, 0, consumer,
+                consumer["inputs"].index(timeline_input),
+                "H3_SOURCE_TIMELINE")
+
+    # source_timeline mode deliberately receives the same static full track as
+    # Loop Start. Tagged Audio derives the current scene window internally,
+    # keeping the registry safe to fingerprint and pass to preflight.
+    audio_input = _input(audio_ref, "audio")
+    audio_link_id = audio_input.get("link")
+    if audio_link_id is None:
+        graph.connect(loader, 0, audio_ref,
+                      audio_ref["inputs"].index(audio_input), "AUDIO")
+    else:
+        audio_link = graph.links[int(audio_link_id)]
+        if (int(audio_link[1]) != int(loader["id"])
+                or int(audio_link[2]) != 0):
+            graph.reorigin(int(audio_link_id), loader, 0)
+    loader_audio_links = loader["outputs"][0].get("links") or []
+    loader["outputs"][0]["links"] = sorted(loader_audio_links) or None
+    audio_ref["widgets_values"] = ["audio_1", "source_timeline", True]
+    audio_ref["title"] = "3 — @audio_1 / FULL TRACK → CURRENT SCENE"
+    current["widgets_values"] = [True]
+
+    # The full registry is now static and can fingerprint both pictures and
+    # source audio without routing Current Shot back into Plan.
+    fingerprint_link = _input(plan, "generation_fingerprint").get("link")
+    if fingerprint_link is None:
+        graph.connect(
+            audio_ref, 1, plan,
+            plan["inputs"].index(_input(plan, "generation_fingerprint")),
+            "STRING")
+    else:
+        fingerprint = graph.links[int(fingerprint_link)]
+        if (int(fingerprint[1]) != int(audio_ref["id"])
+                or int(fingerprint[2]) != 1):
+            graph.reorigin(int(fingerprint_link), audio_ref, 1)
+
+    outputs = conditioner.setdefault("outputs", [])
+    if not any(item.get("name") == "refmod_sources" for item in outputs):
+        outputs.append({
+            "name": "refmod_sources", "type": "H3_REF_LIST", "links": None})
+    conditioner_values = conditioner.setdefault("widgets_values", [])
+    if len(conditioner_values) == 9:
+        conditioner_values.append("native_ref2va")
+
+
+def migrate(workflow: dict[str, Any], name: str) -> dict[str, Any]:
+    if _node(workflow, "MiniMaxH3ChainPlan") is not None:
+        graph = Graph(workflow)
+        _add_chain_policy(workflow, graph)
+        if name == SOURCE_AUDIO_DEMO:
+            _migrate_source_audio_demo(workflow, graph)
+        _add_preflight(workflow, graph)
+        _wire_scene_resolved_trim(workflow, graph)
+        graph.finish()
+    _prefix_custom_titles(workflow)
+    return workflow
+
+
+def active_paths() -> list[Path]:
+    # The active catalog is 0.6 and must never be fed back through this
+    # historical positional-widget migration.  Defaults now resolve only to
+    # the byte-preserved 0.5 archive; callers can still pass explicit copies.
+    return [ARCHIVE_05 / name for name in MAINTAINED_DEMOS]
+
+
+def main() -> int:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("paths", nargs="*", type=Path,
+                        help="Workflow JSON paths (defaults to archived 0.5 examples)")
+    parser.add_argument("--check", action="store_true",
+                        help="Report workflows that still need migration")
+    args = parser.parse_args()
+    paths = args.paths or active_paths()
+    changed = []
+    for path in paths:
+        source = path.read_text(encoding="utf-8")
+        workflow = migrate(json.loads(source), path.name)
+        rendered = json.dumps(workflow, ensure_ascii=False, indent=2) + "\n"
+        if rendered != source:
+            changed.append(path)
+            if not args.check:
+                path.write_text(rendered, encoding="utf-8")
+    if args.check and changed:
+        for path in changed:
+            print(path)
+        return 1
+    print(("would migrate" if args.check else "migrated"),
+          len(changed), "workflow(s)")
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/README.md b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..d6182c9c3ae1209015871799ef6c0322f530532f
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/README.md
@@ -0,0 +1,74 @@
+# Building the 0.6 workflow catalog
+
+`recipes/` is the source of truth. Each recipe names its node settings and
+connections; it contains no UI widget arrays, node dimensions, link-slot numbers,
+or frontend metadata. Existing example prompts and intended connections were
+reviewed as reference material. The old archive-based builder is no longer used.
+The files under `example_workflows/Archive/` are never read or modified by this
+builder.
+
+From this checkout, run:
+
+```sh
+python3 tools/build_v06_workflows.py
+python3 tools/build_v06_workflows.py --check
+python3 tests/_workflow_schema_unit_test.py
+python3 tests/_workflow_catalog_unit_test.py
+```
+
+The builder imports this branch's H3 `INPUT_TYPES` / output definitions in an
+offline schema environment. Run it in its own Python process, not inside a
+running ComfyUI server. The normal package dependencies, including torch, must
+be available; no model weights or GPU inference are used.
+
+`external_schemas.json` contains only dependency contracts, with provenance and
+installation-specific file inventories removed. It is not a snapshot of nightly
+H3 nodes. Update these external contracts deliberately when changing the
+documented dependency requirements; do not import an entire server inventory.
+
+## Serialization rules
+
+- Name every widget explicitly. A new/missing field fails the build until its
+  recipe has been reviewed.
+- Connected widgets still occupy their normal position in `widgets_values`.
+  They also need the input's `widget.name` metadata.
+- Seed controls include `control_after_generate` in frontend order.
+- V3 dynamic combos include their selected child settings; autogrow reference
+  sockets are generated from named connections.
+- VHS uses named widget serialization. Preview state and uploaded-file browser
+  metadata are not embedded.
+- Studio's connected Plan values initialize its mirror consistently.
+
+Tests cover widget types, enums and ranges, required inputs, converted-widget
+metadata, bidirectional links, output slots, Studio plan wiring, title-inclusive
+node bounds, group containment, preserved assets, and deterministic generation.
+The reported two-slot Tagged Ref2VA shift is an explicit negative regression test.
+
+## Layout and release checks
+
+Project controls precede numbered dependency columns. Titles are short enough
+not to force automatic width expansion. Stacks reserve body height, the 30-pixel
+title bar and a 70-pixel gap. DOM editors and image/video previews get explicit
+space. Recovery is isolated and disabled; detailed Notes become companion guides.
+
+The September 5 audit opened all 18 files in an isolated ComfyUI 1.51.9 frontend
+with this 0.6 branch's schemas and JavaScript (plus VHS), and checked serialized
+API prompts. All project writes and queue requests were blocked. This checks
+loading, settings and wiring, not numerical model output or GPU memory use.
+Before release, also test representative real renders with installed models and
+assets, particularly the optional external upscale packs.
+
+The September 5–6 local execution pass completed all 15 non-upscale workflows
+with bounded smoke settings (two steps, reduced canvas and loop-scene lengths).
+The seven corrected workflows were rerun and their final audio/video streams and
+expected checkpoints verified. The unavailable Ref2VA model was substituted with
+FL2VA for these execution tests, and a compatible installed H3 text encoder was
+used. This does not replace full-resolution or genuine Ref2VA quality testing.
+
+Maintained media examples now use core Load Video/native VIDEO paths. In the
+tested frontend, VHS could reinterpret named widget values as its old positional
+layout, silently changing frame caps and frame selection; its lazy audio mapping
+also failed strict AUDIO-dictionary consumers. Check that serialized API values
+equal the recipe values, not merely that they satisfy a type/range schema.
+The native bridge preserves the 114-frame gap and uses a 311-frame H3-safe source
+span, dropping only the former demo's final two frames.
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/external_schemas.json b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/external_schemas.json
new file mode 100644
index 0000000000000000000000000000000000000000..3b09e6e4babeaedf19f36d6e12606840484dccfe
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/external_schemas.json
@@ -0,0 +1,3059 @@
+{
+  "provenance": {
+    "date": "2026-09-05",
+    "core": "ComfyUI 0.34.0 / object_info (machine inventories removed)",
+    "MAINodes": "https://github.com/matlowai/ComfyUI-MAINodes/blob/main/motion.py",
+    "SeedVR2": "https://github.com/ethanfel/ComfyUI-SeedVR2_VideoUpscaler/blob/main/src/interfaces/direct_video_upscaler.py",
+    "LBH": "https://github.com/LBH-123-AI/Comfyui_Minimax_h3_latent_Upscaler",
+    "USDU_H3": "https://github.com/lisitskyaa/ComfyUI_UltimateSDUpscaleGuider_H3/blob/main/usdu_nodes.py (2026-09-06; anchor_context BOOLEAN)",
+    "DLSS5": "https://github.com/Blueforcer/ComfyUI-DLSS5-Enhancer/tree/main/nodes (2026-09-06)",
+    "note": "External-only offline contracts; H3 Context Loop contracts are imported from this checkout, never from a server."
+  },
+  "nodes": {
+    "LoraLoaderModelOnly": {
+      "input": {"required": {
+        "model": ["MODEL", {}],
+        "lora_name": [["minimax_h3_turbo_v4_step600_ema_pruned_comfyui.safetensors"], {}],
+        "strength_model": ["FLOAT", {"default": 1.0, "min": -100.0, "max": 100.0, "step": 0.01}]
+      }},
+      "output": ["MODEL"], "output_name": ["MODEL"], "output_is_list": [false]
+    },
+    "DLSS5Settings": {
+      "input": {
+        "required": {
+          "upscaling_mode": [
+            [
+              "1x (DLAA / native)",
+              "1.5x (Quality)",
+              "1.724x (Balanced)",
+              "2x (Performance)",
+              "3x (Ultra Performance)"
+            ],
+            {
+              "default": "1x (DLAA / native)"
+            }
+          ],
+          "nr_preset": [
+            [
+              "Default",
+              "Preset #1",
+              "Preset #2",
+              "Preset #3"
+            ],
+            {
+              "default": "Default"
+            }
+          ],
+          "nr_style": [
+            [
+              "Default",
+              "Natural",
+              "Cinematic"
+            ],
+            {
+              "default": "Default"
+            }
+          ],
+          "nr_intensity": [
+            "FLOAT",
+            {
+              "default": 1,
+              "min": 0,
+              "max": 2,
+              "step": 0.01
+            }
+          ],
+          "local_tone_strength": [
+            "FLOAT",
+            {
+              "default": 1,
+              "min": 0,
+              "max": 2,
+              "step": 0.01
+            }
+          ],
+          "local_structure_strength": [
+            "FLOAT",
+            {
+              "default": 1.5,
+              "min": 0,
+              "max": 2,
+              "step": 0.01
+            }
+          ],
+          "skin_structure_strength": [
+            "FLOAT",
+            {
+              "default": 2,
+              "min": -1,
+              "max": 2,
+              "step": 0.01
+            }
+          ],
+          "automatic_mask": [
+            "BOOLEAN",
+            {
+              "default": true
+            }
+          ],
+          "dlss_model_preset": [
+            [
+              "Default",
+              "J",
+              "K",
+              "L",
+              "M"
+            ],
+            {
+              "default": "M"
+            }
+          ],
+          "motion": [
+            [
+              "auto",
+              "optical_flow",
+              "none"
+            ],
+            {
+              "default": "auto"
+            }
+          ],
+          "scene_change_threshold": [
+            "FLOAT",
+            {
+              "default": 0.24,
+              "min": 0.01,
+              "max": 1,
+              "step": 0.01
+            }
+          ],
+          "warmup_frames": [
+            "INT",
+            {
+              "default": 0,
+              "min": 0,
+              "max": 16,
+              "step": 1
+            }
+          ],
+          "runtime_dir": [
+            "STRING",
+            {
+              "default": ""
+            }
+          ]
+        }
+      },
+      "output": [
+        "DLSS5_SETTINGS"
+      ],
+      "output_name": [
+        "settings"
+      ],
+      "output_is_list": [
+        false
+      ]
+    },
+    "DLSS5EnhanceImages": {
+      "input": {
+        "required": {
+          "images": [
+            "IMAGE",
+            {}
+          ],
+          "settings": [
+            "DLSS5_SETTINGS",
+            {}
+          ],
+          "verify_neural_rendering": [
+            "BOOLEAN",
+            {
+              "default": true
+            }
+          ]
+        }
+      },
+      "output": [
+        "IMAGE"
+      ],
+      "output_name": [
+        "images"
+      ],
+      "output_is_list": [
+        false
+      ]
+    },
+    "UltimateSDUpscaleNoUpscaleGuider": {
+      "input": {
+        "required": {
+          "upscaled_image": [
+            "IMAGE",
+            {}
+          ],
+          "guider": [
+            "GUIDER",
+            {}
+          ],
+          "sampler": [
+            "SAMPLER",
+            {}
+          ],
+          "sigmas": [
+            "SIGMAS",
+            {}
+          ],
+          "vae": [
+            "VAE",
+            {}
+          ],
+          "seed": [
+            "INT",
+            {
+              "default": 0,
+              "min": 0,
+              "max": 18446744073709551615
+            }
+          ],
+          "mode_type": [
+            [
+              "Linear",
+              "Chess",
+              "None"
+            ],
+            {}
+          ],
+          "tile_width": [
+            "INT",
+            {
+              "default": 512,
+              "min": 64,
+              "max": 8192,
+              "step": 8
+            }
+          ],
+          "tile_height": [
+            "INT",
+            {
+              "default": 512,
+              "min": 64,
+              "max": 8192,
+              "step": 8
+            }
+          ],
+          "mask_blur": [
+            "INT",
+            {
+              "default": 8,
+              "min": 0,
+              "max": 64,
+              "step": 1
+            }
+          ],
+          "tile_padding": [
+            "INT",
+            {
+              "default": 32,
+              "min": 0,
+              "max": 8192,
+              "step": 8
+            }
+          ],
+          "seam_fix_mode": [
+            [
+              "None",
+              "Band Pass",
+              "Half Tile",
+              "Half Tile + Intersections"
+            ],
+            {}
+          ],
+          "seam_fix_denoise": [
+            "FLOAT",
+            {
+              "default": 1,
+              "min": 0,
+              "max": 1,
+              "step": 0.01
+            }
+          ],
+          "seam_fix_width": [
+            "INT",
+            {
+              "default": 64,
+              "min": 0,
+              "max": 8192,
+              "step": 8
+            }
+          ],
+          "seam_fix_mask_blur": [
+            "INT",
+            {
+              "default": 8,
+              "min": 0,
+              "max": 64,
+              "step": 1
+            }
+          ],
+          "seam_fix_padding": [
+            "INT",
+            {
+              "default": 16,
+              "min": 0,
+              "max": 8192,
+              "step": 8
+            }
+          ],
+          "tile_overlap_mode": [
+            [
+              "Ignore Overlap",
+              "Reprocess Overlap",
+              "Context Only Overlap"
+            ],
+            {
+              "default": "Reprocess Overlap"
+            }
+          ],
+          "tiled_decode": [
+            "BOOLEAN",
+            {
+              "default": false
+            }
+          ],
+          "batch_size": [
+            "INT",
+            {
+              "default": 1,
+              "min": 1,
+              "max": 4096,
+              "step": 1
+            }
+          ]
+        },
+        "optional": {
+          "mask": [
+            "MASK",
+            {}
+          ],
+          "anchor_context": [
+            "BOOLEAN",
+            {
+              "default": false
+            }
+          ]
+        }
+      },
+      "output": [
+        "IMAGE"
+      ],
+      "output_name": [
+        "IMAGE"
+      ],
+      "output_is_list": [
+        false
+      ]
+    },
+    "GetVideoComponents": {
+      "input": {"required": {"video": ["VIDEO", {}]}},
+      "output": ["IMAGE", "AUDIO", "FLOAT", "COMBO", "COMBO"],
+      "output_is_list": [false, false, false, false, false],
+      "output_name": ["images", "audio", "fps", "bit_depth", "color_space"]
+    },
+    "Video Slice": {
+      "input": {"required": {
+        "video": ["VIDEO", {}],
+        "start_time": ["FLOAT", {"default": 0.0, "min": -100000.0, "max": 100000.0, "step": 0.001}],
+        "duration": ["FLOAT", {"default": 0.0, "min": 0.0, "step": 0.001}],
+        "strict_duration": ["BOOLEAN", {"default": false}]
+      }},
+      "output": ["VIDEO"],
+      "output_is_list": [false],
+      "output_name": ["VIDEO"]
+    },
+    "ImageScale": {
+      "input": {"required": {
+        "image": ["IMAGE"],
+        "upscale_method": [["nearest-exact", "bilinear", "area", "bicubic", "lanczos"]],
+        "width": ["INT", {"default": 512, "min": 0, "max": 16384, "step": 1}],
+        "height": ["INT", {"default": 512, "min": 0, "max": 16384, "step": 1}],
+        "crop": [["disabled", "center"]]
+      }},
+      "output": ["IMAGE"],
+      "output_is_list": [false],
+      "output_name": ["IMAGE"]
+    },
+    "AudioConcat": {
+      "input": {
+        "required": {
+          "audio1": [
+            "AUDIO",
+            {}
+          ],
+          "audio2": [
+            "AUDIO",
+            {}
+          ],
+          "direction": [
+            "COMBO",
+            {
+              "default": "after",
+              "multiselect": false,
+              "options": [
+                "after",
+                "before"
+              ]
+            }
+          ]
+        }
+      },
+      "output": [
+        "AUDIO"
+      ],
+      "output_is_list": [
+        false
+      ],
+      "output_name": [
+        "AUDIO"
+      ]
+    },
+    "BasicGuider": {
+      "input": {
+        "required": {
+          "model": [
+            "MODEL",
+            {}
+          ],
+          "conditioning": [
+            "CONDITIONING",
+            {}
+          ]
+        }
+      },
+      "output": [
+        "GUIDER"
+      ],
+      "output_is_list": [
+        false
+      ],
+      "output_name": [
+        "GUIDER"
+      ]
+    },
+    "BasicScheduler": {
+      "input": {
+        "required": {
+          "model": [
+            "MODEL",
+            {}
+          ],
+          "scheduler": [
+            "COMBO",
+            {
+              "multiselect": false,
+              "options": [
+                "simple",
+                "sgm_uniform",
+                "karras",
+                "exponential",
+                "ddim_uniform",
+                "beta",
+                "normal",
+                "linear_quadratic",
+                "kl_optimal",
+                "bong_tangent",
+                "beta57"
+              ]
+            }
+          ],
+          "steps": [
+            "INT",
+            {
+              "default": 20,
+              "min": 1,
+              "max": 10000
+            }
+          ],
+          "denoise": [
+            "FLOAT",
+            {
+              "default": 1.0,
+              "min": 0.0,
+              "max": 1.0,
+              "step": 0.01
+            }
+          ]
+        }
+      },
+      "output": [
+        "SIGMAS"
+      ],
+      "output_is_list": [
+        false
+      ],
+      "output_name": [
+        "SIGMAS"
+      ]
+    },
+    "CLIPLoader": {
+      "input": {
+        "required": {
+          "clip_name": [
+            [
+              "qwen3vl_32b_minimax_h3_int8_convrot.safetensors"
+            ]
+          ],
+          "type": [
+            [
+              "stable_diffusion",
+              "stable_cascade",
+              "sd3",
+              "stable_audio",
+              "mochi",
+              "ltxv",
+              "pixart",
+              "cosmos",
+              "lumina2",
+              "wan",
+              "hidream",
+              "chroma",
+              "ace",
+              "omnigen2",
+              "qwen_image",
+              "hunyuan_image",
+              "flux2",
+              "ovis",
+              "longcat_image",
+              "cogvideox",
+              "lens",
+              "pixeldit",
+              "ideogram4",
+              "boogu",
+              "krea2",
+              "joyimage",
+              "mage",
+              "minimax"
+            ]
+          ]
+        },
+        "optional": {
+          "device": [
+            [
+              "default",
+              "cpu"
+            ],
+            {}
+          ]
+        }
+      },
+      "output": [
+        "CLIP"
+      ],
+      "output_is_list": [
+        false
+      ],
+      "output_name": [
+        "CLIP"
+      ]
+    },
+    "CreateVideo": {
+      "input": {
+        "required": {
+          "images": [
+            "IMAGE",
+            {}
+          ],
+          "fps": [
+            "FLOAT",
+            {
+              "default": 30.0,
+              "min": 1.0,
+              "max": 120.0,
+              "step": 1.0
+            }
+          ]
+        },
+        "optional": {
+          "audio": [
+            "AUDIO",
+            {}
+          ],
+          "bit_depth": [
+            "COMBO",
+            {
+              "default": "auto",
+              "multiselect": false,
+              "options": [
+                "auto",
+                8,
+                10
+              ]
+            }
+          ],
+          "color_space": [
+            "COMBO",
+            {
+              "default": "sRGB",
+              "multiselect": false,
+              "options": [
+                "sRGB",
+                "HDR",
+                "HDR PQ"
+              ]
+            }
+          ]
+        }
+      },
+      "output": [
+        "VIDEO"
+      ],
+      "output_is_list": [
+        false
+      ],
+      "output_name": [
+        "VIDEO"
+      ]
+    },
+    "DisableNoise": {
+      "input": {
+        "required": {}
+      },
+      "output": [
+        "NOISE"
+      ],
+      "output_is_list": [
+        false
+      ],
+      "output_name": [
+        "NOISE"
+      ]
+    },
+    "ImageBatchExtendWithOverlap": {
+      "input": {
+        "required": {
+          "source_images": [
+            "IMAGE",
+            {}
+          ],
+          "overlap": [
+            "INT",
+            {
+              "default": 13,
+              "min": 1,
+              "max": 4096,
+              "step": 1
+            }
+          ],
+          "overlap_side": [
+            [
+              "source",
+              "new_images"
+            ],
+            {
+              "default": "source"
+            }
+          ],
+          "overlap_mode": [
+            [
+              "cut",
+              "linear_blend",
+              "ease_in_out",
+              "filmic_crossfade",
+              "perceptual_crossfade"
+            ],
+            {
+              "default": "linear_blend"
+            }
+          ]
+        },
+        "optional": {
+          "new_images": [
+            "IMAGE",
+            {}
+          ]
+        }
+      },
+      "output": [
+        "IMAGE",
+        "IMAGE",
+        "IMAGE"
+      ],
+      "output_is_list": [
+        false,
+        false,
+        false
+      ],
+      "output_name": [
+        "source_images",
+        "start_images",
+        "extended_images"
+      ]
+    },
+    "KSamplerSelect": {
+      "input": {
+        "required": {
+          "sampler_name": [
+            "COMBO",
+            {
+              "multiselect": false,
+              "options": [
+                "euler",
+                "euler_cfg_pp",
+                "euler_ancestral",
+                "euler_ancestral_cfg_pp",
+                "heun",
+                "heunpp2",
+                "exp_heun_2_x0",
+                "exp_heun_2_x0_sde",
+                "dpm_2",
+                "dpm_2_ancestral",
+                "lms",
+                "dpm_fast",
+                "dpm_adaptive",
+                "dpmpp_2s_ancestral",
+                "dpmpp_2s_ancestral_cfg_pp",
+                "dpmpp_sde",
+                "dpmpp_sde_gpu",
+                "dpmpp_2m",
+                "dpmpp_2m_cfg_pp",
+                "dpmpp_2m_sde",
+                "dpmpp_2m_sde_gpu",
+                "dpmpp_2m_sde_heun",
+                "dpmpp_2m_sde_heun_gpu",
+                "dpmpp_3m_sde",
+                "dpmpp_3m_sde_gpu",
+                "ddpm",
+                "lcm",
+                "ipndm",
+                "ipndm_v",
+                "deis",
+                "cfgpp_ud10_ab",
+                "res_multistep",
+                "res_multistep_cfg_pp",
+                "res_multistep_ancestral",
+                "res_multistep_ancestral_cfg_pp",
+                "gradient_estimation",
+                "gradient_estimation_cfg_pp",
+                "er_sde",
+                "seeds_2",
+                "seeds_3",
+                "sa_solver",
+                "sa_solver_pece",
+                "ddim",
+                "uni_pc",
+                "uni_pc_bh2",
+                "legacy_rk",
+                "rk",
+                "rk_beta",
+                "deis_3m_ode",
+                "deis_2m_ode",
+                "deis_3m",
+                "deis_2m",
+                "res_6s_ode",
+                "res_5s_ode",
+                "res_3s_ode",
+                "res_2s_ode",
+                "res_3m_ode",
+                "res_2m_ode",
+                "res_6s",
+                "res_5s",
+                "res_3s",
+                "res_2s",
+                "res_3m",
+                "res_2m"
+              ]
+            }
+          ]
+        }
+      },
+      "output": [
+        "SAMPLER"
+      ],
+      "output_is_list": [
+        false
+      ],
+      "output_name": [
+        "SAMPLER"
+      ]
+    },
+    "LoadImage": {
+      "input": {
+        "required": {
+          "image": [
+            [
+              "h3_v06_courier_greenhouse_arrival.png",
+              "h3_v06_courier_greenhouse_delivery.png",
+              "soldier_crabs_reference_cc0.png"
+            ],
+            {}
+          ]
+        }
+      },
+      "output": [
+        "IMAGE",
+        "MASK"
+      ],
+      "output_is_list": [
+        false,
+        false
+      ],
+      "output_name": [
+        "IMAGE",
+        "MASK"
+      ]
+    },
+    "LoadImageMask": {
+      "input": {
+        "required": {
+          "image": [
+            [
+              "soldier_crabs_inpaint_mask.png"
+            ],
+            {}
+          ],
+          "channel": [
+            [
+              "alpha",
+              "red",
+              "green",
+              "blue"
+            ]
+          ]
+        }
+      },
+      "output": [
+        "MASK"
+      ],
+      "output_is_list": [
+        false
+      ],
+      "output_name": [
+        "MASK"
+      ]
+    },
+    "LoadVideo": {
+      "input": {
+        "required": {
+          "file": [
+            [
+              "SELECT_LONG_MOTION_REFERENCE_WITH_AUDIO.mp4",
+              "soldier_crabs_bribie_island_cc0.webm"
+            ],
+            {
+              "multiselect": false
+            }
+          ]
+        }
+      },
+      "output": [
+        "VIDEO"
+      ],
+      "output_is_list": [
+        false
+      ],
+      "output_name": [
+        "VIDEO"
+      ]
+    },
+    "MiniMaxH3ImageToVideo": {
+      "input": {
+        "required": {
+          "clip": [
+            "CLIP",
+            {}
+          ],
+          "vae": [
+            "VAE",
+            {}
+          ],
+          "prompt": [
+            "STRING",
+            {
+              "multiline": true,
+              "dynamicPrompts": true
+            }
+          ],
+          "width": [
+            "INT",
+            {
+              "default": 1344,
+              "min": 32,
+              "max": 16384,
+              "step": 32
+            }
+          ],
+          "height": [
+            "INT",
+            {
+              "default": 768,
+              "min": 32,
+              "max": 16384,
+              "step": 32
+            }
+          ],
+          "length": [
+            "INT",
+            {
+              "default": 124,
+              "min": 5,
+              "max": 3600,
+              "step": 17
+            }
+          ]
+        },
+        "optional": {
+          "first_frame": [
+            "IMAGE",
+            {}
+          ],
+          "last_frame": [
+            "IMAGE",
+            {}
+          ]
+        }
+      },
+      "output": [
+        "CONDITIONING",
+        "LATENT"
+      ],
+      "output_is_list": [
+        false,
+        false
+      ],
+      "output_name": [
+        "positive",
+        "LATENT"
+      ]
+    },
+    "MiniMaxH3ReferenceToVideo": {
+      "input": {
+        "required": {
+          "clip": [
+            "CLIP",
+            {}
+          ],
+          "vae": [
+            "VAE",
+            {}
+          ],
+          "audio_vae": [
+            "VAE",
+            {}
+          ],
+          "prompt": [
+            "STRING",
+            {
+              "multiline": true,
+              "dynamicPrompts": true
+            }
+          ],
+          "width": [
+            "INT",
+            {
+              "default": 1344,
+              "min": 32,
+              "max": 16384,
+              "step": 32
+            }
+          ],
+          "height": [
+            "INT",
+            {
+              "default": 768,
+              "min": 32,
+              "max": 16384,
+              "step": 32
+            }
+          ],
+          "length": [
+            "INT",
+            {
+              "default": 124,
+              "min": 5,
+              "max": 3600,
+              "step": 17
+            }
+          ],
+          "ref_image_size": [
+            "COMBO",
+            {
+              "default": "match",
+              "multiselect": false,
+              "options": [
+                "match",
+                "max"
+              ]
+            }
+          ]
+        },
+        "optional": {
+          "ref_images": [
+            "COMFY_AUTOGROW_V3",
+            {
+              "template": {
+                "input": {
+                  "required": {
+                    "ref_image": [
+                      "IMAGE",
+                      {}
+                    ]
+                  }
+                },
+                "prefix": "ref_image_",
+                "min": 0,
+                "max": 9
+              }
+            }
+          ],
+          "ref_videos": [
+            "COMFY_AUTOGROW_V3",
+            {
+              "template": {
+                "input": {
+                  "required": {
+                    "ref_video": [
+                      "IMAGE",
+                      {}
+                    ]
+                  }
+                },
+                "prefix": "ref_video_",
+                "min": 0,
+                "max": 3
+              }
+            }
+          ],
+          "ref_video_audios": [
+            "COMFY_AUTOGROW_V3",
+            {
+              "template": {
+                "input": {
+                  "required": {
+                    "ref_video_audio": [
+                      "AUDIO",
+                      {}
+                    ]
+                  }
+                },
+                "prefix": "ref_video_audio_",
+                "min": 0,
+                "max": 3
+              }
+            }
+          ],
+          "ref_audios": [
+            "COMFY_AUTOGROW_V3",
+            {
+              "template": {
+                "input": {
+                  "required": {
+                    "ref_audio": [
+                      "AUDIO",
+                      {}
+                    ]
+                  }
+                },
+                "prefix": "ref_audio_",
+                "min": 0,
+                "max": 3
+              }
+            }
+          ]
+        }
+      },
+      "output": [
+        "CONDITIONING",
+        "LATENT"
+      ],
+      "output_is_list": [
+        false,
+        false
+      ],
+      "output_name": [
+        "positive",
+        "LATENT"
+      ]
+    },
+    "MiniMaxH3SigmaShift": {
+      "input": {
+        "required": {
+          "model": [
+            "MODEL",
+            {}
+          ],
+          "shift_video": [
+            "FLOAT",
+            {
+              "default": 12.0,
+              "min": 0.01,
+              "max": 100.0,
+              "step": 0.01
+            }
+          ],
+          "shift_audio": [
+            "FLOAT",
+            {
+              "default": 3.0,
+              "min": 0.01,
+              "max": 100.0,
+              "step": 0.01
+            }
+          ]
+        }
+      },
+      "output": [
+        "MODEL"
+      ],
+      "output_is_list": [
+        false
+      ],
+      "output_name": [
+        "MODEL"
+      ]
+    },
+    "MinimaxH3LatentUpscaler3D": {
+      "input": {
+        "required": {
+          "latent": [
+            "*",
+            {}
+          ],
+          "model_name": [
+            [
+              "minimax_h3_latent_upscaler_3d_fp16.safetensors"
+            ],
+            {
+              "multiselect": false
+            }
+          ],
+          "mode": [
+            "COMFY_DYNAMICCOMBO_V3",
+            {
+              "options": [
+                {
+                  "key": "scale by multiplier",
+                  "inputs": {
+                    "required": {
+                      "scale": [
+                        "FLOAT",
+                        {
+                          "default": 2.0,
+                          "min": 1.0,
+                          "max": 4.0,
+                          "step": 0.05
+                        }
+                      ]
+                    }
+                  }
+                },
+                {
+                  "key": "target dimensions",
+                  "inputs": {
+                    "required": {
+                      "width": [
+                        "INT",
+                        {
+                          "default": 1280,
+                          "min": 64,
+                          "max": 8192,
+                          "step": 8
+                        }
+                      ],
+                      "height": [
+                        "INT",
+                        {
+                          "default": 704,
+                          "min": 64,
+                          "max": 8192,
+                          "step": 8
+                        }
+                      ]
+                    }
+                  }
+                },
+                {
+                  "key": "megapixels",
+                  "inputs": {
+                    "required": {
+                      "megapixels": [
+                        "FLOAT",
+                        {
+                          "default": 1.0,
+                          "min": 0.1,
+                          "max": 16.0,
+                          "step": 0.1
+                        }
+                      ]
+                    }
+                  }
+                }
+              ]
+            }
+          ],
+          "align": [
+            "INT",
+            {
+              "default": 32,
+              "min": 1,
+              "max": 512,
+              "step": 1
+            }
+          ],
+          "enable_temporal_chunking": [
+            "BOOLEAN",
+            {
+              "default": true
+            }
+          ],
+          "force_unload": [
+            "BOOLEAN",
+            {
+              "default": true
+            }
+          ],
+          "device": [
+            "COMBO",
+            {
+              "default": "cuda",
+              "multiselect": false,
+              "options": [
+                "cuda",
+                "rocm",
+                "cpu"
+              ]
+            }
+          ],
+          "precision": [
+            "COMBO",
+            {
+              "default": "fp16",
+              "multiselect": false,
+              "options": [
+                "fp32",
+                "fp16",
+                "bf16"
+              ]
+            }
+          ]
+        }
+      },
+      "output": [
+        "*"
+      ],
+      "output_is_list": [
+        false
+      ],
+      "output_name": [
+        "latent"
+      ]
+    },
+    "ModelAttentionBackend": {
+      "input": {
+        "required": {
+          "model": [
+            "MODEL"
+          ],
+          "attention": [
+            [
+              "pytorch attention",
+              "comfy kitchen attention"
+            ]
+          ]
+        }
+      },
+      "output": [
+        "MODEL"
+      ],
+      "output_is_list": [
+        false
+      ],
+      "output_name": [
+        "MODEL"
+      ]
+    },
+    "PreviewAny": {
+      "input": {
+        "required": {
+          "source": [
+            "*",
+            {}
+          ]
+        }
+      },
+      "output": [
+        "STRING"
+      ],
+      "output_is_list": [
+        false
+      ],
+      "output_name": [
+        "STRING"
+      ]
+    },
+    "PreviewImage": {
+      "input": {
+        "required": {
+          "images": [
+            "IMAGE"
+          ]
+        },
+        "hidden": {
+          "prompt": "PROMPT",
+          "extra_pnginfo": "EXTRA_PNGINFO"
+        }
+      },
+      "output": [
+        "IMAGE"
+      ],
+      "output_is_list": [
+        false
+      ],
+      "output_name": [
+        "images"
+      ]
+    },
+    "RandomNoise": {
+      "input": {
+        "required": {
+          "noise_seed": [
+            "INT",
+            {
+              "default": 0,
+              "min": 0,
+              "max": 18446744073709551615,
+              "control_after_generate": true
+            }
+          ]
+        }
+      },
+      "output": [
+        "NOISE"
+      ],
+      "output_is_list": [
+        false
+      ],
+      "output_name": [
+        "NOISE"
+      ]
+    },
+    "SamplerCustomAdvanced": {
+      "input": {
+        "required": {
+          "noise": [
+            "NOISE",
+            {}
+          ],
+          "guider": [
+            "GUIDER",
+            {}
+          ],
+          "sampler": [
+            "SAMPLER",
+            {}
+          ],
+          "sigmas": [
+            "SIGMAS",
+            {}
+          ],
+          "latent_image": [
+            "LATENT",
+            {}
+          ]
+        }
+      },
+      "output": [
+        "LATENT",
+        "LATENT"
+      ],
+      "output_is_list": [
+        false,
+        false
+      ],
+      "output_name": [
+        "output",
+        "denoised_output"
+      ]
+    },
+    "SaveVideo": {
+      "input": {
+        "required": {
+          "video": [
+            "VIDEO",
+            {}
+          ],
+          "filename_prefix": [
+            "STRING",
+            {
+              "default": "video/ComfyUI",
+              "multiline": false
+            }
+          ],
+          "format": [
+            "COMFY_DYNAMICCOMBO_V3",
+            {
+              "options": [
+                {
+                  "key": "auto",
+                  "inputs": {
+                    "required": {
+                      "codec": [
+                        "COMFY_DYNAMICCOMBO_V3",
+                        {
+                          "options": [
+                            {
+                              "key": "auto",
+                              "inputs": {
+                                "required": {}
+                              }
+                            },
+                            {
+                              "key": "h264",
+                              "inputs": {
+                                "required": {},
+                                "optional": {
+                                  "encoding": [
+                                    "COMFY_DYNAMICCOMBO_V3",
+                                    {
+                                      "display_name": "encoding mode",
+                                      "options": [
+                                        {
+                                          "key": "auto",
+                                          "inputs": {
+                                            "required": {}
+                                          }
+                                        },
+                                        {
+                                          "key": "re-encode",
+                                          "inputs": {
+                                            "required": {
+                                              "crf": [
+                                                "FLOAT",
+                                                {
+                                                  "default": 23.0,
+                                                  "min": 0.0,
+                                                  "max": 51.0,
+                                                  "step": 1.0
+                                                }
+                                              ]
+                                            }
+                                          }
+                                        }
+                                      ]
+                                    }
+                                  ]
+                                }
+                              }
+                            },
+                            {
+                              "key": "av1",
+                              "inputs": {
+                                "required": {},
+                                "optional": {
+                                  "encoding": [
+                                    "COMFY_DYNAMICCOMBO_V3",
+                                    {
+                                      "display_name": "encoding mode",
+                                      "options": [
+                                        {
+                                          "key": "auto",
+                                          "inputs": {
+                                            "required": {}
+                                          }
+                                        },
+                                        {
+                                          "key": "re-encode",
+                                          "inputs": {
+                                            "required": {
+                                              "crf": [
+                                                "FLOAT",
+                                                {
+                                                  "default": 30.0,
+                                                  "min": 0.0,
+                                                  "max": 63.0,
+                                                  "step": 1.0
+                                                }
+                                              ]
+                                            }
+                                          }
+                                        }
+                                      ]
+                                    }
+                                  ]
+                                }
+                              }
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  }
+                },
+                {
+                  "key": "mp4",
+                  "inputs": {
+                    "required": {
+                      "codec": [
+                        "COMFY_DYNAMICCOMBO_V3",
+                        {
+                          "options": [
+                            {
+                              "key": "auto",
+                              "inputs": {
+                                "required": {}
+                              }
+                            },
+                            {
+                              "key": "h264",
+                              "inputs": {
+                                "required": {},
+                                "optional": {
+                                  "encoding": [
+                                    "COMFY_DYNAMICCOMBO_V3",
+                                    {
+                                      "display_name": "encoding mode",
+                                      "options": [
+                                        {
+                                          "key": "auto",
+                                          "inputs": {
+                                            "required": {}
+                                          }
+                                        },
+                                        {
+                                          "key": "re-encode",
+                                          "inputs": {
+                                            "required": {
+                                              "crf": [
+                                                "FLOAT",
+                                                {
+                                                  "default": 23.0,
+                                                  "min": 0.0,
+                                                  "max": 51.0,
+                                                  "step": 1.0
+                                                }
+                                              ]
+                                            }
+                                          }
+                                        }
+                                      ]
+                                    }
+                                  ]
+                                }
+                              }
+                            },
+                            {
+                              "key": "av1",
+                              "inputs": {
+                                "required": {},
+                                "optional": {
+                                  "encoding": [
+                                    "COMFY_DYNAMICCOMBO_V3",
+                                    {
+                                      "display_name": "encoding mode",
+                                      "options": [
+                                        {
+                                          "key": "auto",
+                                          "inputs": {
+                                            "required": {}
+                                          }
+                                        },
+                                        {
+                                          "key": "re-encode",
+                                          "inputs": {
+                                            "required": {
+                                              "crf": [
+                                                "FLOAT",
+                                                {
+                                                  "default": 30.0,
+                                                  "min": 0.0,
+                                                  "max": 63.0,
+                                                  "step": 1.0
+                                                }
+                                              ]
+                                            }
+                                          }
+                                        }
+                                      ]
+                                    }
+                                  ]
+                                }
+                              }
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  }
+                },
+                {
+                  "key": "mkv",
+                  "inputs": {
+                    "required": {
+                      "codec": [
+                        "COMFY_DYNAMICCOMBO_V3",
+                        {
+                          "options": [
+                            {
+                              "key": "auto",
+                              "inputs": {
+                                "required": {}
+                              }
+                            },
+                            {
+                              "key": "h264",
+                              "inputs": {
+                                "required": {},
+                                "optional": {
+                                  "encoding": [
+                                    "COMFY_DYNAMICCOMBO_V3",
+                                    {
+                                      "display_name": "encoding mode",
+                                      "options": [
+                                        {
+                                          "key": "auto",
+                                          "inputs": {
+                                            "required": {}
+                                          }
+                                        },
+                                        {
+                                          "key": "re-encode",
+                                          "inputs": {
+                                            "required": {
+                                              "crf": [
+                                                "FLOAT",
+                                                {
+                                                  "default": 23.0,
+                                                  "min": 0.0,
+                                                  "max": 51.0,
+                                                  "step": 1.0
+                                                }
+                                              ]
+                                            }
+                                          }
+                                        }
+                                      ]
+                                    }
+                                  ]
+                                }
+                              }
+                            },
+                            {
+                              "key": "av1",
+                              "inputs": {
+                                "required": {},
+                                "optional": {
+                                  "encoding": [
+                                    "COMFY_DYNAMICCOMBO_V3",
+                                    {
+                                      "display_name": "encoding mode",
+                                      "options": [
+                                        {
+                                          "key": "auto",
+                                          "inputs": {
+                                            "required": {}
+                                          }
+                                        },
+                                        {
+                                          "key": "re-encode",
+                                          "inputs": {
+                                            "required": {
+                                              "crf": [
+                                                "FLOAT",
+                                                {
+                                                  "default": 30.0,
+                                                  "min": 0.0,
+                                                  "max": 63.0,
+                                                  "step": 1.0
+                                                }
+                                              ]
+                                            }
+                                          }
+                                        }
+                                      ]
+                                    }
+                                  ]
+                                }
+                              }
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  }
+                },
+                {
+                  "key": "webm",
+                  "inputs": {
+                    "required": {
+                      "codec": [
+                        "COMFY_DYNAMICCOMBO_V3",
+                        {
+                          "options": [
+                            {
+                              "key": "auto",
+                              "inputs": {
+                                "required": {}
+                              }
+                            },
+                            {
+                              "key": "av1",
+                              "inputs": {
+                                "required": {},
+                                "optional": {
+                                  "encoding": [
+                                    "COMFY_DYNAMICCOMBO_V3",
+                                    {
+                                      "display_name": "encoding mode",
+                                      "options": [
+                                        {
+                                          "key": "auto",
+                                          "inputs": {
+                                            "required": {}
+                                          }
+                                        },
+                                        {
+                                          "key": "re-encode",
+                                          "inputs": {
+                                            "required": {
+                                              "crf": [
+                                                "FLOAT",
+                                                {
+                                                  "default": 30.0,
+                                                  "min": 0.0,
+                                                  "max": 63.0,
+                                                  "step": 1.0
+                                                }
+                                              ]
+                                            }
+                                          }
+                                        }
+                                      ]
+                                    }
+                                  ]
+                                }
+                              }
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "optional": {
+          "codec": [
+            "COMFY_DYNAMICCOMBO_V3",
+            {
+              "hidden": true,
+              "options": [
+                {
+                  "key": "auto",
+                  "inputs": {
+                    "required": {}
+                  }
+                },
+                {
+                  "key": "h264",
+                  "inputs": {
+                    "required": {},
+                    "optional": {
+                      "encoding": [
+                        "COMFY_DYNAMICCOMBO_V3",
+                        {
+                          "display_name": "encoding mode",
+                          "options": [
+                            {
+                              "key": "auto",
+                              "inputs": {
+                                "required": {}
+                              }
+                            },
+                            {
+                              "key": "re-encode",
+                              "inputs": {
+                                "required": {
+                                  "crf": [
+                                    "FLOAT",
+                                    {
+                                      "default": 23.0,
+                                      "min": 0.0,
+                                      "max": 51.0,
+                                      "step": 1.0
+                                    }
+                                  ]
+                                }
+                              }
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  }
+                },
+                {
+                  "key": "av1",
+                  "inputs": {
+                    "required": {},
+                    "optional": {
+                      "encoding": [
+                        "COMFY_DYNAMICCOMBO_V3",
+                        {
+                          "display_name": "encoding mode",
+                          "options": [
+                            {
+                              "key": "auto",
+                              "inputs": {
+                                "required": {}
+                              }
+                            },
+                            {
+                              "key": "re-encode",
+                              "inputs": {
+                                "required": {
+                                  "crf": [
+                                    "FLOAT",
+                                    {
+                                      "default": 30.0,
+                                      "min": 0.0,
+                                      "max": 63.0,
+                                      "step": 1.0
+                                    }
+                                  ]
+                                }
+                              }
+                            }
+                          ]
+                        }
+                      ]
+                    }
+                  }
+                }
+              ]
+            }
+          ]
+        },
+        "hidden": {
+          "prompt": [
+            "PROMPT"
+          ],
+          "extra_pnginfo": [
+            "EXTRA_PNGINFO"
+          ]
+        }
+      },
+      "output": [
+        "VIDEO"
+      ],
+      "output_is_list": [
+        false
+      ],
+      "output_name": [
+        "video"
+      ]
+    },
+    "SeedVR2LoadDiTModel": {
+      "input": {
+        "required": {
+          "model": [
+            "COMBO",
+            {
+              "default": "seedvr2_ema_3b_fp8_e4m3fn.safetensors",
+              "multiselect": false,
+              "options": [
+                "seedvr2_ema_3b-Q4_K_M.gguf",
+                "seedvr2_ema_3b-Q8_0.gguf",
+                "seedvr2_ema_3b_fp8_e4m3fn.safetensors",
+                "seedvr2_ema_3b_fp16.safetensors",
+                "seedvr2_ema_7b-Q4_K_M.gguf",
+                "seedvr2_ema_7b_fp8_e4m3fn_mixed_block35_fp16.safetensors",
+                "seedvr2_ema_7b_fp16.safetensors",
+                "seedvr2_ema_7b_sharp-Q4_K_M.gguf",
+                "seedvr2_ema_7b_sharp_fp8_e4m3fn_mixed_block35_fp16.safetensors",
+                "seedvr2_ema_7b_sharp_fp16.safetensors"
+              ]
+            }
+          ],
+          "device": [
+            "COMBO",
+            {
+              "default": "cuda:0",
+              "multiselect": false,
+              "options": [
+                "cuda:0"
+              ]
+            }
+          ]
+        },
+        "optional": {
+          "blocks_to_swap": [
+            "INT",
+            {
+              "default": 0,
+              "min": 0,
+              "max": 36,
+              "step": 1
+            }
+          ],
+          "swap_io_components": [
+            "BOOLEAN",
+            {
+              "default": false
+            }
+          ],
+          "offload_device": [
+            "COMBO",
+            {
+              "default": "none",
+              "multiselect": false,
+              "options": [
+                "none",
+                "cpu",
+                "cuda:0"
+              ]
+            }
+          ],
+          "cache_model": [
+            "BOOLEAN",
+            {
+              "default": false
+            }
+          ],
+          "attention_mode": [
+            "COMBO",
+            {
+              "default": "sdpa",
+              "multiselect": false,
+              "options": [
+                "sdpa",
+                "flash_attn_2",
+                "flash_attn_3",
+                "sageattn_2",
+                "sageattn_3"
+              ]
+            }
+          ],
+          "torch_compile_args": [
+            "TORCH_COMPILE_ARGS",
+            {}
+          ]
+        }
+      },
+      "output": [
+        "SEEDVR2_DIT"
+      ],
+      "output_is_list": [
+        false
+      ],
+      "output_name": [
+        "SEEDVR2_DIT"
+      ]
+    },
+    "SeedVR2LoadVAEModel": {
+      "input": {
+        "required": {
+          "model": [
+            "COMBO",
+            {
+              "default": "ema_vae_fp16.safetensors",
+              "multiselect": false,
+              "options": [
+                "ema_vae_fp16.safetensors"
+              ]
+            }
+          ],
+          "device": [
+            "COMBO",
+            {
+              "default": "cuda:0",
+              "multiselect": false,
+              "options": [
+                "cuda:0"
+              ]
+            }
+          ]
+        },
+        "optional": {
+          "encode_tiled": [
+            "BOOLEAN",
+            {
+              "default": false
+            }
+          ],
+          "encode_tile_size": [
+            "INT",
+            {
+              "default": 1024,
+              "min": 64,
+              "step": 32
+            }
+          ],
+          "encode_tile_overlap": [
+            "INT",
+            {
+              "default": 128,
+              "min": 0,
+              "step": 32
+            }
+          ],
+          "decode_tiled": [
+            "BOOLEAN",
+            {
+              "default": false
+            }
+          ],
+          "decode_tile_size": [
+            "INT",
+            {
+              "default": 1024,
+              "min": 64,
+              "step": 32
+            }
+          ],
+          "decode_tile_overlap": [
+            "INT",
+            {
+              "default": 128,
+              "min": 0,
+              "step": 32
+            }
+          ],
+          "tile_debug": [
+            "COMBO",
+            {
+              "default": "false",
+              "multiselect": false,
+              "options": [
+                "false",
+                "encode",
+                "decode"
+              ]
+            }
+          ],
+          "offload_device": [
+            "COMBO",
+            {
+              "default": "none",
+              "multiselect": false,
+              "options": [
+                "none",
+                "cpu",
+                "cuda:0"
+              ]
+            }
+          ],
+          "cache_model": [
+            "BOOLEAN",
+            {
+              "default": false
+            }
+          ],
+          "torch_compile_args": [
+            "TORCH_COMPILE_ARGS",
+            {}
+          ]
+        }
+      },
+      "output": [
+        "SEEDVR2_VAE"
+      ],
+      "output_is_list": [
+        false
+      ],
+      "output_name": [
+        "SEEDVR2_VAE"
+      ]
+    },
+    "TrimAudioDuration": {
+      "input": {
+        "required": {
+          "audio": [
+            "AUDIO",
+            {}
+          ],
+          "start_index": [
+            "FLOAT",
+            {
+              "default": 0.0,
+              "min": -18446744073709551615,
+              "max": 18446744073709551615,
+              "step": 0.01
+            }
+          ],
+          "duration": [
+            "FLOAT",
+            {
+              "default": 60.0,
+              "min": 0.0,
+              "step": 0.01
+            }
+          ]
+        }
+      },
+      "output": [
+        "AUDIO"
+      ],
+      "output_is_list": [
+        false
+      ],
+      "output_name": [
+        "AUDIO"
+      ]
+    },
+    "UNETLoader": {
+      "input": {
+        "required": {
+          "unet_name": [
+            [
+              "minimax_h3_fl2va_pruned_int8_convrot.safetensors",
+              "minimax_h3_ref2va_pruned_int8_convrot.safetensors"
+            ]
+          ],
+          "weight_dtype": [
+            [
+              "default",
+              "fp8_e4m3fn",
+              "fp8_e4m3fn_fast",
+              "fp8_e5m2"
+            ],
+            {}
+          ]
+        }
+      },
+      "output": [
+        "MODEL"
+      ],
+      "output_is_list": [
+        false
+      ],
+      "output_name": [
+        "MODEL"
+      ]
+    },
+    "VAEDecode": {
+      "input": {
+        "required": {
+          "samples": [
+            "LATENT",
+            {}
+          ],
+          "vae": [
+            "VAE",
+            {}
+          ]
+        }
+      },
+      "output": [
+        "IMAGE"
+      ],
+      "output_is_list": [
+        false
+      ],
+      "output_name": [
+        "IMAGE"
+      ]
+    },
+    "VAEDecodeAudio": {
+      "input": {
+        "required": {
+          "samples": [
+            "LATENT",
+            {}
+          ],
+          "vae": [
+            "VAE",
+            {}
+          ]
+        }
+      },
+      "output": [
+        "AUDIO"
+      ],
+      "output_is_list": [
+        false
+      ],
+      "output_name": [
+        "AUDIO"
+      ]
+    },
+    "VAEEncode": {
+      "input": {
+        "required": {
+          "pixels": [
+            "IMAGE"
+          ],
+          "vae": [
+            "VAE"
+          ]
+        }
+      },
+      "output": [
+        "LATENT"
+      ],
+      "output_is_list": [
+        false
+      ],
+      "output_name": [
+        "LATENT"
+      ]
+    },
+    "VAEEncodeAudio": {
+      "input": {
+        "required": {
+          "audio": [
+            "AUDIO",
+            {}
+          ],
+          "vae": [
+            "VAE",
+            {}
+          ]
+        }
+      },
+      "output": [
+        "LATENT"
+      ],
+      "output_is_list": [
+        false
+      ],
+      "output_name": [
+        "LATENT"
+      ]
+    },
+    "VAELoader": {
+      "input": {
+        "required": {
+          "vae_name": [
+            [
+              "minimax_h3_audio_vae_fp32.safetensors",
+              "minimax_h3_video_vae_fp16.safetensors"
+            ]
+          ]
+        }
+      },
+      "output": [
+        "VAE"
+      ],
+      "output_is_list": [
+        false
+      ],
+      "output_name": [
+        "VAE"
+      ]
+    },
+    "VHS_LoadVideo": {
+      "input": {
+        "required": {
+          "video": [
+            [
+              "soldier_crabs_bribie_island_cc0.webm"
+            ]
+          ],
+          "force_rate": [
+            "FLOAT",
+            {
+              "default": 0,
+              "min": 0,
+              "max": 60,
+              "step": 1,
+              "disable": 0
+            }
+          ],
+          "custom_width": [
+            "INT",
+            {
+              "default": 0,
+              "min": 0,
+              "max": 8192,
+              "disable": 0
+            }
+          ],
+          "custom_height": [
+            "INT",
+            {
+              "default": 0,
+              "min": 0,
+              "max": 8192,
+              "disable": 0
+            }
+          ],
+          "frame_load_cap": [
+            "INT",
+            {
+              "default": 0,
+              "min": 0,
+              "max": 9007199254740991,
+              "step": 1,
+              "disable": 0
+            }
+          ],
+          "skip_first_frames": [
+            "INT",
+            {
+              "default": 0,
+              "min": 0,
+              "max": 9007199254740991,
+              "step": 1
+            }
+          ],
+          "select_every_nth": [
+            "INT",
+            {
+              "default": 1,
+              "min": 1,
+              "max": 9007199254740991,
+              "step": 1
+            }
+          ]
+        },
+        "optional": {
+          "meta_batch": [
+            "VHS_BatchManager"
+          ],
+          "vae": [
+            "VAE"
+          ],
+          "format": [
+            [
+              "None",
+              "AnimateDiff",
+              "Mochi",
+              "LTXV",
+              "Hunyuan",
+              "Cosmos",
+              "Wan",
+              "H3"
+            ],
+            {
+              "default": "AnimateDiff"
+            }
+          ]
+        },
+        "hidden": {
+          "force_size": "STRING",
+          "unique_id": "UNIQUE_ID"
+        }
+      },
+      "output": [
+        "IMAGE",
+        "INT",
+        "AUDIO",
+        "VHS_VIDEOINFO"
+      ],
+      "output_is_list": [
+        false,
+        false,
+        false,
+        false
+      ],
+      "output_name": [
+        "IMAGE",
+        "frame_count",
+        "audio",
+        "video_info"
+      ]
+    },
+    "H3AudioRecover": {
+      "input": {
+        "required": {
+          "audio": [
+            "AUDIO"
+          ],
+          "hold_map": [
+            "STRING",
+            {
+              "default": ""
+            }
+          ],
+          "fps": [
+            "INT",
+            {
+              "default": 24,
+              "min": 1,
+              "max": 120
+            }
+          ]
+        },
+        "optional": {
+          "reference": [
+            "AUDIO",
+            {}
+          ],
+          "reference_mix": [
+            "FLOAT",
+            {
+              "default": 1.0,
+              "min": 0.0,
+              "max": 1.0,
+              "step": 0.05
+            }
+          ],
+          "audio_source": [
+            [
+              "custom (use reference_mix)",
+              "keep the original performance (safe default)",
+              "use pass 2's foley - ONLY IF the audio rows were seeded",
+              "blend, favour the original",
+              "blend, favour pass 2"
+            ],
+            {
+              "default": "custom (use reference_mix)"
+            }
+          ]
+        }
+      },
+      "output": [
+        "AUDIO"
+      ],
+      "output_name": [
+        "AUDIO"
+      ],
+      "output_is_list": [
+        false
+      ]
+    },
+    "H3AudioSmear": {
+      "input": {
+        "required": {
+          "audio": [
+            "AUDIO",
+            {}
+          ],
+          "hold_map": [
+            "STRING",
+            {
+              "default": ""
+            }
+          ],
+          "fps": [
+            "INT",
+            {
+              "default": 24,
+              "min": 1,
+              "max": 120
+            }
+          ]
+        }
+      },
+      "output": [
+        "AUDIO"
+      ],
+      "output_name": [
+        "AUDIO"
+      ],
+      "output_is_list": [
+        false
+      ]
+    },
+    "H3ExactRecover": {
+      "input": {
+        "required": {
+          "images": [
+            "IMAGE"
+          ],
+          "hold_map": [
+            "STRING",
+            {
+              "default": ""
+            }
+          ]
+        }
+      },
+      "output": [
+        "IMAGE"
+      ],
+      "output_name": [
+        "IMAGE"
+      ],
+      "output_is_list": [
+        false
+      ]
+    },
+    "H3InjectSchedule": {
+      "input": {
+        "required": {
+          "model": [
+            "MODEL"
+          ],
+          "scheduler": [
+            [
+              "simple",
+              "normal",
+              "beta",
+              "sgm_uniform",
+              "karras",
+              "exponential"
+            ],
+            {
+              "default": "simple"
+            }
+          ],
+          "total_steps": [
+            "INT",
+            {
+              "default": 25,
+              "min": 4,
+              "max": 100
+            }
+          ],
+          "inject": [
+            "FLOAT",
+            {
+              "default": 0.7,
+              "min": 0.05,
+              "max": 1.0,
+              "step": 0.05
+            }
+          ]
+        },
+        "optional": {
+          "preset": [
+            [
+              "custom",
+              "balanced 0.70 (default)",
+              "faithful detail 0.50 (metric best)",
+              "loose / creative 0.80"
+            ],
+            {
+              "default": "balanced 0.70 (default)"
+            }
+          ]
+        }
+      },
+      "output": [
+        "SIGMAS"
+      ],
+      "output_name": [
+        "SIGMAS"
+      ],
+      "output_is_list": [
+        false
+      ]
+    },
+    "H3JerkOracle": {
+      "input": {
+        "required": {
+          "samples": [
+            "LATENT"
+          ],
+          "length": [
+            "INT",
+            {
+              "default": 124,
+              "min": 5,
+              "max": 3600,
+              "step": 17
+            }
+          ],
+          "q": [
+            "FLOAT",
+            {
+              "default": 0.75,
+              "min": 0.5,
+              "max": 0.99,
+              "step": 0.01
+            }
+          ],
+          "d_max": [
+            "INT",
+            {
+              "default": 4,
+              "min": 2,
+              "max": 8
+            }
+          ],
+          "ramp": [
+            "BOOLEAN",
+            {
+              "default": true
+            }
+          ]
+        },
+        "optional": {
+          "preset": [
+            [
+              "custom",
+              "balanced (default)",
+              "max quality (wide plateau)",
+              "economy (tight spans)"
+            ],
+            {
+              "default": "balanced (default)"
+            }
+          ],
+          "bridge": [
+            "INT",
+            {
+              "default": 8,
+              "min": 0,
+              "max": 20
+            }
+          ],
+          "profile_mode": [
+            [
+              "value |d3| (default)",
+              "value |d1| (energy baseline)",
+              "trajectory centroid |d3|",
+              "value |d3| camera-compensated"
+            ],
+            {
+              "default": "value |d3| (default)"
+            }
+          ],
+          "abstain_below": [
+            "FLOAT",
+            {
+              "default": 0.0,
+              "min": 0.0,
+              "max": 10.0,
+              "step": 0.1
+            }
+          ],
+          "fps": [
+            "INT",
+            {
+              "default": 24,
+              "min": 1,
+              "max": 120
+            }
+          ],
+          "s_per_step": [
+            "FLOAT",
+            {
+              "default": 0.0,
+              "min": 0.0,
+              "max": 120.0,
+              "step": 0.05
+            }
+          ],
+          "est_steps": [
+            "INT",
+            {
+              "default": 18,
+              "min": 1,
+              "max": 100
+            }
+          ],
+          "overhead_s": [
+            "FLOAT",
+            {
+              "default": 6.7,
+              "min": 0.0,
+              "max": 600.0,
+              "step": 0.1
+            }
+          ],
+          "model_profile": [
+            [
+              "minimax-h3"
+            ],
+            {
+              "default": "minimax-h3"
+            }
+          ],
+          "protect_tail": [
+            "INT",
+            {
+              "default": 0,
+              "min": 0,
+              "max": 96
+            }
+          ]
+        }
+      },
+      "output": [
+        "STRING",
+        "STRING",
+        "INT",
+        "INT",
+        "STRING",
+        "STRING"
+      ],
+      "output_name": [
+        "hold_map",
+        "segments",
+        "window_start",
+        "window_len",
+        "profile",
+        "report"
+      ],
+      "output_is_list": [
+        false,
+        false,
+        false,
+        false,
+        false,
+        false
+      ]
+    },
+    "H3TimeSmear": {
+      "input": {
+        "required": {
+          "images": [
+            "IMAGE"
+          ],
+          "dilation": [
+            "INT",
+            {
+              "default": 4,
+              "min": 1,
+              "max": 8
+            }
+          ]
+        },
+        "optional": {
+          "hold_map": [
+            "STRING",
+            {
+              "default": ""
+            }
+          ],
+          "expand_to_end": [
+            "BOOLEAN",
+            {
+              "default": true
+            }
+          ],
+          "fps": [
+            "INT",
+            {
+              "default": 24,
+              "min": 1,
+              "max": 120
+            }
+          ],
+          "s_per_step": [
+            "FLOAT",
+            {
+              "default": 0.0,
+              "min": 0.0,
+              "max": 120.0,
+              "step": 0.05
+            }
+          ],
+          "est_steps": [
+            "INT",
+            {
+              "default": 18,
+              "min": 1,
+              "max": 100
+            }
+          ],
+          "overhead_s": [
+            "FLOAT",
+            {
+              "default": 6.7,
+              "min": 0.0,
+              "max": 600.0,
+              "step": 0.1
+            }
+          ]
+        }
+      },
+      "output": [
+        "IMAGE",
+        "STRING",
+        "INT",
+        "STRING"
+      ],
+      "output_name": [
+        "images",
+        "hold_map_used",
+        "length",
+        "report"
+      ],
+      "output_is_list": [
+        false,
+        false,
+        false,
+        false
+      ]
+    },
+    "H3V2VInit": {
+      "input": {
+        "required": {
+          "samples": [
+            "LATENT",
+            {}
+          ]
+        },
+        "optional": {
+          "length": [
+            "INT",
+            {
+              "default": 0,
+              "min": 0,
+              "max": 3600
+            }
+          ],
+          "oracle_samples": [
+            "LATENT",
+            {}
+          ],
+          "freeze_threshold": [
+            "FLOAT",
+            {
+              "default": 0.0,
+              "min": 0.0,
+              "max": 1.0,
+              "step": 0.05
+            }
+          ],
+          "freeze_grow": [
+            "INT",
+            {
+              "default": 2,
+              "min": 0,
+              "max": 16
+            }
+          ],
+          "mask": [
+            "MASK",
+            {}
+          ],
+          "mask_feather": [
+            "INT",
+            {
+              "default": 0,
+              "min": 0,
+              "max": 256
+            }
+          ],
+          "invert_mask": [
+            "BOOLEAN",
+            {
+              "default": false
+            }
+          ],
+          "time_varying": [
+            "BOOLEAN",
+            {
+              "default": false
+            }
+          ],
+          "audio_latent": [
+            "LATENT",
+            {}
+          ],
+          "audio_mode": [
+            [
+              "custom (use audio_strength)",
+              "invent freely (original behaviour)",
+              "follow the original performance (0.5)",
+              "follow loosely, re-render more (0.7)",
+              "pin the original outright (0.0)"
+            ],
+            {
+              "default": "custom (use audio_strength)"
+            }
+          ],
+          "audio_strength": [
+            "FLOAT",
+            {
+              "default": 1.0,
+              "min": 0.0,
+              "max": 1.0,
+              "step": 0.05
+            }
+          ],
+          "audio_prefix_ticks": [
+            "INT",
+            {
+              "default": 0,
+              "min": 0,
+              "max": 36000
+            }
+          ],
+          "audio_prefix_release_ticks": [
+            "INT",
+            {
+              "default": 0,
+              "min": 0,
+              "max": 400
+            }
+          ]
+        }
+      },
+      "output": [
+        "LATENT"
+      ],
+      "output_name": [
+        "LATENT"
+      ],
+      "output_is_list": [
+        false
+      ]
+    },
+    "SeedVR2VideoPathUpscaler": {
+      "input": {
+        "required": {
+          "video": [
+            "VIDEO",
+            {}
+          ],
+          "dit": [
+            "SEEDVR2_DIT",
+            {}
+          ],
+          "vae": [
+            "SEEDVR2_VAE",
+            {}
+          ],
+          "seed": [
+            "INT",
+            {
+              "default": 42,
+              "min": 0,
+              "max": 4294967295,
+              "step": 1
+            }
+          ],
+          "resolution": [
+            "INT",
+            {
+              "default": 1080,
+              "min": 16,
+              "max": 16384,
+              "step": 2
+            }
+          ],
+          "max_resolution": [
+            "INT",
+            {
+              "default": 0,
+              "min": 0,
+              "max": 16384,
+              "step": 2
+            }
+          ],
+          "batch_size": [
+            "INT",
+            {
+              "default": 5,
+              "min": 1,
+              "max": 16384,
+              "step": 4
+            }
+          ],
+          "chunk_size": [
+            "INT",
+            {
+              "default": 21,
+              "min": 0,
+              "max": 4096,
+              "step": 1
+            }
+          ],
+          "color_correction": [
+            "COMBO",
+            {
+              "options": [
+                "lab",
+                "wavelet",
+                "wavelet_adaptive",
+                "hsv",
+                "adain",
+                "none"
+              ],
+              "default": "lab"
+            }
+          ]
+        },
+        "optional": {
+          "chunk_overlap": [
+            "INT",
+            {
+              "default": 2,
+              "min": 0,
+              "max": 32,
+              "step": 1
+            }
+          ],
+          "uniform_batch_size": [
+            "BOOLEAN",
+            {
+              "default": false
+            }
+          ],
+          "temporal_overlap": [
+            "INT",
+            {
+              "default": 0,
+              "min": 0,
+              "max": 16,
+              "step": 1
+            }
+          ],
+          "prepend_frames": [
+            "INT",
+            {
+              "default": 0,
+              "min": 0,
+              "max": 32,
+              "step": 1
+            }
+          ],
+          "input_noise_scale": [
+            "FLOAT",
+            {
+              "default": 0.0,
+              "min": 0.0,
+              "max": 1.0,
+              "step": 0.001
+            }
+          ],
+          "latent_noise_scale": [
+            "FLOAT",
+            {
+              "default": 0.0,
+              "min": 0.0,
+              "max": 1.0,
+              "step": 0.001
+            }
+          ],
+          "offload_device": [
+            "COMBO",
+            {
+              "options": [
+                "cpu",
+                "cuda:0",
+                "none"
+              ],
+              "default": "cpu"
+            }
+          ],
+          "temporary_video_crf": [
+            "INT",
+            {
+              "default": 18,
+              "min": 0,
+              "max": 51,
+              "step": 1
+            }
+          ],
+          "enable_debug": [
+            "BOOLEAN",
+            {
+              "default": false
+            }
+          ],
+          "auto_settings": [
+            "SEEDVR2_AUTO_SETTINGS",
+            {}
+          ]
+        }
+      },
+      "output": [
+        "VIDEO",
+        "AUDIO"
+      ],
+      "output_name": [
+        "video",
+        "audio"
+      ],
+      "output_is_list": [
+        false,
+        false
+      ]
+    }
+  }
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Deferred Upscale + De-Rope - H3 LBH 3D - MiniMax H3 0.6.json b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Deferred Upscale + De-Rope - H3 LBH 3D - MiniMax H3 0.6.json
new file mode 100644
index 0000000000000000000000000000000000000000..27a927ed40fd3d29926d5374f3bc05ec0ee52b41
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Deferred Upscale + De-Rope - H3 LBH 3D - MiniMax H3 0.6.json	
@@ -0,0 +1,699 @@
+{
+  "nodes": [
+    {
+      "key": "n1",
+      "type": "MiniMaxH3ChainCheckpointManager",
+      "settings": {
+        "selection_json": ""
+      },
+      "inputs": {}
+    },
+    {
+      "key": "n2",
+      "type": "MiniMaxH3ChainUpscaleAdapter",
+      "settings": {
+        "profile": "h3_lbh_3d_derope",
+        "backend": "h3_latent",
+        "recipe_json": "{\"upscaler\":\"LBH 3D\",\"target_megapixels\":1.5,\"derope\":\"MAINodes adaptive pixel smear\",\"oracle\":\"balanced q0.75 dmax4\",\"pass2_steps\":8,\"inject\":0.5,\"audio_init\":0.5,\"audio_output\":\"original performance\"}",
+        "start_clip": 1,
+        "end_clip": 0,
+        "save_latent": true,
+        "segment_crf": 18
+      },
+      "inputs": {
+        "source_manifest": [
+          "n1",
+          "selected_manifest"
+        ]
+      }
+    },
+    {
+      "key": "n3",
+      "type": "MiniMaxH3ChainUpscaleCurrent",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n2",
+          "state"
+        ]
+      }
+    },
+    {
+      "key": "n4",
+      "type": "UNETLoader",
+      "settings": {
+        "unet_name": "minimax_h3_fl2va_pruned_int8_convrot.safetensors",
+        "weight_dtype": "default"
+      },
+      "inputs": {}
+    },
+    {
+      "key": "n5",
+      "type": "ModelAttentionBackend",
+      "settings": {
+        "attention": "pytorch attention"
+      },
+      "inputs": {
+        "model": [
+          "n4",
+          "MODEL"
+        ]
+      },
+      "mode": 4
+    },
+    {
+      "key": "n6",
+      "type": "MiniMaxH3SigmaShift",
+      "settings": {
+        "shift_video": 12,
+        "shift_audio": 3
+      },
+      "inputs": {
+        "model": [
+          "n5",
+          "MODEL"
+        ]
+      }
+    },
+    {
+      "key": "n7",
+      "type": "CLIPLoader",
+      "settings": {
+        "clip_name": "qwen3vl_32b_minimax_h3_int8_convrot.safetensors",
+        "type": "minimax",
+        "device": "default"
+      },
+      "inputs": {}
+    },
+    {
+      "key": "n8",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_video_vae_fp16.safetensors"
+      },
+      "inputs": {}
+    },
+    {
+      "key": "n9",
+      "type": "MiniMaxH3ChainUpscaleReferenceConditioning",
+      "settings": {
+        "missing_cache": "text_only",
+        "motion_ref_mode": "exclude_video_keep_audio",
+        "prompt_override": "",
+        "override_ref_image_size": "inherit",
+        "override_reference_policy": "strict"
+      },
+      "inputs": {
+        "state": [
+          "n3",
+          "state"
+        ],
+        "clip": [
+          "n7",
+          "CLIP"
+        ],
+        "target_video_latent": [
+          "n32",
+          "video_latent"
+        ],
+        "video_vae": [
+          "n8",
+          "VAE"
+        ],
+        "prompt_override": [
+          "n22",
+          "prompt_override"
+        ],
+        "tagged_references": [
+          "n22",
+          "references"
+        ],
+        "audio_vae": [
+          "n23",
+          "VAE"
+        ]
+      }
+    },
+    {
+      "key": "n10",
+      "type": "RandomNoise",
+      "settings": {
+        "noise_seed": 0,
+        "control_after_generate": "fixed"
+      },
+      "inputs": {
+        "noise_seed": [
+          "n3",
+          "seed"
+        ]
+      }
+    },
+    {
+      "key": "n11",
+      "type": "MinimaxH3LatentUpscaler3D",
+      "settings": {
+        "model_name": "minimax_h3_latent_upscaler_3d_fp16.safetensors",
+        "mode": "megapixels",
+        "mode.megapixels": 1.5,
+        "align": 32,
+        "enable_temporal_chunking": true,
+        "force_unload": true,
+        "device": "cuda",
+        "precision": "fp16"
+      },
+      "inputs": {
+        "latent": [
+          "n29",
+          "LATENT"
+        ]
+      }
+    },
+    {
+      "key": "n12",
+      "type": "BasicGuider",
+      "settings": {},
+      "inputs": {
+        "model": [
+          "n6",
+          "MODEL"
+        ],
+        "conditioning": [
+          "n21",
+          "positive"
+        ]
+      }
+    },
+    {
+      "key": "n13",
+      "type": "KSamplerSelect",
+      "settings": {
+        "sampler_name": "res_multistep"
+      },
+      "inputs": {}
+    },
+    {
+      "key": "n14",
+      "type": "SamplerCustomAdvanced",
+      "settings": {},
+      "inputs": {
+        "noise": [
+          "n10",
+          "NOISE"
+        ],
+        "guider": [
+          "n12",
+          "GUIDER"
+        ],
+        "sampler": [
+          "n13",
+          "SAMPLER"
+        ],
+        "sigmas": [
+          "n35",
+          "SIGMAS"
+        ],
+        "latent_image": [
+          "n34",
+          "LATENT"
+        ]
+      }
+    },
+    {
+      "key": "n15",
+      "type": "VAEDecode",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n14",
+          "output"
+        ],
+        "vae": [
+          "n8",
+          "VAE"
+        ]
+      }
+    },
+    {
+      "key": "n16",
+      "type": "MiniMaxH3ChainUpscaleSegmentSave",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n3",
+          "state"
+        ],
+        "images": [
+          "n37",
+          "IMAGE"
+        ],
+        "upscaled_latent": [
+          "n41",
+          "latent"
+        ],
+        "recovered_audio": [
+          "n38",
+          "AUDIO"
+        ]
+      }
+    },
+    {
+      "key": "n17",
+      "type": "MiniMaxH3ChainUpscaleLoopEnd",
+      "settings": {},
+      "inputs": {
+        "flow": [
+          "n2",
+          "flow"
+        ],
+        "state": [
+          "n3",
+          "state"
+        ],
+        "images": [
+          "n37",
+          "IMAGE"
+        ],
+        "segment": [
+          "n16",
+          "segment"
+        ],
+        "upscaled_latent": [
+          "n41",
+          "latent"
+        ]
+      }
+    },
+    {
+      "key": "n18",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "h3_upscaled_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n17",
+          "manifest"
+        ]
+      }
+    },
+    {
+      "key": "n19",
+      "type": "Note",
+      "settings": {
+        "text": "CHAIN-AWARE H3 UPSCALE + DE-ROPE\n\n1. Select the generated branch tip in Checkpoint Manager. Partial generated branches are valid.\n2. Keep a unique profile name. Each recovered HQ scene is saved before the loop advances.\n3. H3 Jerk Oracle finds overloaded motion on the saved clean source latent. Chain De-Rope Guard prevents it from retiming the disposable continuation prefix and the last 17 frames of every non-final selected scene. Its expand_to_end output must stay connected to H3 Time Smear.\n4. Time Smear expands decoded source frames; VAE Encode returns them to clean H3 latent space; LBH 3D performs the spatial upscale. Chain De-Rope Continuity then splices the previous HQ Drift-Control tail at target resolution.\n5. Chain De-Rope Freeze Mask must stay connected to H3 V2V Init with time_varying ON. The stretched source audio is seeded at strength 0.5 so dialogue timing does not drag the mouth back to natural speed.\n6. Exact Recover and Audio Recover return to the original RAW clock. The bundled safe audio default keeps the original performance; change Audio Recover only for an intentional pass-2 foley test. Recovered AV is re-encoded for Drift-Control continuity and optional latent saving.\n\nNo Plan, Source Timeline, source media, or manual references are required. Automatic reference-cache restore remains active and excludes motion-video refs by default because the source latent already contains the motion. Functional nodes intentionally use their original registered names."
+      },
+      "inputs": {},
+      "label": "HOW TO RUN"
+    },
+    {
+      "key": "n20",
+      "type": "Note",
+      "settings": {
+        "text": "REQUIRES\nhttps://github.com/LBH-123-AI/Comfyui_Minimax_h3_latent_Upscaler\nhttps://github.com/matlowai/ComfyUI-MAINodes\n\nThis uses MAINodes' stable decoded pixel-smear path, not experimental latent temporal insertion. The longer smeared IMAGE batch lives on CPU, then VAE Encode and LBH operate scene by scene; effective time can still reach roughly 2-3x on high-motion clips. If RAM or generation time is excessive, process a smaller start/end scene range or use a less aggressive oracle preset before lowering target resolution.\n\nDefaults: balanced oracle q=0.75 / d_max=4 / ramp ON / bridge=8; 1.5 MP LBH 3D; 20-step simple schedule injected from 0.50; res_multistep sampler; audio init follows the original performance at 0.5; Audio Recover delivers the original performance. Community testing consistently places d_max=4 at the useful H3 threshold and recommends doing spatial upscale and de-rope in this same regeneration pass.\n\nH3 Conditioning Sync now permits the longer target clock while resizing only spatial reference/keyframe latents. Motion refs remain excluded by default. The pass-2 Comfy Kitchen override is bypassed because large H3 sequences can exceed Sage prequantized int32 strides. save_latent is ON so the recovered RAW-clock latent is saved for deferred reuse. The compact HQ continuation tail is retained automatically when the next scene needs it."
+      },
+      "inputs": {},
+      "label": "DEPENDENCIES / QUALITY AND MEMORY"
+    },
+    {
+      "key": "n21",
+      "type": "H3ConditioningSyncFromLatents",
+      "settings": {
+        "method": "bilinear",
+        "motion_ref_mode": "conditioning_policy"
+      },
+      "inputs": {
+        "original_latent": [
+          "n3",
+          "source_video_latent"
+        ],
+        "upscaled_latent": [
+          "n32",
+          "video_latent"
+        ],
+        "positive": [
+          "n9",
+          "positive"
+        ]
+      }
+    },
+    {
+      "key": "n22",
+      "type": "MiniMaxH3UpscaleReferencePromptOverride",
+      "settings": {
+        "prompt_override": "",
+        "disabled_tags": ""
+      },
+      "inputs": {}
+    },
+    {
+      "key": "n23",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_audio_vae_fp32.safetensors"
+      },
+      "inputs": {}
+    },
+    {
+      "key": "n24",
+      "type": "VAEDecode",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n3",
+          "source_video_latent"
+        ],
+        "vae": [
+          "n8",
+          "VAE"
+        ]
+      }
+    },
+    {
+      "key": "n25",
+      "type": "VAEDecodeAudio",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n3",
+          "source_audio_latent"
+        ],
+        "vae": [
+          "n23",
+          "VAE"
+        ]
+      }
+    },
+    {
+      "key": "n26",
+      "type": "H3JerkOracle",
+      "settings": {
+        "length": 124,
+        "q": 0.75,
+        "d_max": 4,
+        "ramp": true,
+        "preset": "balanced (default)",
+        "bridge": 8,
+        "profile_mode": "value |d3| (default)",
+        "abstain_below": 0,
+        "fps": 24,
+        "s_per_step": 0,
+        "est_steps": 8,
+        "overhead_s": 6.7,
+        "model_profile": "minimax-h3",
+        "protect_tail": 0
+      },
+      "inputs": {
+        "samples": [
+          "n3",
+          "source_video_latent"
+        ],
+        "length": [
+          "n3",
+          "raw_frames"
+        ]
+      }
+    },
+    {
+      "key": "n27",
+      "type": "MiniMaxH3ChainDeropeGuard",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n3",
+          "state"
+        ],
+        "hold_map": [
+          "n26",
+          "hold_map"
+        ]
+      }
+    },
+    {
+      "key": "n28",
+      "type": "H3TimeSmear",
+      "settings": {
+        "dilation": 4,
+        "hold_map": "",
+        "expand_to_end": true,
+        "fps": 24,
+        "s_per_step": 0,
+        "est_steps": 18,
+        "overhead_s": 6.7
+      },
+      "inputs": {
+        "images": [
+          "n24",
+          "IMAGE"
+        ],
+        "hold_map": [
+          "n27",
+          "hold_map"
+        ],
+        "expand_to_end": [
+          "n27",
+          "expand_to_end"
+        ]
+      }
+    },
+    {
+      "key": "n29",
+      "type": "VAEEncode",
+      "settings": {},
+      "inputs": {
+        "pixels": [
+          "n28",
+          "images"
+        ],
+        "vae": [
+          "n8",
+          "VAE"
+        ]
+      }
+    },
+    {
+      "key": "n30",
+      "type": "H3AudioSmear",
+      "settings": {
+        "hold_map": "",
+        "fps": 24
+      },
+      "inputs": {
+        "audio": [
+          "n25",
+          "AUDIO"
+        ],
+        "hold_map": [
+          "n28",
+          "hold_map_used"
+        ]
+      }
+    },
+    {
+      "key": "n31",
+      "type": "VAEEncodeAudio",
+      "settings": {},
+      "inputs": {
+        "audio": [
+          "n30",
+          "AUDIO"
+        ],
+        "vae": [
+          "n23",
+          "VAE"
+        ]
+      }
+    },
+    {
+      "key": "n32",
+      "type": "MiniMaxH3ChainDeropeContinuity",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n3",
+          "state"
+        ],
+        "video_latent": [
+          "n11",
+          "latent"
+        ]
+      }
+    },
+    {
+      "key": "n33",
+      "type": "MiniMaxH3ChainDeropeFreezeMask",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n3",
+          "state"
+        ],
+        "hold_map_used": [
+          "n28",
+          "hold_map_used"
+        ]
+      }
+    },
+    {
+      "key": "n34",
+      "type": "H3V2VInit",
+      "settings": {
+        "length": 0,
+        "freeze_threshold": 0,
+        "freeze_grow": 2,
+        "mask_feather": 0,
+        "invert_mask": false,
+        "time_varying": true,
+        "audio_mode": "follow the original performance (0.5)",
+        "audio_strength": 0.5,
+        "audio_prefix_ticks": 0,
+        "audio_prefix_release_ticks": 0
+      },
+      "inputs": {
+        "samples": [
+          "n32",
+          "video_latent"
+        ],
+        "length": [
+          "n28",
+          "length"
+        ],
+        "mask": [
+          "n33",
+          "mask"
+        ],
+        "audio_latent": [
+          "n31",
+          "LATENT"
+        ]
+      }
+    },
+    {
+      "key": "n35",
+      "type": "H3InjectSchedule",
+      "settings": {
+        "scheduler": "simple",
+        "total_steps": 20,
+        "inject": 0.5,
+        "preset": "custom"
+      },
+      "inputs": {
+        "model": [
+          "n6",
+          "MODEL"
+        ]
+      }
+    },
+    {
+      "key": "n36",
+      "type": "VAEDecodeAudio",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n14",
+          "output"
+        ],
+        "vae": [
+          "n23",
+          "VAE"
+        ]
+      }
+    },
+    {
+      "key": "n37",
+      "type": "H3ExactRecover",
+      "settings": {
+        "hold_map": ""
+      },
+      "inputs": {
+        "images": [
+          "n15",
+          "IMAGE"
+        ],
+        "hold_map": [
+          "n28",
+          "hold_map_used"
+        ]
+      }
+    },
+    {
+      "key": "n38",
+      "type": "H3AudioRecover",
+      "settings": {
+        "hold_map": "",
+        "fps": 24,
+        "reference_mix": 1,
+        "audio_source": "keep the original performance (safe default)"
+      },
+      "inputs": {
+        "audio": [
+          "n36",
+          "AUDIO"
+        ],
+        "hold_map": [
+          "n28",
+          "hold_map_used"
+        ],
+        "reference": [
+          "n25",
+          "AUDIO"
+        ]
+      }
+    },
+    {
+      "key": "n39",
+      "type": "VAEEncode",
+      "settings": {},
+      "inputs": {
+        "pixels": [
+          "n37",
+          "IMAGE"
+        ],
+        "vae": [
+          "n8",
+          "VAE"
+        ]
+      }
+    },
+    {
+      "key": "n40",
+      "type": "VAEEncodeAudio",
+      "settings": {},
+      "inputs": {
+        "audio": [
+          "n38",
+          "AUDIO"
+        ],
+        "vae": [
+          "n23",
+          "VAE"
+        ]
+      }
+    },
+    {
+      "key": "n41",
+      "type": "MiniMaxH3ChainRecoveredAV",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n3",
+          "state"
+        ],
+        "video_latent": [
+          "n39",
+          "LATENT"
+        ],
+        "audio_latent": [
+          "n40",
+          "LATENT"
+        ]
+      }
+    }
+  ]
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Deferred Upscale - H3 LBH 3D - MiniMax H3 0.6.json b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Deferred Upscale - H3 LBH 3D - MiniMax H3 0.6.json
new file mode 100644
index 0000000000000000000000000000000000000000..1bb271033ec4d6d1d9a94e39a3bace7c9126fbd3
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Deferred Upscale - H3 LBH 3D - MiniMax H3 0.6.json	
@@ -0,0 +1,396 @@
+{
+  "nodes": [
+    {
+      "key": "n1",
+      "type": "MiniMaxH3ChainCheckpointManager",
+      "settings": {
+        "selection_json": ""
+      },
+      "inputs": {}
+    },
+    {
+      "key": "n2",
+      "type": "MiniMaxH3ChainUpscaleAdapter",
+      "settings": {
+        "profile": "h3_lbh_3d",
+        "backend": "h3_latent",
+        "recipe_json": "{\"upscaler\":\"LBH 3D\",\"target_megapixels\":1.5,\"pass2_steps\":2,\"denoise\":0.24,\"conditioning\":\"latent_sync\",\"audio_denoise\":0}",
+        "start_clip": 1,
+        "end_clip": 0,
+        "save_latent": false,
+        "segment_crf": 18
+      },
+      "inputs": {
+        "source_manifest": [
+          "n1",
+          "selected_manifest"
+        ]
+      }
+    },
+    {
+      "key": "n3",
+      "type": "MiniMaxH3ChainUpscaleCurrent",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n2",
+          "state"
+        ]
+      }
+    },
+    {
+      "key": "n4",
+      "type": "UNETLoader",
+      "settings": {
+        "unet_name": "minimax_h3_fl2va_pruned_int8_convrot.safetensors",
+        "weight_dtype": "default"
+      },
+      "inputs": {}
+    },
+    {
+      "key": "n5",
+      "type": "ModelAttentionBackend",
+      "settings": {
+        "attention": "pytorch attention"
+      },
+      "inputs": {
+        "model": [
+          "n4",
+          "MODEL"
+        ]
+      },
+      "mode": 4
+    },
+    {
+      "key": "n6",
+      "type": "MiniMaxH3SigmaShift",
+      "settings": {
+        "shift_video": 12,
+        "shift_audio": 3
+      },
+      "inputs": {
+        "model": [
+          "n5",
+          "MODEL"
+        ]
+      }
+    },
+    {
+      "key": "n7",
+      "type": "CLIPLoader",
+      "settings": {
+        "clip_name": "qwen3vl_32b_minimax_h3_int8_convrot.safetensors",
+        "type": "minimax",
+        "device": "default"
+      },
+      "inputs": {}
+    },
+    {
+      "key": "n8",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_video_vae_fp16.safetensors"
+      },
+      "inputs": {}
+    },
+    {
+      "key": "n9",
+      "type": "MiniMaxH3UpscaleReferencePromptOverride",
+      "settings": {
+        "prompt_override": "",
+        "disabled_tags": ""
+      },
+      "inputs": {}
+    },
+    {
+      "key": "n10",
+      "type": "MiniMaxH3ChainUpscaleReferenceConditioning",
+      "settings": {
+        "missing_cache": "text_only",
+        "motion_ref_mode": "exclude_video_keep_audio",
+        "prompt_override": "",
+        "override_ref_image_size": "inherit",
+        "override_reference_policy": "strict"
+      },
+      "inputs": {
+        "state": [
+          "n3",
+          "state"
+        ],
+        "clip": [
+          "n7",
+          "CLIP"
+        ],
+        "video_vae": [
+          "n8",
+          "VAE"
+        ],
+        "prompt_override": [
+          "n9",
+          "prompt_override"
+        ],
+        "tagged_references": [
+          "n9",
+          "references"
+        ]
+      }
+    },
+    {
+      "key": "n11",
+      "type": "RandomNoise",
+      "settings": {
+        "noise_seed": 0,
+        "control_after_generate": "fixed"
+      },
+      "inputs": {
+        "noise_seed": [
+          "n3",
+          "seed"
+        ]
+      }
+    },
+    {
+      "key": "n12",
+      "type": "BasicScheduler",
+      "settings": {
+        "scheduler": "simple",
+        "steps": 20,
+        "denoise": 0.24
+      },
+      "inputs": {
+        "model": [
+          "n6",
+          "MODEL"
+        ]
+      }
+    },
+    {
+      "key": "n13",
+      "type": "MinimaxH3LatentUpscaler3D",
+      "settings": {
+        "model_name": "minimax_h3_latent_upscaler_3d_fp16.safetensors",
+        "mode": "megapixels",
+        "mode.megapixels": 1.5,
+        "align": 32,
+        "enable_temporal_chunking": true,
+        "force_unload": true,
+        "device": "cuda",
+        "precision": "fp16"
+      },
+      "inputs": {
+        "latent": [
+          "n3",
+          "source_video_latent"
+        ]
+      }
+    },
+    {
+      "key": "n14",
+      "type": "H3ConditioningSyncFromLatents",
+      "settings": {
+        "method": "bilinear",
+        "motion_ref_mode": "conditioning_policy"
+      },
+      "inputs": {
+        "original_latent": [
+          "n3",
+          "source_video_latent"
+        ],
+        "upscaled_latent": [
+          "n13",
+          "latent"
+        ],
+        "positive": [
+          "n10",
+          "positive"
+        ]
+      }
+    },
+    {
+      "key": "n15",
+      "type": "MiniMaxH3ChainPass2Prepare",
+      "settings": {},
+      "inputs": {
+        "upscaled_video": [
+          "n13",
+          "latent"
+        ],
+        "source_audio": [
+          "n3",
+          "source_audio_latent"
+        ],
+        "model": [
+          "n6",
+          "MODEL"
+        ],
+        "noise": [
+          "n11",
+          "NOISE"
+        ],
+        "sigmas": [
+          "n12",
+          "SIGMAS"
+        ],
+        "state": [
+          "n3",
+          "state"
+        ]
+      }
+    },
+    {
+      "key": "n16",
+      "type": "BasicGuider",
+      "settings": {},
+      "inputs": {
+        "model": [
+          "n6",
+          "MODEL"
+        ],
+        "conditioning": [
+          "n14",
+          "positive"
+        ]
+      }
+    },
+    {
+      "key": "n17",
+      "type": "DisableNoise",
+      "settings": {},
+      "inputs": {}
+    },
+    {
+      "key": "n18",
+      "type": "KSamplerSelect",
+      "settings": {
+        "sampler_name": "res_multistep"
+      },
+      "inputs": {}
+    },
+    {
+      "key": "n19",
+      "type": "SamplerCustomAdvanced",
+      "settings": {},
+      "inputs": {
+        "noise": [
+          "n17",
+          "NOISE"
+        ],
+        "guider": [
+          "n16",
+          "GUIDER"
+        ],
+        "sampler": [
+          "n18",
+          "SAMPLER"
+        ],
+        "sigmas": [
+          "n12",
+          "SIGMAS"
+        ],
+        "latent_image": [
+          "n15",
+          "latent"
+        ]
+      }
+    },
+    {
+      "key": "n20",
+      "type": "VAEDecode",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n19",
+          "output"
+        ],
+        "vae": [
+          "n8",
+          "VAE"
+        ]
+      }
+    },
+    {
+      "key": "n21",
+      "type": "MiniMaxH3ChainUpscaleSegmentSave",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n3",
+          "state"
+        ],
+        "images": [
+          "n20",
+          "IMAGE"
+        ],
+        "upscaled_latent": [
+          "n19",
+          "output"
+        ]
+      }
+    },
+    {
+      "key": "n22",
+      "type": "MiniMaxH3ChainUpscaleLoopEnd",
+      "settings": {},
+      "inputs": {
+        "flow": [
+          "n2",
+          "flow"
+        ],
+        "state": [
+          "n3",
+          "state"
+        ],
+        "images": [
+          "n20",
+          "IMAGE"
+        ],
+        "segment": [
+          "n21",
+          "segment"
+        ],
+        "upscaled_latent": [
+          "n19",
+          "output"
+        ]
+      }
+    },
+    {
+      "key": "n23",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "h3_upscaled_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n22",
+          "manifest"
+        ]
+      }
+    },
+    {
+      "key": "n24",
+      "type": "Note",
+      "settings": {
+        "text": "STANDALONE H3 CHECKPOINT UPSCALE\n\n1. Open Checkpoint Manager and select the right-hand tip you want to finish. A partial generated branch is valid; no ungenerated scenes are required.\n2. The selected_manifest cable is the complete parent-chain contract. No Plan, Source Timeline, source audio, or external context enters the upscale loop. Original reference media is unnecessary unless you deliberately connect a new Tagged Ref line to the override node.\n3. Choose a unique profile in Upscale Adapter. start_clip=1/end_clip=0 processes every generated scene in the selection.\n4. Set LBH target megapixels. The default is 1.5 MP with grid-32 alignment.\n5. Queue. Each HQ scene is saved before the loop advances; Assemble writes under output/h3_chains/<run>/upscaled/<profile>/final/.\n\nsave_latent is OFF by default. Enable it only when you need to reopen the complete HQ latent later. Drift-Control compatibility still saves only the small 12-step HQ context tail needed by the following scene and by interrupted-run resume.\n\nUpscale Reference Conditioning restores the scene's original Ref2VA conditioning from its automatic cache. Upscale Reference + Prompt Override stays inline on the normal H3 Tagged Ref line: leave its references input empty for automatic cache restore, or connect a new Tagged registry to replace the cached refs for pass 2. Use disabled_tags to omit selected connected refs. Its prompt override is blank by default, so pass 2 uses the exact compiled source prompt.\n\nOPTIONAL NEUTRAL REPLACEMENT PROMPT — copy this into the override only for a controlled comparison:\nPreserve the existing video's identity, appearance, composition, framing, lighting, color, action, motion timing, and audio. Use the supplied picture references only to maintain the identities and appearance already present. Improve only fine spatial detail and high-resolution texture fidelity. Do not introduce new motion, objects, cuts, camera moves, or scene changes.\n\nThe default motion policy excludes both the Qwen motion-video presentation and native motion-reference latent because the source latent already contains the generated motion; paired reference audio is retained. H3 Conditioning Sync From Latents follows that policy automatically, measures LBH's real X/Y latent scale, and resizes match picture minimax_refs plus minimax_keyframes while keeping max picture refs at their cached geometry. Its positive output creates a fresh pass-2 Basic Guider. Older non-reference runs fall back to text-only by default; choose error when a Ref2VA cache is mandatory."
+      },
+      "inputs": {},
+      "label": "HOW TO RUN"
+    },
+    {
+      "key": "n25",
+      "type": "Note",
+      "settings": {
+        "text": "REQUIRES\nhttps://github.com/LBH-123-AI/Comfyui_Minimax_h3_latent_Upscaler\nDownload minimax_h3_latent_upscaler_3d_fp16.safetensors into ComfyUI/models/latent_upscale_models/.\n\nLBH receives only the saved clean 24-channel VIDEO x0. MiniMax H3 Pass-2 AV Prepare rejoins the untouched 32-channel audio and reads the current upscale state. For Drift-Control AV scene 2+, it replaces the 12-step pass-2 prefix with the previous HQ latent tail, gives that prefix zero added noise and a zero denoise mask, refines only the new video region, and keeps audio locked. Other continuation modes retain the open-video behavior. H3 Conditioning Sync From Latents follows the community pass-2 method: original latent + LBH latent + original conditioning -> spatially synchronized conditioning -> new Guider -> sampler 2. Choose motion policy once on Upscale Reference Conditioning: exclude_video_keep_audio is the upscale default; keep_video_native and resize_video remain available for controlled comparisons. Leave the sync node on conditioning_policy. The default interpolation is bilinear.\n\nConservative defaults: 1.5 MP, align 32, FP16, 2 pass-2 steps, denoise 0.24, simple schedule, Euler. Raise denoise only after checking identity and scene boundaries. The Comfy Kitchen attention override remains bypassed because large H3 target sequences can exceed Sage prequantized int32 stride limits; this graph uses ComfyUI's PyTorch attention path. Functional nodes intentionally retain their original display names."
+      },
+      "inputs": {},
+      "label": "DEPENDENCY / PASS-2 NOTES"
+    }
+  ]
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Deferred Upscale - Pixel DLSS5 + USDU - EXPERIMENTAL - MiniMax H3 0.6.json b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Deferred Upscale - Pixel DLSS5 + USDU - EXPERIMENTAL - MiniMax H3 0.6.json
new file mode 100644
index 0000000000000000000000000000000000000000..29d57d931abb7282013be47e552aa4b877aa4b29
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Deferred Upscale - Pixel DLSS5 + USDU - EXPERIMENTAL - MiniMax H3 0.6.json	
@@ -0,0 +1,326 @@
+{
+  "compatibility_note": "Validated against the **0.6 node definitions**. A corresponding nightly example is maintained on that branch.",
+  "nodes": [
+    {
+      "key": "manager",
+      "type": "MiniMaxH3ChainCheckpointManager",
+      "settings": {
+        "selection_json": ""
+      },
+      "inputs": {}
+    },
+    {
+      "key": "adapter",
+      "type": "MiniMaxH3ChainUpscaleAdapter",
+      "settings": {
+        "profile": "h3_pixel_dlss5",
+        "backend": "pixel",
+        "recipe_json": "{\"upscaler\":\"DLSS5\",\"refiner\":\"USDU H3\",\"conditioning\":\"actual_image_size\",\"audio\":\"preserve_source\",\"denoise\":0.2,\"steps\":3}",
+        "start_clip": 1,
+        "end_clip": 0,
+        "save_latent": false,
+        "segment_crf": 18
+      },
+      "inputs": {
+        "source_manifest": [
+          "manager",
+          "selected_manifest"
+        ]
+      }
+    },
+    {
+      "key": "video_vae",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_video_vae_fp16.safetensors"
+      },
+      "inputs": {}
+    },
+    {
+      "key": "current",
+      "type": "MiniMaxH3ChainUpscalePixelCurrent",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "adapter",
+          "state"
+        ],
+        "video_vae": [
+          "video_vae",
+          "VAE"
+        ]
+      }
+    },
+    {
+      "key": "model",
+      "type": "UNETLoader",
+      "settings": {
+        "unet_name": "minimax_h3_ref2va_pruned_int8_convrot.safetensors",
+        "weight_dtype": "default"
+      },
+      "inputs": {}
+    },
+    {
+      "key": "turbo",
+      "type": "LoraLoaderModelOnly",
+      "settings": {
+        "lora_name": "minimax_h3_turbo_v4_step600_ema_pruned_comfyui.safetensors",
+        "strength_model": 0.75
+      },
+      "inputs": {
+        "model": [
+          "model",
+          "MODEL"
+        ]
+      }
+    },
+    {
+      "key": "clip",
+      "type": "CLIPLoader",
+      "settings": {
+        "clip_name": "qwen3vl_32b_minimax_h3_int8_convrot.safetensors",
+        "type": "minimax",
+        "device": "default"
+      },
+      "inputs": {}
+    },
+    {
+      "key": "dlss_settings",
+      "type": "DLSS5Settings",
+      "settings": {
+        "upscaling_mode": "2x (Performance)",
+        "nr_preset": "Default",
+        "nr_style": "Default",
+        "nr_intensity": 0,
+        "local_tone_strength": 0,
+        "local_structure_strength": 0,
+        "skin_structure_strength": 0,
+        "automatic_mask": true,
+        "dlss_model_preset": "L",
+        "motion": "auto",
+        "scene_change_threshold": 0.24,
+        "warmup_frames": 0,
+        "runtime_dir": ""
+      },
+      "inputs": {}
+    },
+    {
+      "key": "dlss",
+      "type": "DLSS5EnhanceImages",
+      "settings": {
+        "verify_neural_rendering": true
+      },
+      "inputs": {
+        "images": [
+          "current",
+          "images"
+        ],
+        "settings": [
+          "dlss_settings",
+          "settings"
+        ]
+      }
+    },
+    {
+      "key": "override",
+      "type": "MiniMaxH3UpscaleReferencePromptOverride",
+      "settings": {
+        "prompt_override": "",
+        "disabled_tags": ""
+      },
+      "inputs": {}
+    },
+    {
+      "key": "conditioning",
+      "type": "MiniMaxH3ChainUpscalePixelConditioning",
+      "settings": {
+        "missing_cache": "text_only",
+        "motion_ref_mode": "exclude_video_keep_audio",
+        "method": "bilinear",
+        "prompt_override": "",
+        "override_ref_image_size": "inherit",
+        "override_reference_policy": "strict",
+        "conditioning_width": 0,
+        "conditioning_height": 0
+      },
+      "inputs": {
+        "state": [
+          "current",
+          "state"
+        ],
+        "clip": [
+          "clip",
+          "CLIP"
+        ],
+        "video_vae": [
+          "video_vae",
+          "VAE"
+        ],
+        "images": [
+          "dlss",
+          "images"
+        ],
+        "prompt_override": [
+          "override",
+          "prompt_override"
+        ],
+        "tagged_references": [
+          "override",
+          "references"
+        ]
+      }
+    },
+    {
+      "key": "guider",
+      "type": "BasicGuider",
+      "settings": {},
+      "inputs": {
+        "model": [
+          "turbo",
+          "MODEL"
+        ],
+        "conditioning": [
+          "conditioning",
+          "positive"
+        ]
+      }
+    },
+    {
+      "key": "schedule",
+      "type": "BasicScheduler",
+      "settings": {
+        "scheduler": "beta",
+        "steps": 3,
+        "denoise": 0.2
+      },
+      "inputs": {
+        "model": [
+          "turbo",
+          "MODEL"
+        ]
+      }
+    },
+    {
+      "key": "sampler",
+      "type": "KSamplerSelect",
+      "settings": {
+        "sampler_name": "er_sde"
+      },
+      "inputs": {}
+    },
+    {
+      "key": "refine",
+      "type": "UltimateSDUpscaleNoUpscaleGuider",
+      "settings": {
+        "seed": 0,
+        "control_after_generate": "fixed",
+        "mode_type": "Chess",
+        "tile_width": 864,
+        "tile_height": 960,
+        "mask_blur": 16,
+        "tile_padding": 64,
+        "seam_fix_mode": "None",
+        "seam_fix_denoise": 0.15,
+        "seam_fix_width": 32,
+        "seam_fix_mask_blur": 4,
+        "seam_fix_padding": 16,
+        "tile_overlap_mode": "Reprocess Overlap",
+        "tiled_decode": true,
+        "batch_size": 1,
+        "anchor_context": false
+      },
+      "inputs": {
+        "upscaled_image": [
+          "conditioning",
+          "images"
+        ],
+        "guider": [
+          "guider",
+          "GUIDER"
+        ],
+        "sampler": [
+          "sampler",
+          "SAMPLER"
+        ],
+        "sigmas": [
+          "schedule",
+          "SIGMAS"
+        ],
+        "vae": [
+          "video_vae",
+          "VAE"
+        ],
+        "seed": [
+          "current",
+          "seed"
+        ]
+      }
+    },
+    {
+      "key": "save",
+      "type": "MiniMaxH3ChainUpscaleSegmentSave",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "current",
+          "state"
+        ],
+        "images": [
+          "refine",
+          "IMAGE"
+        ]
+      }
+    },
+    {
+      "key": "end",
+      "type": "MiniMaxH3ChainUpscaleLoopEnd",
+      "settings": {},
+      "inputs": {
+        "flow": [
+          "adapter",
+          "flow"
+        ],
+        "state": [
+          "current",
+          "state"
+        ],
+        "images": [
+          "refine",
+          "IMAGE"
+        ],
+        "segment": [
+          "save",
+          "segment"
+        ]
+      }
+    },
+    {
+      "key": "assemble",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "h3_pixel_upscaled_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "end",
+          "manifest"
+        ]
+      }
+    },
+    {
+      "key": "guide",
+      "type": "Note",
+      "settings": {
+        "text": "EXPERIMENTAL • PER-SCENE PIXEL UPSCALE\n\nAdapted from Illynir's H3_Pixel_Upscale_Loop.json and the Banodoco discussion:\nhttps://discord.com/channels/1076117621407223829/1537598841199792148/1545925352377815130\nRequirements and actual-image sizing:\nhttps://discord.com/channels/1076117621407223829/1537598841199792148/1545926662288449637\n\nSelect a saved generated lineage in Checkpoint Manager (no Plan is needed). Choose a new child profile in Upscale Adapter, backend=pixel, save_latent=false. start_clip=1/end_clip=0 processes all selected generated scenes, one at a time; it does not upscale the full movie at once.\n\nPixel Current Scene decodes the original clean video checkpoint at its RAW frame count. DLSS5 upscales it. Pixel Upscale Conditioning measures those actual images, restores cached or overridden references at the target canvas, and synchronizes remaining eligible video/keyframe conditioning exactly once. Its positive output feeds Basic Guider; its unchanged images output feeds USDU H3. Do not insert another resize between conditioning and refinement. Both dimensions must be multiples of 32: if using a fractional upscaler, align its output before feeding this node.\n\nPicture policy is preserved: match references are rebuilt from their cached RGB masters using the target canvas; max references deliberately retain their capped geometry. The source reference aspect ratio is preserved, so a match reference need not have the identical pixel rectangle as the movie. No fake latent or full-video VAE encode is used merely to determine size. The default motion policy drops reference video but keeps paired audio conditioning.\n\nPixel Upscale Conditioning also has `conditioning_width` and `conditioning_height`, both defaulting to `0` (auto). Each zero uses the corresponding actual image dimension; a positive multiple of 32 overrides that axis of the reference-conditioning canvas. For example, `1920 × 1088` sizes match picture references independently of a larger output movie. This works with cached and connected picture references; max-policy pictures remain capped as before. Output images, width/height outputs, and spatial keyframes still follow the actual image canvas. Existing workflows keep automatic sizing. Use a new upscale profile when changing these settings to avoid mixing refinement recipes.\n\nUSDU performs its own tile encoding and low-denoise H3 refinement. The example retains the contributed 2x DLSS settings, Turbo v4 strength 0.75, beta schedule, 3 steps and denoise 0.2; these are experimental starting points, not a quality guarantee. The current upstream anchor_context field is BOOLEAN, not the stale 'H3 Visual Conditioning' string in the contributed file. H3 handling is selected by the H3 model in that fork. Extra memory-cleanup/attention patches from the original graph are not required for wiring; add your preferred memory controls only after a small test.\n\nSave and Loop End both receive the final RAW images. They trim the repeated prefix once and retain each source checkpoint's delivered audio unchanged. Do not wire Pixel Current source_audio into recovered_audio (which expects RAW audio), or into Assemble source_audio (which expects the whole-run source track). The image reader's source_audio output is delivered-only and optional, intended for inspection/preview, not for a RAW-image mux. No audio VAE is required to preserve saved delivered sound.\n\nNo Pass-2 AV Prepare, latent Conditioning Sync, or upscaled_latent connection is needed. With backend=pixel, a parent Drift-Control boundary no longer demands an HQ latent; pixel refinement does not freeze/splice latent prefixes. This changes the refinement continuity strategy, not the original generation or its checkpoints. Inspect transitions before accepting a final.\n\nEach completed scene is saved under output/h3_chains/<run>/upscaled/<profile>/. To resume, retain the same selection/profile/settings and set start_clip to the first unfinished scene. A changed source branch or recorded recipe refuses reuse of the prior HQ prefix. recipe_json documents the recipe but does not automatically track every external node edit: choose a new profile when changing upscaler/model/settings to avoid mixing passes. Final assembly is under that child profile's final/ directory. A selected generated branch can stop before ungenerated Plan scenes.\n\nDEPENDENCIES\n\n- DLSS5 image upscaler: https://github.com/Blueforcer/ComfyUI-DLSS5-Enhancer\n  Its NVIDIA runtime is a separate platform-specific requirement; this file does not install it. Select/configure runtime_dir according to that pack. Any frame-preserving IMAGE upscaler can replace DLSS5 if its output drives both conditioning and refinement.\n- H3-aware USDU fork: https://github.com/lisitskyaa/ComfyUI_UltimateSDUpscaleGuider_H3\n  Use this H3-capable Guider fork, not just the unrelated standard Ultimate SD Upscale pack.\n- MiniMax H3 Ref2VA model, Qwen3-VL encoder, video VAE, and Turbo v4 LoRA. Select the installed filenames. Removing the Turbo LoRA requires retuning the schedule, not merely bypassing it at three steps.\n\nVALIDATION\n\nThe H3 adapter, scene reader, target-size reference rebuild, RAW trim, preserved audio, per-scene save, resume and final assembly have CPU integration coverage with synthetic checkpoints and fake VAE/CLIP. The external DLSS5 + USDU GPU refinement and visual quality still need testing on a machine with those packs and models. Start with one short scene before a long run."
+      },
+      "inputs": {}
+    }
+  ]
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Deferred Upscale - SeedVR2 Full Chain - MiniMax H3 0.6.json b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Deferred Upscale - SeedVR2 Full Chain - MiniMax H3 0.6.json
new file mode 100644
index 0000000000000000000000000000000000000000..dd778082da0f9486107cf5d4a38087fef4966494
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Deferred Upscale - SeedVR2 Full Chain - MiniMax H3 0.6.json	
@@ -0,0 +1,133 @@
+{
+  "nodes": [
+    {
+      "key": "n1",
+      "type": "MiniMaxH3ChainCheckpointManager",
+      "settings": {
+        "selection_json": ""
+      },
+      "inputs": {}
+    },
+    {
+      "key": "n2",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_video_vae_fp16.safetensors"
+      },
+      "inputs": {}
+    },
+    {
+      "key": "n3",
+      "type": "MiniMaxH3ChainLatentVideoAdapter",
+      "settings": {
+        "audio_source": "plan",
+        "blend_schedule": "plan",
+        "decode_buffer": "disk-backed",
+        "reuse_cache": true,
+        "audio_bitrate": 256
+      },
+      "inputs": {
+        "manifest": [
+          "n1",
+          "selected_manifest"
+        ],
+        "video_vae": [
+          "n2",
+          "VAE"
+        ]
+      }
+    },
+    {
+      "key": "n4",
+      "type": "SeedVR2LoadDiTModel",
+      "settings": {
+        "model": "seedvr2_ema_3b_fp16.safetensors",
+        "device": "cuda:0",
+        "blocks_to_swap": 32,
+        "swap_io_components": false,
+        "offload_device": "cpu",
+        "cache_model": false,
+        "attention_mode": "sdpa"
+      },
+      "inputs": {}
+    },
+    {
+      "key": "n5",
+      "type": "SeedVR2LoadVAEModel",
+      "settings": {
+        "model": "ema_vae_fp16.safetensors",
+        "device": "cuda:0",
+        "encode_tiled": true,
+        "encode_tile_size": 1024,
+        "encode_tile_overlap": 128,
+        "decode_tiled": true,
+        "decode_tile_size": 768,
+        "decode_tile_overlap": 128,
+        "tile_debug": "false",
+        "offload_device": "cpu",
+        "cache_model": false
+      },
+      "inputs": {}
+    },
+    {
+      "key": "n6",
+      "type": "SeedVR2VideoPathUpscaler",
+      "settings": {
+        "seed": 42,
+        "control_after_generate": "fixed",
+        "resolution": 1080,
+        "max_resolution": 0,
+        "batch_size": 5,
+        "chunk_size": 21,
+        "color_correction": "lab",
+        "chunk_overlap": 2,
+        "uniform_batch_size": false,
+        "temporal_overlap": 0,
+        "prepend_frames": 0,
+        "input_noise_scale": 0.0,
+        "latent_noise_scale": 0.0,
+        "offload_device": "cpu",
+        "temporary_video_crf": 18,
+        "enable_debug": false
+      },
+      "inputs": {
+        "video": [
+          "n3",
+          "video"
+        ],
+        "dit": [
+          "n4",
+          "SEEDVR2_DIT"
+        ],
+        "vae": [
+          "n5",
+          "SEEDVR2_VAE"
+        ]
+      }
+    },
+    {
+      "key": "n7",
+      "type": "SaveVideo",
+      "settings": {
+        "filename_prefix": "video/h3_seedvr2_%date:yyyy-MM-dd%",
+        "format": "auto",
+        "format.codec": "auto",
+        "codec": "auto"
+      },
+      "inputs": {
+        "video": [
+          "n6",
+          "video"
+        ]
+      }
+    },
+    {
+      "key": "n8",
+      "type": "Note",
+      "settings": {
+        "text": "WHOLE-CHAIN SEEDVR2 FINISH\n\n1. In Checkpoint Manager select the final scene of a COMPLETE branch.\n2. Use the original H3 VIDEO VAE. Do not select minimax_h3_audio_vae: it has 32 latent channels and cannot decode the 24-channel video latent.\n3. Keep decode_buffer=disk-backed. MiniMax's temporal VAE writes the active scene to a temporary mmap; only boundary frames stay in ordinary RAM.\n4. The adapter trims saved context, resolves the Plan's boundary blends, embeds the saved final audio policy, and caches one continuous lossless movie under output/h3_chains/<run>/upscaled/seedvr2/source/.\n5. SeedVR2 Direct reads that movie in chunk_size batches. chunk_size=21 and overlap=2 are conservative defaults; its batching is independent of H3 scene boundaries.\n6. The ethanfel SeedVR2 fork preserves input audio in its returned VIDEO, so it connects directly to core Save Video.\n\nNo Plan, Source Timeline, source media, per-scene upscale loop, IMAGE batch, or manual intermediate path is required. Legacy source-audio runs without a saved Source Timeline are the only case that may need source_audio on the adapter.\n\nRequired SeedVR2 fork: https://github.com/ethanfel/ComfyUI-SeedVR2_VideoUpscaler"
+      },
+      "inputs": {}
+    }
+  ]
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/FL2V Normal - MiniMax H3 0.6.json b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/FL2V Normal - MiniMax H3 0.6.json
new file mode 100644
index 0000000000000000000000000000000000000000..be86ff9709b82dc8028d0ed77559b86e77d30cfd
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/FL2V Normal - MiniMax H3 0.6.json	
@@ -0,0 +1,621 @@
+{
+  "nodes": [
+    {
+      "key": "n1",
+      "type": "UNETLoader",
+      "settings": {
+        "unet_name": "minimax_h3_fl2va_pruned_int8_convrot.safetensors",
+        "weight_dtype": "default"
+      },
+      "inputs": {},
+      "label": "Load Diffusion Model — H3 MODEL — REQUIRED"
+    },
+    {
+      "key": "n2",
+      "type": "CLIPLoader",
+      "settings": {
+        "clip_name": "qwen3vl_32b_minimax_h3_int8_convrot.safetensors",
+        "type": "minimax",
+        "device": "default"
+      },
+      "inputs": {},
+      "label": "Load CLIP — H3 TEXT ENCODER"
+    },
+    {
+      "key": "n3",
+      "type": "KSamplerSelect",
+      "settings": {
+        "sampler_name": "res_multistep"
+      },
+      "inputs": {},
+      "label": "KSamplerSelect — Sampler algorithm"
+    },
+    {
+      "key": "n4",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_video_vae_fp16.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Video VAE"
+    },
+    {
+      "key": "n5",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_audio_vae_fp32.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Audio VAE"
+    },
+    {
+      "key": "n6",
+      "type": "Note",
+      "settings": {
+        "text": "0.6 A→B REFERENCES\n\nCopy h3_v06_courier_greenhouse_arrival.png and h3_v06_courier_greenhouse_delivery.png from example_workflows/assets to ComfyUI/input. They were created as a coherent opening/destination pair for this release catalog."
+      },
+      "inputs": {},
+      "label": "0.6 A→B REFERENCES"
+    },
+    {
+      "key": "n11",
+      "type": "MiniMaxH3ChainCurrent",
+      "settings": {
+        "align_audio_reference": false
+      },
+      "inputs": {
+        "state": [
+          "n35",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Current Shot — CURRENT FL2V SCENE — PROMPT / SEED / TIMING"
+    },
+    {
+      "key": "n12",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "t2v_normal_recovered_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n32",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — RECOVERY: ASSEMBLE WITHOUT RENDERING",
+      "mode": 2
+    },
+    {
+      "key": "n14",
+      "type": "RandomNoise",
+      "settings": {
+        "noise_seed": 0,
+        "control_after_generate": "fixed"
+      },
+      "inputs": {
+        "noise_seed": [
+          "n11",
+          "noise_seed"
+        ]
+      },
+      "label": "RandomNoise — Per-shot noise seed"
+    },
+    {
+      "key": "n15",
+      "type": "MiniMaxH3ImageToVideo",
+      "settings": {
+        "prompt": "integrated_multimodal_description:\n[Shot 1] <Picture 1> aligns with 0.00 seconds and <Picture 2> aligns with the final target frame. Begin from the exact adult courier, mustard waterproof jacket, teal trousers, charcoal helmet, olive messenger bag, silver bicycle, parcel, glass entrance, wet paving, lighting, lens, and landscape composition in <Picture 1>. In one continuous shot he walks the bicycle through the doorway, turns toward the potting table, and places the parcel down. Progressively match the courier's final pose, bicycle position, parcel placement, warm greenhouse bulbs, plant geometry, reflections, and framing in <Picture 2>. Reach <Picture 2> only on the final frame; do not freeze early, cut, or introduce another person.\n\noverall_soundscape:\nRain on glass, tire roll, freewheel ticks, footsteps, door hinge, jacket rustle, and the parcel touching wood follow the visible action continuously.\n\nnon_diegetic_music:\nNo non-diegetic music.",
+        "width": 896,
+        "height": 672,
+        "length": 362
+      },
+      "inputs": {
+        "clip": [
+          "n2",
+          "CLIP"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "first_frame": [
+          "n37",
+          "first_frame"
+        ],
+        "last_frame": [
+          "n37",
+          "last_frame"
+        ],
+        "prompt": [
+          "n11",
+          "prompt"
+        ],
+        "width": [
+          "n11",
+          "width"
+        ],
+        "height": [
+          "n11",
+          "height"
+        ],
+        "length": [
+          "n11",
+          "length"
+        ]
+      },
+      "label": "MiniMax H3 Image to Video — CORE FL2VA — FIRST A ONCE + INDEXED LAST TARGET"
+    },
+    {
+      "key": "n16",
+      "type": "MiniMaxH3ChainContext",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n11",
+          "state"
+        ],
+        "conditioning": [
+          "n15",
+          "positive"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "latent": [
+          "n15",
+          "LATENT"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Context — AUTO CONTEXT — clip 1 bypass / continuation"
+    },
+    {
+      "key": "n17",
+      "type": "MiniMaxH3SigmaShift",
+      "settings": {
+        "shift_video": 12,
+        "shift_audio": 3
+      },
+      "inputs": {
+        "model": [
+          "n28",
+          "MODEL"
+        ]
+      }
+    },
+    {
+      "key": "n20",
+      "type": "BasicGuider",
+      "settings": {},
+      "inputs": {
+        "model": [
+          "n17",
+          "MODEL"
+        ],
+        "conditioning": [
+          "n16",
+          "conditioning"
+        ]
+      },
+      "label": "Basic Guider — Loop guider"
+    },
+    {
+      "key": "n21",
+      "type": "BasicScheduler",
+      "settings": {
+        "scheduler": "simple",
+        "steps": 20,
+        "denoise": 1
+      },
+      "inputs": {
+        "model": [
+          "n17",
+          "MODEL"
+        ],
+        "steps": [
+          "n11",
+          "steps"
+        ]
+      },
+      "label": "BasicScheduler — Per-shot scheduler steps"
+    },
+    {
+      "key": "n22",
+      "type": "SamplerCustomAdvanced",
+      "settings": {},
+      "inputs": {
+        "noise": [
+          "n14",
+          "NOISE"
+        ],
+        "guider": [
+          "n20",
+          "GUIDER"
+        ],
+        "sampler": [
+          "n3",
+          "SAMPLER"
+        ],
+        "sigmas": [
+          "n21",
+          "SIGMAS"
+        ],
+        "latent_image": [
+          "n16",
+          "latent"
+        ]
+      },
+      "label": "SamplerCustomAdvanced — H3 sampler — SINGLE LOOP BODY"
+    },
+    {
+      "key": "n23",
+      "type": "VAEDecode",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n22",
+          "output"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode — Decode current clip frames"
+    },
+    {
+      "key": "n24",
+      "type": "VAEDecodeAudio",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n22",
+          "output"
+        ],
+        "vae": [
+          "n5",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode Audio — Decode current clip audio"
+    },
+    {
+      "key": "n25",
+      "type": "MiniMaxH3LoopTrim",
+      "settings": {
+        "trim_frames": 0,
+        "fps": 24,
+        "match_tail": true,
+        "retain_overlap_frames": 0
+      },
+      "inputs": {
+        "images": [
+          "n23",
+          "IMAGE"
+        ],
+        "audio": [
+          "n24",
+          "AUDIO"
+        ],
+        "trim_frames": [
+          "n16",
+          "trim_frames"
+        ],
+        "state": [
+          "n11",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Trim — TRIM CONTEXT / AUTO-RESOLVE SCENE BLEND"
+    },
+    {
+      "key": "n26",
+      "type": "MiniMaxH3ChainSegmentSave",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n11",
+          "state"
+        ],
+        "images": [
+          "n25",
+          "images"
+        ],
+        "sampled_latent": [
+          "n22",
+          "output"
+        ],
+        "audio": [
+          "n25",
+          "audio"
+        ],
+        "images_with_overlap": [
+          "n25",
+          "images_with_overlap"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Segment + Checkpoint — SAVE DELIVERED + BLEND-READY SEGMENTS"
+    },
+    {
+      "key": "n27",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "t2v_normal_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n29",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — FINAL ASSEMBLY — 5-FRAME VISUAL BLEND"
+    },
+    {
+      "key": "n28",
+      "type": "ModelAttentionBackend",
+      "settings": {
+        "attention": "pytorch attention"
+      },
+      "inputs": {
+        "model": [
+          "n1",
+          "MODEL"
+        ]
+      },
+      "label": "ModelAttentionBackend — COMFY KITCHEN ATTENTION"
+    },
+    {
+      "key": "n29",
+      "type": "MiniMaxH3ChainLoopEnd",
+      "settings": {
+        "between_scene_cleanup": "off"
+      },
+      "inputs": {
+        "flow": [
+          "n35",
+          "flow"
+        ],
+        "state": [
+          "n11",
+          "state"
+        ],
+        "images": [
+          "n25",
+          "images"
+        ],
+        "sampled_latent": [
+          "n22",
+          "output"
+        ],
+        "segment": [
+          "n38",
+          "segment"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop End — LOOP END — ADVANCE T2V SCENE"
+    },
+    {
+      "key": "n30",
+      "type": "Note",
+      "settings": {
+        "text": "FL2VA PROMPT FORMAT\n\nEach three-section prompt identifies the opening and final target inside integrated_multimodal_description. The action converges on the target only at the final frame."
+      },
+      "inputs": {},
+      "label": "FL2VA PROMPT FORMAT"
+    },
+    {
+      "key": "n31",
+      "type": "MiniMaxH3ChainPlanModern",
+      "settings": {
+        "plan_json": "{\n  \"defaults\": {\n    \"steps\": 20\n  },\n  \"shots\": [\n    {\n      \"id\": \"arrival_to_delivery\",\n      \"prompt\": \"integrated_multimodal_description:\\n[Shot 1] <Picture 1> aligns with 0.00 seconds and <Picture 2> aligns with the final target frame. Begin from the exact adult courier, mustard waterproof jacket, teal trousers, charcoal helmet, olive messenger bag, silver bicycle, parcel, glass entrance, wet paving, lighting, lens, and landscape composition in <Picture 1>. In one continuous shot he walks the bicycle through the doorway, turns toward the potting table, and places the parcel down. Progressively match the courier's final pose, bicycle position, parcel placement, warm greenhouse bulbs, plant geometry, reflections, and framing in <Picture 2>. Reach <Picture 2> only on the final frame; do not freeze early, cut, or introduce another person.\\n\\noverall_soundscape:\\nRain on glass, tire roll, freewheel ticks, footsteps, door hinge, jacket rustle, and the parcel touching wood follow the visible action continuously.\\n\\nnon_diegetic_music:\\nNo non-diegetic music.\",\n      \"length\": 362,\n      \"steps\": 20,\n      \"seed\": \"6101\"\n    },\n    {\n      \"id\": \"delivery_to_arrival\",\n      \"prompt\": \"integrated_multimodal_description:\\n[Shot 1] Continue from the incoming greenhouse delivery context. The carried overlap already contains the completed parcel placement; begin new action only after it. The courier checks his bicycle, turns it smoothly toward the open door, and walks back onto the wet paving. Preserve his exact identity and wardrobe, the bicycle, greenhouse layout, parcel remaining on the table, camera height, and screen direction. During the final seconds, progressively align the doorway, exterior reflections, courier stance, bicycle position, and composition with <Picture 1>, reaching that picture only on the final frame without a cut or early hold.\\n\\noverall_soundscape:\\nContinue greenhouse room tone and rain, then add the bicycle freewheel, footsteps, door hinge, and brighter exterior rain as he exits.\\n\\nnon_diegetic_music:\\nNo non-diegetic music.\",\n      \"length\": 362,\n      \"steps\": 20,\n      \"seed\": \"6102\"\n    }\n  ]\n}",
+        "run_name": "fl2v_normal_minimax_h3_0_6_json",
+        "generation_fingerprint": "h3-v06-release-example",
+        "width": 896,
+        "height": 672,
+        "encode_mode": "video",
+        "crop": "disabled",
+        "default_duration_seconds": 15.0,
+        "default_steps": 20,
+        "base_seed": 0,
+        "segment_crf": 20,
+        "video_blend_frames": 0
+      },
+      "inputs": {
+        "chain_policy": [
+          "n43",
+          "chain_policy"
+        ]
+      },
+      "label": "MiniMax H3 Production Plan — 0.6 SCENE COLUMNS"
+    },
+    {
+      "key": "n32",
+      "type": "MiniMaxH3ChainManifestLoad",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n41",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Load Manifest — RECOVERY: LOAD ALL SAVED CLIPS",
+      "mode": 2
+    },
+    {
+      "key": "n33",
+      "type": "Note",
+      "settings": {
+        "text": "The two amber recovery nodes are MUTED by default.\n\nIf all segments finished but final assembly did not, mute the main green Assemble node, enable both recovery nodes, and queue. They validate every SHA-256 checkpoint pair and assemble without rerendering the completed clips.\n\nFor an interrupted generation, leave recovery muted and set Loop Start's start_clip to the first unfinished clip."
+      },
+      "inputs": {},
+      "label": "Note — RECOVERY / ASSEMBLE LATER"
+    },
+    {
+      "key": "n34",
+      "type": "LoadImage",
+      "settings": {
+        "image": "h3_v06_courier_greenhouse_delivery.png"
+      },
+      "inputs": {},
+      "label": "Load Image — 0.6 COURIER ARRIVAL"
+    },
+    {
+      "key": "n35",
+      "type": "MiniMaxH3ChainLoopStart",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true
+      },
+      "inputs": {
+        "plan": [
+          "n42",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Start — LOOP START / RESUME"
+    },
+    {
+      "key": "n36",
+      "type": "MiniMaxH3ChainFrameIndexSwitch",
+      "settings": {
+        "clip_index": 1
+      },
+      "inputs": {
+        "frame_1": [
+          "n34",
+          "IMAGE"
+        ],
+        "frame_2": [
+          "n39",
+          "IMAGE"
+        ],
+        "clip_index": [
+          "n11",
+          "clip_index"
+        ]
+      },
+      "label": "MiniMax H3 Frame Index Switch — LAST-FRAME INDEX — SCENE 1→B / SCENE 2→A"
+    },
+    {
+      "key": "n37",
+      "type": "MiniMaxH3ChainFirstSceneImage",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n11",
+          "state"
+        ],
+        "image": [
+          "n39",
+          "IMAGE"
+        ],
+        "last_frame": [
+          "n36",
+          "image"
+        ]
+      },
+      "label": "MiniMax H3 Frame Gate — FRAME GATE — FRAME A ONCE / SELECTED END TARGET"
+    },
+    {
+      "key": "n38",
+      "type": "MiniMaxH3ChainReview",
+      "settings": {
+        "enabled": true,
+        "play_notification_sound": false,
+        "auto_continue_timeout_minutes": 0,
+        "unload_models_while_waiting": false,
+        "assemble_partial_on_stop": true,
+        "partial_audio_source": "checkpointed",
+        "candidate_count": 1,
+        "review_each_candidate": false
+      },
+      "inputs": {
+        "state": [
+          "n11",
+          "state"
+        ],
+        "segment": [
+          "n26",
+          "segment"
+        ],
+        "audio": [
+          "n25",
+          "audio"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Review Gate — REVIEW GATE — APPROVE / EDIT+RETRY / REROLL / STOP"
+    },
+    {
+      "key": "n39",
+      "type": "LoadImage",
+      "settings": {
+        "image": "h3_v06_courier_greenhouse_arrival.png"
+      },
+      "inputs": {},
+      "label": "Load Image — 0.6 GREENHOUSE DELIVERY"
+    },
+    {
+      "key": "n40",
+      "type": "Note",
+      "settings": {
+        "text": "FL2V 0.6 QUICK START\n\nKeep delivery on Frame Index Switch frame_1 and arrival on frame_2. Frame Gate supplies arrival as scene 1's opening and alternates B→A end targets for the loop."
+      },
+      "inputs": {},
+      "label": "FL2V 0.6 QUICK START"
+    },
+    {
+      "key": "n41",
+      "type": "MiniMaxH3ChainScenePromptEditor",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n31",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Scene Prompt Editor — SCENE PROMPT EDITOR — STANDARD AUTHORING"
+    },
+    {
+      "key": "n42",
+      "type": "MiniMaxH3ChainPreflight",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true
+      },
+      "inputs": {
+        "plan": [
+          "n41",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Chain Preflight — 0.6 PREFLIGHT — BLOCKS BEFORE MODELS"
+    },
+    {
+      "key": "n43",
+      "type": "MiniMaxH3GenerationProfile",
+      "settings": {
+        "scene_continuity": "Visual continuity",
+        "audio_profile": "Generate audio"
+      },
+      "inputs": {},
+      "label": "MiniMax H3 Generation Profile — RELEASE DEFAULTS"
+    }
+  ]
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/I2V Normal - MiniMax H3 0.6.json b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/I2V Normal - MiniMax H3 0.6.json
new file mode 100644
index 0000000000000000000000000000000000000000..c4741c4ea8b83f8dacedb0e13e51400bcc60f5c2
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/I2V Normal - MiniMax H3 0.6.json	
@@ -0,0 +1,582 @@
+{
+  "nodes": [
+    {
+      "key": "n1",
+      "type": "UNETLoader",
+      "settings": {
+        "unet_name": "minimax_h3_fl2va_pruned_int8_convrot.safetensors",
+        "weight_dtype": "default"
+      },
+      "inputs": {},
+      "label": "Load Diffusion Model — H3 MODEL — REQUIRED"
+    },
+    {
+      "key": "n2",
+      "type": "CLIPLoader",
+      "settings": {
+        "clip_name": "qwen3vl_32b_minimax_h3_int8_convrot.safetensors",
+        "type": "minimax",
+        "device": "default"
+      },
+      "inputs": {},
+      "label": "Load CLIP — H3 TEXT ENCODER"
+    },
+    {
+      "key": "n3",
+      "type": "KSamplerSelect",
+      "settings": {
+        "sampler_name": "res_multistep"
+      },
+      "inputs": {},
+      "label": "KSamplerSelect — Sampler algorithm"
+    },
+    {
+      "key": "n4",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_video_vae_fp16.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Video VAE"
+    },
+    {
+      "key": "n5",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_audio_vae_fp32.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Audio VAE"
+    },
+    {
+      "key": "n6",
+      "type": "Note",
+      "settings": {
+        "text": "0.6 REFERENCE ASSET\n\nh3_v06_courier_greenhouse_arrival.png was generated specifically for this release catalog. Copy it from example_workflows/assets to ComfyUI/input before loading the workflow."
+      },
+      "inputs": {},
+      "label": "0.6 REFERENCE ASSET"
+    },
+    {
+      "key": "n7",
+      "type": "MiniMaxH3ChainScenePromptEditor",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n34",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Scene Prompt Editor — SCENE PROMPT EDITOR — STANDARD AUTHORING"
+    },
+    {
+      "key": "n8",
+      "type": "Note",
+      "settings": {
+        "text": "I2VA PROMPT FORMAT\n\nScene 1 declares <Picture 1> as the opening frame inside the three-section H3 prompt. Scene 2 relies on the incoming H3 Motion Context and begins new action only after the carried overlap."
+      },
+      "inputs": {},
+      "label": "I2VA PROMPT FORMAT"
+    },
+    {
+      "key": "n11",
+      "type": "MiniMaxH3ChainLoopStart",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true
+      },
+      "inputs": {
+        "plan": [
+          "n40",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Start — LOOP START / RESUME"
+    },
+    {
+      "key": "n14",
+      "type": "MiniMaxH3ChainCurrent",
+      "settings": {
+        "align_audio_reference": false
+      },
+      "inputs": {
+        "state": [
+          "n11",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Current Shot — CURRENT I2V SCENE — PROMPT / SEED / TIMING"
+    },
+    {
+      "key": "n15",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "t2v_normal_recovered_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n36",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — RECOVERY: ASSEMBLE WITHOUT RENDERING",
+      "mode": 2
+    },
+    {
+      "key": "n17",
+      "type": "RandomNoise",
+      "settings": {
+        "noise_seed": 0,
+        "control_after_generate": "fixed"
+      },
+      "inputs": {
+        "noise_seed": [
+          "n14",
+          "noise_seed"
+        ]
+      },
+      "label": "RandomNoise — Per-shot noise seed"
+    },
+    {
+      "key": "n18",
+      "type": "MiniMaxH3ImageToVideo",
+      "settings": {
+        "prompt": "integrated_multimodal_description:\n[Shot 1] At 0.00 seconds, <Picture 1> is fully referenced as the opening frame. Animate the exact adult bicycle courier, mustard-yellow waterproof jacket, dark teal trousers, charcoal helmet, olive messenger bag, silver bicycle, kraft parcel, glass greenhouse entrance, wet paving, overcast daylight, and photographic rendering shown in <Picture 1>. In one stable landscape shot, he walks the bicycle through the open doorway, checks the parcel, then turns his shoulders toward the workbench inside. Keep exactly one courier and one bicycle; preserve face, wardrobe, proportions, bicycle geometry, parcel size, lighting direction, and camera height. End while he is crossing the threshold so the motion can continue.\n\noverall_soundscape:\nLight rain beyond the glass, wet tire noise, a quiet freewheel tick, rubber soles, the metal door hinge, jacket rustle, and soft greenhouse room tone.\n\nnon_diegetic_music:\nNo non-diegetic music.",
+        "width": 896,
+        "height": 672,
+        "length": 362
+      },
+      "inputs": {
+        "clip": [
+          "n2",
+          "CLIP"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "first_frame": [
+          "n39",
+          "first_frame"
+        ],
+        "prompt": [
+          "n14",
+          "prompt"
+        ],
+        "width": [
+          "n14",
+          "width"
+        ],
+        "height": [
+          "n14",
+          "height"
+        ],
+        "length": [
+          "n14",
+          "length"
+        ]
+      },
+      "label": "MiniMax H3 Image to Video — CORE I2VA — IMAGE ONLY ON SCENE 1"
+    },
+    {
+      "key": "n19",
+      "type": "MiniMaxH3ChainContext",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n14",
+          "state"
+        ],
+        "conditioning": [
+          "n18",
+          "positive"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "latent": [
+          "n18",
+          "LATENT"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Context — AUTO CONTEXT — clip 1 bypass / continuation"
+    },
+    {
+      "key": "n20",
+      "type": "MiniMaxH3SigmaShift",
+      "settings": {
+        "shift_video": 12,
+        "shift_audio": 3
+      },
+      "inputs": {
+        "model": [
+          "n31",
+          "MODEL"
+        ]
+      }
+    },
+    {
+      "key": "n23",
+      "type": "BasicGuider",
+      "settings": {},
+      "inputs": {
+        "model": [
+          "n20",
+          "MODEL"
+        ],
+        "conditioning": [
+          "n19",
+          "conditioning"
+        ]
+      },
+      "label": "Basic Guider — Loop guider"
+    },
+    {
+      "key": "n24",
+      "type": "BasicScheduler",
+      "settings": {
+        "scheduler": "simple",
+        "steps": 20,
+        "denoise": 1
+      },
+      "inputs": {
+        "model": [
+          "n20",
+          "MODEL"
+        ],
+        "steps": [
+          "n14",
+          "steps"
+        ]
+      },
+      "label": "BasicScheduler — Per-shot scheduler steps"
+    },
+    {
+      "key": "n25",
+      "type": "SamplerCustomAdvanced",
+      "settings": {},
+      "inputs": {
+        "noise": [
+          "n17",
+          "NOISE"
+        ],
+        "guider": [
+          "n23",
+          "GUIDER"
+        ],
+        "sampler": [
+          "n3",
+          "SAMPLER"
+        ],
+        "sigmas": [
+          "n24",
+          "SIGMAS"
+        ],
+        "latent_image": [
+          "n19",
+          "latent"
+        ]
+      },
+      "label": "SamplerCustomAdvanced — H3 sampler — SINGLE LOOP BODY"
+    },
+    {
+      "key": "n26",
+      "type": "VAEDecode",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n25",
+          "output"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode — Decode current clip frames"
+    },
+    {
+      "key": "n27",
+      "type": "VAEDecodeAudio",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n25",
+          "output"
+        ],
+        "vae": [
+          "n5",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode Audio — Decode current clip audio"
+    },
+    {
+      "key": "n28",
+      "type": "MiniMaxH3LoopTrim",
+      "settings": {
+        "trim_frames": 0,
+        "fps": 24,
+        "match_tail": true,
+        "retain_overlap_frames": 0
+      },
+      "inputs": {
+        "images": [
+          "n26",
+          "IMAGE"
+        ],
+        "audio": [
+          "n27",
+          "AUDIO"
+        ],
+        "trim_frames": [
+          "n19",
+          "trim_frames"
+        ],
+        "state": [
+          "n14",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Trim — TRIM CONTEXT / AUTO-RESOLVE SCENE BLEND"
+    },
+    {
+      "key": "n29",
+      "type": "MiniMaxH3ChainSegmentSave",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n14",
+          "state"
+        ],
+        "images": [
+          "n28",
+          "images"
+        ],
+        "sampled_latent": [
+          "n25",
+          "output"
+        ],
+        "audio": [
+          "n28",
+          "audio"
+        ],
+        "images_with_overlap": [
+          "n28",
+          "images_with_overlap"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Segment + Checkpoint — SAVE DELIVERED + BLEND-READY SEGMENTS"
+    },
+    {
+      "key": "n30",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "t2v_normal_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n32",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — FINAL ASSEMBLY — 5-FRAME VISUAL BLEND"
+    },
+    {
+      "key": "n31",
+      "type": "ModelAttentionBackend",
+      "settings": {
+        "attention": "pytorch attention"
+      },
+      "inputs": {
+        "model": [
+          "n1",
+          "MODEL"
+        ]
+      },
+      "label": "ModelAttentionBackend — COMFY KITCHEN ATTENTION"
+    },
+    {
+      "key": "n32",
+      "type": "MiniMaxH3ChainLoopEnd",
+      "settings": {
+        "between_scene_cleanup": "off"
+      },
+      "inputs": {
+        "flow": [
+          "n11",
+          "flow"
+        ],
+        "state": [
+          "n14",
+          "state"
+        ],
+        "images": [
+          "n28",
+          "images"
+        ],
+        "sampled_latent": [
+          "n25",
+          "output"
+        ],
+        "segment": [
+          "n35",
+          "segment"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop End — LOOP END — ADVANCE T2V SCENE"
+    },
+    {
+      "key": "n33",
+      "type": "Note",
+      "settings": {
+        "text": "I2V 0.6 QUICK START\n\nSelect the courier arrival image and keep Frame Gate connected: it applies Picture 1 only to scene 1. Select installed H3 model/VAE files, edit the Plan, then queue."
+      },
+      "inputs": {},
+      "label": "I2V 0.6 QUICK START"
+    },
+    {
+      "key": "n34",
+      "type": "MiniMaxH3ChainPlanModern",
+      "settings": {
+        "plan_json": "{\n  \"defaults\": {\n    \"steps\": 20\n  },\n  \"shots\": [\n    {\n      \"id\": \"greenhouse_arrival\",\n      \"prompt\": \"integrated_multimodal_description:\\n[Shot 1] At 0.00 seconds, <Picture 1> is fully referenced as the opening frame. Animate the exact adult bicycle courier, mustard-yellow waterproof jacket, dark teal trousers, charcoal helmet, olive messenger bag, silver bicycle, kraft parcel, glass greenhouse entrance, wet paving, overcast daylight, and photographic rendering shown in <Picture 1>. In one stable landscape shot, he walks the bicycle through the open doorway, checks the parcel, then turns his shoulders toward the workbench inside. Keep exactly one courier and one bicycle; preserve face, wardrobe, proportions, bicycle geometry, parcel size, lighting direction, and camera height. End while he is crossing the threshold so the motion can continue.\\n\\noverall_soundscape:\\nLight rain beyond the glass, wet tire noise, a quiet freewheel tick, rubber soles, the metal door hinge, jacket rustle, and soft greenhouse room tone.\\n\\nnon_diegetic_music:\\nNo non-diegetic music.\",\n      \"length\": 362,\n      \"steps\": 20,\n      \"seed\": \"6101\"\n    },\n    {\n      \"id\": \"greenhouse_delivery\",\n      \"prompt\": \"integrated_multimodal_description:\\n[Shot 1] Continue directly from the incoming H3 Motion Context inside the same greenhouse. The carried opening overlap already contains the courier crossing the threshold; begin new action only after it. Preserve the same face, mustard jacket, teal trousers, helmet, olive bag, bicycle, parcel, glass architecture, plant layout, wet floor reflections, camera height, and direction of travel. He rolls the bicycle beside the wooden potting table, stops it with his left hand, and places the parcel on the dry corner of the table with his right hand. He briefly smiles at the completed delivery. No cut, no duplicate person or bicycle, and no motion reset.\\n\\noverall_soundscape:\\nContinue the rain-muted greenhouse ambience, freewheel tick, tire roll, footsteps, clothing movement, and a soft cardboard contact on wood without an acoustic restart.\\n\\nnon_diegetic_music:\\nNo non-diegetic music.\",\n      \"length\": 362,\n      \"steps\": 20,\n      \"seed\": \"6102\"\n    }\n  ]\n}",
+        "run_name": "i2v_normal_minimax_h3_0_6_json",
+        "generation_fingerprint": "h3-v06-release-example",
+        "width": 896,
+        "height": 672,
+        "encode_mode": "video",
+        "crop": "disabled",
+        "default_duration_seconds": 15.0,
+        "default_steps": 20,
+        "base_seed": 0,
+        "segment_crf": 20,
+        "video_blend_frames": 0
+      },
+      "inputs": {
+        "chain_policy": [
+          "n41",
+          "chain_policy"
+        ]
+      },
+      "label": "MiniMax H3 Production Plan — 0.6 SCENE COLUMNS"
+    },
+    {
+      "key": "n35",
+      "type": "MiniMaxH3ChainReview",
+      "settings": {
+        "enabled": true,
+        "play_notification_sound": false,
+        "auto_continue_timeout_minutes": 0,
+        "unload_models_while_waiting": false,
+        "assemble_partial_on_stop": true,
+        "partial_audio_source": "checkpointed",
+        "candidate_count": 1,
+        "review_each_candidate": false
+      },
+      "inputs": {
+        "state": [
+          "n14",
+          "state"
+        ],
+        "segment": [
+          "n29",
+          "segment"
+        ],
+        "audio": [
+          "n28",
+          "audio"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Review Gate — REVIEW GATE — APPROVE / EDIT+RETRY / REROLL / STOP"
+    },
+    {
+      "key": "n36",
+      "type": "MiniMaxH3ChainManifestLoad",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n7",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Load Manifest — RECOVERY: LOAD ALL SAVED CLIPS",
+      "mode": 2
+    },
+    {
+      "key": "n37",
+      "type": "Note",
+      "settings": {
+        "text": "The two amber recovery nodes are MUTED by default.\n\nIf all segments finished but final assembly did not, mute the main green Assemble node, enable both recovery nodes, and queue. They validate every SHA-256 checkpoint pair and assemble without rerendering the completed clips.\n\nFor an interrupted generation, leave recovery muted and set Loop Start's start_clip to the first unfinished clip."
+      },
+      "inputs": {},
+      "label": "Note — RECOVERY / ASSEMBLE LATER"
+    },
+    {
+      "key": "n38",
+      "type": "LoadImage",
+      "settings": {
+        "image": "h3_v06_courier_greenhouse_arrival.png"
+      },
+      "inputs": {},
+      "label": "Load Image — 0.6 COURIER ARRIVAL"
+    },
+    {
+      "key": "n39",
+      "type": "MiniMaxH3ChainFirstSceneImage",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n14",
+          "state"
+        ],
+        "image": [
+          "n38",
+          "IMAGE"
+        ]
+      },
+      "label": "MiniMax H3 Frame Gate — FRAME GATE — FIRST ONCE / INDEXED LAST TARGET"
+    },
+    {
+      "key": "n40",
+      "type": "MiniMaxH3ChainPreflight",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true
+      },
+      "inputs": {
+        "plan": [
+          "n7",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Chain Preflight — 0.6 PREFLIGHT — BLOCKS BEFORE MODELS"
+    },
+    {
+      "key": "n41",
+      "type": "MiniMaxH3GenerationProfile",
+      "settings": {
+        "scene_continuity": "Visual continuity",
+        "audio_profile": "Generate audio"
+      },
+      "inputs": {},
+      "label": "MiniMax H3 Generation Profile — RELEASE DEFAULTS"
+    }
+  ]
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/I2V Studio - MiniMax H3 0.6.json b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/I2V Studio - MiniMax H3 0.6.json
new file mode 100644
index 0000000000000000000000000000000000000000..3996eee4c9777bac0f997192d4ed33d39bf40cdd
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/I2V Studio - MiniMax H3 0.6.json	
@@ -0,0 +1,638 @@
+{
+  "nodes": [
+    {
+      "key": "n1",
+      "type": "UNETLoader",
+      "settings": {
+        "unet_name": "minimax_h3_fl2va_pruned_int8_convrot.safetensors",
+        "weight_dtype": "default"
+      },
+      "inputs": {},
+      "label": "Load Diffusion Model — H3 MODEL — REQUIRED"
+    },
+    {
+      "key": "n2",
+      "type": "CLIPLoader",
+      "settings": {
+        "clip_name": "qwen3vl_32b_minimax_h3_int8_convrot.safetensors",
+        "type": "minimax",
+        "device": "default"
+      },
+      "inputs": {},
+      "label": "Load CLIP — H3 TEXT ENCODER"
+    },
+    {
+      "key": "n3",
+      "type": "KSamplerSelect",
+      "settings": {
+        "sampler_name": "res_multistep"
+      },
+      "inputs": {},
+      "label": "KSamplerSelect — Sampler algorithm"
+    },
+    {
+      "key": "n4",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_video_vae_fp16.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Video VAE"
+    },
+    {
+      "key": "n5",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_audio_vae_fp32.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Audio VAE"
+    },
+    {
+      "key": "n6",
+      "type": "Note",
+      "settings": {
+        "text": "0.6 REFERENCE ASSET\n\nh3_v06_courier_greenhouse_arrival.png was generated specifically for this release catalog. Copy it from example_workflows/assets to ComfyUI/input before loading the workflow."
+      },
+      "inputs": {},
+      "label": "0.6 REFERENCE ASSET"
+    },
+    {
+      "key": "n7",
+      "type": "Note",
+      "settings": {
+        "text": "I2VA PROMPT FORMAT\n\nScene 1 declares <Picture 1> as the opening frame inside the three-section H3 prompt. Scene 2 relies on the incoming H3 Motion Context and begins new action only after the carried overlap."
+      },
+      "inputs": {},
+      "label": "I2VA PROMPT FORMAT"
+    },
+    {
+      "key": "n10",
+      "type": "MiniMaxH3ChainLoopStart",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true
+      },
+      "inputs": {
+        "plan": [
+          "n33",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Start — LOOP START / RESUME"
+    },
+    {
+      "key": "n13",
+      "type": "MiniMaxH3ChainCurrent",
+      "settings": {
+        "align_audio_reference": false
+      },
+      "inputs": {
+        "state": [
+          "n10",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Current Shot — CURRENT I2V SCENE — PROMPT / SEED / TIMING"
+    },
+    {
+      "key": "n14",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "t2v_studio_recovered_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n34",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — RECOVERY: ASSEMBLE WITHOUT RENDERING",
+      "mode": 2
+    },
+    {
+      "key": "n16",
+      "type": "RandomNoise",
+      "settings": {
+        "noise_seed": 0,
+        "control_after_generate": "fixed"
+      },
+      "inputs": {
+        "noise_seed": [
+          "n13",
+          "noise_seed"
+        ]
+      },
+      "label": "RandomNoise — Per-shot noise seed"
+    },
+    {
+      "key": "n17",
+      "type": "MiniMaxH3ImageToVideo",
+      "settings": {
+        "prompt": "integrated_multimodal_description:\n[Shot 1] At 0.00 seconds, <Picture 1> is fully referenced as the opening frame. Animate the exact adult bicycle courier, mustard-yellow waterproof jacket, dark teal trousers, charcoal helmet, olive messenger bag, silver bicycle, kraft parcel, glass greenhouse entrance, wet paving, overcast daylight, and photographic rendering shown in <Picture 1>. In one stable landscape shot, he walks the bicycle through the open doorway, checks the parcel, then turns his shoulders toward the workbench inside. Keep exactly one courier and one bicycle; preserve face, wardrobe, proportions, bicycle geometry, parcel size, lighting direction, and camera height. End while he is crossing the threshold so the motion can continue.\n\noverall_soundscape:\nLight rain beyond the glass, wet tire noise, a quiet freewheel tick, rubber soles, the metal door hinge, jacket rustle, and soft greenhouse room tone.\n\nnon_diegetic_music:\nNo non-diegetic music.",
+        "width": 896,
+        "height": 672,
+        "length": 362
+      },
+      "inputs": {
+        "clip": [
+          "n2",
+          "CLIP"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "first_frame": [
+          "n40",
+          "first_frame"
+        ],
+        "prompt": [
+          "n13",
+          "prompt"
+        ],
+        "width": [
+          "n13",
+          "width"
+        ],
+        "height": [
+          "n13",
+          "height"
+        ],
+        "length": [
+          "n13",
+          "length"
+        ]
+      },
+      "label": "MiniMax H3 Image to Video — CORE I2VA — IMAGE ONLY ON SCENE 1"
+    },
+    {
+      "key": "n18",
+      "type": "MiniMaxH3ChainContext",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n13",
+          "state"
+        ],
+        "conditioning": [
+          "n17",
+          "positive"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "latent": [
+          "n17",
+          "LATENT"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Context — AUTO CONTEXT — clip 1 bypass / continuation"
+    },
+    {
+      "key": "n19",
+      "type": "MiniMaxH3SigmaShift",
+      "settings": {
+        "shift_video": 12,
+        "shift_audio": 3
+      },
+      "inputs": {
+        "model": [
+          "n30",
+          "MODEL"
+        ]
+      }
+    },
+    {
+      "key": "n22",
+      "type": "BasicGuider",
+      "settings": {},
+      "inputs": {
+        "model": [
+          "n19",
+          "MODEL"
+        ],
+        "conditioning": [
+          "n18",
+          "conditioning"
+        ]
+      },
+      "label": "Basic Guider — Loop guider"
+    },
+    {
+      "key": "n23",
+      "type": "BasicScheduler",
+      "settings": {
+        "scheduler": "simple",
+        "steps": 20,
+        "denoise": 1
+      },
+      "inputs": {
+        "model": [
+          "n19",
+          "MODEL"
+        ],
+        "steps": [
+          "n13",
+          "steps"
+        ]
+      },
+      "label": "BasicScheduler — Per-shot scheduler steps"
+    },
+    {
+      "key": "n24",
+      "type": "SamplerCustomAdvanced",
+      "settings": {},
+      "inputs": {
+        "noise": [
+          "n16",
+          "NOISE"
+        ],
+        "guider": [
+          "n22",
+          "GUIDER"
+        ],
+        "sampler": [
+          "n3",
+          "SAMPLER"
+        ],
+        "sigmas": [
+          "n23",
+          "SIGMAS"
+        ],
+        "latent_image": [
+          "n18",
+          "latent"
+        ]
+      },
+      "label": "SamplerCustomAdvanced — H3 sampler — SINGLE LOOP BODY"
+    },
+    {
+      "key": "n25",
+      "type": "VAEDecode",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n24",
+          "output"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode — Decode current clip frames"
+    },
+    {
+      "key": "n26",
+      "type": "VAEDecodeAudio",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n24",
+          "output"
+        ],
+        "vae": [
+          "n5",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode Audio — Decode current clip audio"
+    },
+    {
+      "key": "n27",
+      "type": "MiniMaxH3LoopTrim",
+      "settings": {
+        "trim_frames": 0,
+        "fps": 24,
+        "match_tail": true,
+        "retain_overlap_frames": 5
+      },
+      "inputs": {
+        "images": [
+          "n25",
+          "IMAGE"
+        ],
+        "audio": [
+          "n26",
+          "AUDIO"
+        ],
+        "trim_frames": [
+          "n18",
+          "trim_frames"
+        ],
+        "state": [
+          "n13",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Trim — TRIM CONTEXT / AUTO-RESOLVE SCENE BLEND"
+    },
+    {
+      "key": "n28",
+      "type": "MiniMaxH3ChainSegmentSave",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n13",
+          "state"
+        ],
+        "images": [
+          "n27",
+          "images"
+        ],
+        "sampled_latent": [
+          "n24",
+          "output"
+        ],
+        "audio": [
+          "n27",
+          "audio"
+        ],
+        "images_with_overlap": [
+          "n27",
+          "images_with_overlap"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Segment + Checkpoint — SAVE DELIVERED + BLEND-READY SEGMENTS"
+    },
+    {
+      "key": "n29",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "t2v_studio_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n36",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — FINAL ASSEMBLY — 5-FRAME VISUAL BLEND"
+    },
+    {
+      "key": "n30",
+      "type": "ModelAttentionBackend",
+      "settings": {
+        "attention": "pytorch attention"
+      },
+      "inputs": {
+        "model": [
+          "n1",
+          "MODEL"
+        ]
+      },
+      "label": "ModelAttentionBackend — COMFY KITCHEN ATTENTION"
+    },
+    {
+      "key": "n31",
+      "type": "MiniMaxH3ChainRichScenePromptEditor",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n33",
+          "plan"
+        ]
+      }
+    },
+    {
+      "key": "n32",
+      "type": "MiniMaxH3ChainPlanModern",
+      "settings": {
+        "plan_json": "{\n  \"defaults\": {\n    \"steps\": 20\n  },\n  \"shots\": [\n    {\n      \"id\": \"greenhouse_arrival\",\n      \"prompt\": \"integrated_multimodal_description:\\n[Shot 1] At 0.00 seconds, <Picture 1> is fully referenced as the opening frame. Animate the exact adult bicycle courier, mustard-yellow waterproof jacket, dark teal trousers, charcoal helmet, olive messenger bag, silver bicycle, kraft parcel, glass greenhouse entrance, wet paving, overcast daylight, and photographic rendering shown in <Picture 1>. In one stable landscape shot, he walks the bicycle through the open doorway, checks the parcel, then turns his shoulders toward the workbench inside. Keep exactly one courier and one bicycle; preserve face, wardrobe, proportions, bicycle geometry, parcel size, lighting direction, and camera height. End while he is crossing the threshold so the motion can continue.\\n\\noverall_soundscape:\\nLight rain beyond the glass, wet tire noise, a quiet freewheel tick, rubber soles, the metal door hinge, jacket rustle, and soft greenhouse room tone.\\n\\nnon_diegetic_music:\\nNo non-diegetic music.\",\n      \"length\": 362,\n      \"steps\": 20,\n      \"seed\": \"6101\"\n    },\n    {\n      \"id\": \"greenhouse_delivery\",\n      \"prompt\": \"integrated_multimodal_description:\\n[Shot 1] Continue directly from the incoming H3 Motion Context inside the same greenhouse. The carried opening overlap already contains the courier crossing the threshold; begin new action only after it. Preserve the same face, mustard jacket, teal trousers, helmet, olive bag, bicycle, parcel, glass architecture, plant layout, wet floor reflections, camera height, and direction of travel. He rolls the bicycle beside the wooden potting table, stops it with his left hand, and places the parcel on the dry corner of the table with his right hand. He briefly smiles at the completed delivery. No cut, no duplicate person or bicycle, and no motion reset.\\n\\noverall_soundscape:\\nContinue the rain-muted greenhouse ambience, freewheel tick, tire roll, footsteps, clothing movement, and a soft cardboard contact on wood without an acoustic restart.\\n\\nnon_diegetic_music:\\nNo non-diegetic music.\",\n      \"length\": 362,\n      \"steps\": 20,\n      \"seed\": \"6102\"\n    }\n  ]\n}",
+        "run_name": "i2v_studio_minimax_h3_0_6_json",
+        "generation_fingerprint": "",
+        "width": 896,
+        "height": 672,
+        "encode_mode": "video",
+        "crop": "disabled",
+        "default_duration_seconds": 15.0,
+        "default_steps": 20,
+        "base_seed": 0,
+        "segment_crf": 20,
+        "video_blend_frames": 5
+      },
+      "inputs": {
+        "chain_policy": [
+          "n41",
+          "chain_policy"
+        ],
+        "project_assets": [
+          "n42",
+          "project_assets"
+        ]
+      },
+      "label": "MiniMax H3 Production Plan — 0.6 SCENE COLUMNS"
+    },
+    {
+      "key": "n33",
+      "type": "MiniMaxH3ChainPlanStudio",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true,
+        "plan_json": "{\n  \"shots\": [\n    {\n      \"id\": \"intro\",\n      \"prompt\": \"Describe the opening shot.\"\n    },\n    {\n      \"id\": \"continuation\",\n      \"prompt\": \"Continue the same take.\"\n    }\n  ]\n}",
+        "run_name": "h3_chain",
+        "generation_fingerprint": "",
+        "width": 960,
+        "height": 544,
+        "context_length": 22,
+        "encode_mode": "video",
+        "anchor_mode": "head",
+        "crop": "disabled",
+        "audio_mode": "generated_audio",
+        "audio_context_length": 22,
+        "default_duration_seconds": 15.0,
+        "default_steps": 20,
+        "base_seed": 0,
+        "segment_crf": 18,
+        "video_blend_frames": 0,
+        "continuation_mode": "guide",
+        "alternate_take_json": ""
+      },
+      "inputs": {
+        "plan": [
+          "n32",
+          "plan"
+        ],
+        "tagged_references": [
+          "n42",
+          "references"
+        ],
+        "project_assets": [
+          "n42",
+          "project_assets"
+        ]
+      },
+      "label": "MiniMax H3 Plan Studio — TIMELINE / TAKES / TRIMS"
+    },
+    {
+      "key": "n34",
+      "type": "MiniMaxH3ChainManifestLoad",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n33",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Load Manifest — RECOVERY: LOAD ALL SAVED CLIPS",
+      "mode": 2
+    },
+    {
+      "key": "n35",
+      "type": "Note",
+      "settings": {
+        "text": "The two amber recovery nodes are MUTED by default.\n\nIf all segments finished but final assembly did not, mute the main green Assemble node, enable both recovery nodes, and queue. They validate every SHA-256 checkpoint pair and assemble without rerendering the completed clips.\n\nFor an interrupted generation, leave recovery muted and set Loop Start's start_clip to the first unfinished clip."
+      },
+      "inputs": {},
+      "label": "Note — RECOVERY / ASSEMBLE LATER"
+    },
+    {
+      "key": "n36",
+      "type": "MiniMaxH3ChainLoopEnd",
+      "settings": {
+        "between_scene_cleanup": "off"
+      },
+      "inputs": {
+        "flow": [
+          "n10",
+          "flow"
+        ],
+        "state": [
+          "n13",
+          "state"
+        ],
+        "images": [
+          "n27",
+          "images"
+        ],
+        "sampled_latent": [
+          "n24",
+          "output"
+        ],
+        "segment": [
+          "n37",
+          "segment"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop End — LOOP END — ADVANCE T2V SCENE"
+    },
+    {
+      "key": "n37",
+      "type": "MiniMaxH3ChainReview",
+      "settings": {
+        "enabled": true,
+        "play_notification_sound": false,
+        "auto_continue_timeout_minutes": 0,
+        "unload_models_while_waiting": false,
+        "assemble_partial_on_stop": true,
+        "partial_audio_source": "checkpointed",
+        "candidate_count": 1,
+        "review_each_candidate": false
+      },
+      "inputs": {
+        "state": [
+          "n13",
+          "state"
+        ],
+        "segment": [
+          "n28",
+          "segment"
+        ],
+        "audio": [
+          "n27",
+          "audio"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Review Gate — REVIEW GATE — APPROVE / EDIT+RETRY / REROLL / STOP"
+    },
+    {
+      "key": "n38",
+      "type": "Note",
+      "settings": {
+        "text": "0.6 Studio quick start\n\n1. Open the Project Asset Carousel.\n2. Keep h3_v06_courier_greenhouse_arrival.png selected in the opening Load Image node.\n3. Use the Carousel for additional project references when needed.\n4. Edit scenes in Production Plan or Plan Studio.\n5. Queue; inspect, branch, trim, or restore in Checkpoint Manager."
+      },
+      "inputs": {},
+      "label": "0.6 STUDIO QUICK START"
+    },
+    {
+      "key": "n39",
+      "type": "LoadImage",
+      "settings": {
+        "image": "h3_v06_courier_greenhouse_arrival.png"
+      },
+      "inputs": {},
+      "label": "Load Image — 0.6 COURIER ARRIVAL"
+    },
+    {
+      "key": "n40",
+      "type": "MiniMaxH3ChainFirstSceneImage",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n13",
+          "state"
+        ],
+        "image": [
+          "n39",
+          "IMAGE"
+        ]
+      },
+      "label": "MiniMax H3 Frame Gate — FRAME GATE — FIRST ONCE / INDEXED LAST TARGET"
+    },
+    {
+      "key": "n41",
+      "type": "MiniMaxH3GenerationProfile",
+      "settings": {
+        "scene_continuity": "Visual continuity",
+        "audio_profile": "Generate audio"
+      },
+      "inputs": {},
+      "label": "MiniMax H3 Generation Profile — RELEASE DEFAULTS"
+    },
+    {
+      "key": "n42",
+      "type": "MiniMaxH3ProjectAssetManager",
+      "settings": {
+        "run_name": "i2v_studio_minimax_h3_0_6_json",
+        "catalog_json": "",
+        "semantic_anchor_size": "512",
+        "semantic_anchor_mode": "timestamped_video",
+        "operation_json": ""
+      },
+      "inputs": {},
+      "label": "MiniMax H3 Project Asset Carousel — IMPORT RELEASE REFERENCES"
+    },
+    {
+      "key": "n43",
+      "type": "MiniMaxH3ChainCheckpointManager",
+      "settings": {
+        "selection_json": ""
+      },
+      "inputs": {
+        "plan": [
+          "n33",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Checkpoint Manager — BRANCHES / PREVIEWS / RESTORE"
+    }
+  ]
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Masked AV Bridge - Two Clips - MiniMax H3 0.6.json b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Masked AV Bridge - Two Clips - MiniMax H3 0.6.json
new file mode 100644
index 0000000000000000000000000000000000000000..9f804c8ed4ea8dedde56349a14b22548b5eb7d6b
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Masked AV Bridge - Two Clips - MiniMax H3 0.6.json	
@@ -0,0 +1,456 @@
+{
+  "nodes": [
+    {
+      "key": "n1",
+      "type": "GetVideoComponents",
+      "settings": {},
+      "inputs": {
+        "video": [
+          "start_slice",
+          "VIDEO"
+        ]
+      }
+    },
+    {
+      "key": "n2",
+      "type": "GetVideoComponents",
+      "settings": {},
+      "inputs": {
+        "video": [
+          "end_slice",
+          "VIDEO"
+        ]
+      }
+    },
+    {
+      "key": "n3",
+      "type": "UNETLoader",
+      "settings": {
+        "unet_name": "minimax_h3_ref2va_pruned_int8_convrot.safetensors",
+        "weight_dtype": "default"
+      },
+      "inputs": {}
+    },
+    {
+      "key": "n4",
+      "type": "CLIPLoader",
+      "settings": {
+        "clip_name": "qwen3vl_32b_minimax_h3_int8_convrot.safetensors",
+        "type": "minimax",
+        "device": "default"
+      },
+      "inputs": {}
+    },
+    {
+      "key": "n5",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_video_vae_fp16.safetensors"
+      },
+      "inputs": {}
+    },
+    {
+      "key": "n6",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_audio_vae_fp32.safetensors"
+      },
+      "inputs": {}
+    },
+    {
+      "key": "n7",
+      "type": "MiniMaxH3SigmaShift",
+      "settings": {
+        "shift_video": 12,
+        "shift_audio": 3
+      },
+      "inputs": {
+        "model": [
+          "n3",
+          "MODEL"
+        ]
+      }
+    },
+    {
+      "key": "n8",
+      "type": "MiniMaxH3ImageToVideo",
+      "settings": {
+        "prompt": "integrated_multimodal_description:\n[Shot 1] Generate only the missing interval between the protected end of the first excerpt and the protected beginning of the second excerpt from the same continuous soldier-crab shot. Preserve the real light-blue soldier crabs, low sand-level camera, cloudy sky, distant shoreline, natural color, shallow depth of field, and documentary motion. Continue every visible crab from its incoming direction and gait. During the missing interval, the foreground group advances laterally across the damp sand while several crabs pass behind it at different depths. Keep the camera's existing low position and gentle drift physically continuous, avoid any cut, speed ramp, freeze, duplicated animal, or sudden composition change, and converge early enough that positions, focus, camera motion, lighting, and crab gait settle exactly into the protected second endpoint.\n\noverall_soundscape:\nContinue the same location recording through the missing interval: coastal wind, distant surf, faint water movement, and quiet crab-leg scratches. Match level, spatial character, and timing at both protected audio endpoints without adding speech or a discontinuity.\n\nnon_diegetic_music:\nN/A",
+        "width": 960,
+        "height": 544,
+        "length": 192
+      },
+      "inputs": {
+        "clip": [
+          "n4",
+          "CLIP"
+        ],
+        "vae": [
+          "n5",
+          "VAE"
+        ]
+      }
+    },
+    {
+      "key": "n9",
+      "type": "MiniMaxH3ContexMaskedAVBridge",
+      "settings": {
+        "start_fps": 24,
+        "end_fps": 24,
+        "preserve_frames": 39,
+        "crop": "center"
+      },
+      "inputs": {
+        "latent": [
+          "n8",
+          "LATENT"
+        ],
+        "vae": [
+          "n5",
+          "VAE"
+        ],
+        "audio_vae": [
+          "n6",
+          "VAE"
+        ],
+        "start_frames": [
+          "n1",
+          "images"
+        ],
+        "start_audio": [
+          "n1",
+          "audio"
+        ],
+        "end_frames": [
+          "n2",
+          "images"
+        ],
+        "end_audio": [
+          "n2",
+          "audio"
+        ]
+      },
+      "label": "MiniMax H3 Masking · Two-Clip AV Bridge — PROTECT 39F + GENERATE 114F + PROTECT 39F"
+    },
+    {
+      "key": "n10",
+      "type": "RandomNoise",
+      "settings": {
+        "noise_seed": 123456789,
+        "control_after_generate": "randomize"
+      },
+      "inputs": {}
+    },
+    {
+      "key": "n11",
+      "type": "BasicGuider",
+      "settings": {},
+      "inputs": {
+        "model": [
+          "n7",
+          "MODEL"
+        ],
+        "conditioning": [
+          "n8",
+          "positive"
+        ]
+      }
+    },
+    {
+      "key": "n12",
+      "type": "KSamplerSelect",
+      "settings": {
+        "sampler_name": "res_multistep"
+      },
+      "inputs": {}
+    },
+    {
+      "key": "n13",
+      "type": "BasicScheduler",
+      "settings": {
+        "scheduler": "simple",
+        "steps": 20,
+        "denoise": 1
+      },
+      "inputs": {
+        "model": [
+          "n7",
+          "MODEL"
+        ]
+      }
+    },
+    {
+      "key": "n14",
+      "type": "SamplerCustomAdvanced",
+      "settings": {},
+      "inputs": {
+        "noise": [
+          "n10",
+          "NOISE"
+        ],
+        "guider": [
+          "n11",
+          "GUIDER"
+        ],
+        "sampler": [
+          "n12",
+          "SAMPLER"
+        ],
+        "sigmas": [
+          "n13",
+          "SIGMAS"
+        ],
+        "latent_image": [
+          "n9",
+          "latent"
+        ]
+      }
+    },
+    {
+      "key": "n15",
+      "type": "VAEDecode",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n14",
+          "output"
+        ],
+        "vae": [
+          "n5",
+          "VAE"
+        ]
+      }
+    },
+    {
+      "key": "n16",
+      "type": "VAEDecodeAudio",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n14",
+          "output"
+        ],
+        "vae": [
+          "n6",
+          "VAE"
+        ]
+      }
+    },
+    {
+      "key": "n17",
+      "type": "TrimAudioDuration",
+      "settings": {
+        "start_index": 1.625,
+        "duration": 4.75
+      },
+      "inputs": {
+        "audio": [
+          "n16",
+          "AUDIO"
+        ]
+      }
+    },
+    {
+      "key": "n18",
+      "type": "AudioConcat",
+      "settings": {
+        "direction": "after"
+      },
+      "inputs": {
+        "audio1": [
+          "n1",
+          "audio"
+        ],
+        "audio2": [
+          "n17",
+          "AUDIO"
+        ]
+      }
+    },
+    {
+      "key": "n19",
+      "type": "AudioConcat",
+      "settings": {
+        "direction": "after"
+      },
+      "inputs": {
+        "audio1": [
+          "n18",
+          "AUDIO"
+        ],
+        "audio2": [
+          "n2",
+          "audio"
+        ]
+      }
+    },
+    {
+      "key": "n20",
+      "type": "ImageBatchExtendWithOverlap",
+      "settings": {
+        "overlap": 39,
+        "overlap_side": "source",
+        "overlap_mode": "linear_blend"
+      },
+      "inputs": {
+        "source_images": [
+          "n1",
+          "images"
+        ],
+        "new_images": [
+          "n15",
+          "IMAGE"
+        ]
+      }
+    },
+    {
+      "key": "n21",
+      "type": "ImageBatchExtendWithOverlap",
+      "settings": {
+        "overlap": 39,
+        "overlap_side": "source",
+        "overlap_mode": "linear_blend"
+      },
+      "inputs": {
+        "source_images": [
+          "n20",
+          "extended_images"
+        ],
+        "new_images": [
+          "n2",
+          "images"
+        ]
+      }
+    },
+    {
+      "key": "n22",
+      "type": "CreateVideo",
+      "settings": {
+        "fps": 24,
+        "bit_depth": "auto",
+        "color_space": "sRGB"
+      },
+      "inputs": {
+        "images": [
+          "n21",
+          "extended_images"
+        ],
+        "audio": [
+          "n19",
+          "AUDIO"
+        ]
+      }
+    },
+    {
+      "key": "n23",
+      "type": "SaveVideo",
+      "settings": {
+        "filename_prefix": "video/cc0_soldier_crabs_masked_AV_bridge",
+        "format": "auto",
+        "format.codec": "auto",
+        "codec": "auto"
+      },
+      "inputs": {
+        "video": [
+          "n22",
+          "VIDEO"
+        ]
+      }
+    },
+    {
+      "key": "n24",
+      "type": "Note",
+      "settings": {
+        "text": "CC0 TWO-CLIP BRIDGE DEMO\n\nCore Load Video feeds Reference Video Prepare, which converts the original 29.97-fps video to a 311-frame H3-safe 24-fps span with its matching source soundtrack. Resize the prepared source to the same canvas as Image / Keyframe Conditioning, then Create Video keeps these prepared frames and audio together without encoding.\n\nThe two Trim Video nodes select Source A at 0 seconds for 4.125 seconds (frames 0–98), and Source B at 8.875 seconds through the end (frames 213–310). Get Video Components supplies ordinary core AUDIO dictionaries. The bridge target remains 192 frames: 39 protected frames from Source A + 114 generated middle frames + 39 protected frames from Source B. Assembly removes both repeated protected windows, reconstructing a 311-frame timeline. This drops only the final two frames from the former 313-frame demo; the 114-frame gap is unchanged.\n\nIf changing the source intervals, also update the bridge target length and generated-middle audio trim to match the new gap. Keep the source resize and generation canvas identical, and leave Create Video at 24 fps.\n\nSOURCE: Light-blue soldier crabs on Bribie Island (2015), Watermark Resort Caloundra, CC0 1.0.\nhttps://commons.wikimedia.org/wiki/File:Light-blue_soldier_crabs_on_Bribie_Island.webm\n\nCopy soldier_crabs_bribie_island_cc0.webm from example_workflows/assets/ to ComfyUI/input/. This prompt does not reuse Crab Rave music, footage, choreography, or branding."
+      },
+      "inputs": {}
+    },
+    {
+      "key": "source_video",
+      "type": "LoadVideo",
+      "settings": {
+        "file": "soldier_crabs_bribie_island_cc0.webm"
+      },
+      "inputs": {}
+    },
+    {
+      "key": "prepared_source",
+      "type": "MiniMaxH3ReferenceVideoPrepare",
+      "settings": {
+        "length": 311,
+        "source_fps": 24
+      },
+      "inputs": {
+        "source_video": [
+          "source_video",
+          "VIDEO"
+        ]
+      }
+    },
+    {
+      "key": "source_canvas",
+      "type": "ImageScale",
+      "settings": {
+        "upscale_method": "bicubic",
+        "width": 960,
+        "height": 544,
+        "crop": "center"
+      },
+      "inputs": {
+        "image": [
+          "prepared_source",
+          "ref_video"
+        ]
+      }
+    },
+    {
+      "key": "prepared_video",
+      "type": "CreateVideo",
+      "settings": {
+        "fps": 24,
+        "bit_depth": "auto",
+        "color_space": "sRGB"
+      },
+      "inputs": {
+        "images": [
+          "source_canvas",
+          "IMAGE"
+        ],
+        "audio": [
+          "prepared_source",
+          "source_audio"
+        ]
+      }
+    },
+    {
+      "key": "start_slice",
+      "type": "Video Slice",
+      "settings": {
+        "start_time": 0,
+        "duration": 4.125,
+        "strict_duration": true
+      },
+      "inputs": {
+        "video": [
+          "prepared_video",
+          "VIDEO"
+        ]
+      }
+    },
+    {
+      "key": "end_slice",
+      "type": "Video Slice",
+      "settings": {
+        "start_time": 8.875,
+        "duration": 0,
+        "strict_duration": true
+      },
+      "inputs": {
+        "video": [
+          "prepared_video",
+          "VIDEO"
+        ]
+      }
+    }
+  ]
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Masked AV Extension - Chain + Reference Image - MiniMax H3 0.6.json b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Masked AV Extension - Chain + Reference Image - MiniMax H3 0.6.json
new file mode 100644
index 0000000000000000000000000000000000000000..5be4155ab80e5cd03aaede155a9863f696b4c751
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Masked AV Extension - Chain + Reference Image - MiniMax H3 0.6.json	
@@ -0,0 +1,686 @@
+{
+  "nodes": [
+    {
+      "key": "n1",
+      "type": "UNETLoader",
+      "settings": {
+        "unet_name": "minimax_h3_ref2va_pruned_int8_convrot.safetensors",
+        "weight_dtype": "default"
+      },
+      "inputs": {},
+      "label": "Load Diffusion Model — H3 MODEL — REQUIRED"
+    },
+    {
+      "key": "n2",
+      "type": "CLIPLoader",
+      "settings": {
+        "clip_name": "qwen3vl_32b_minimax_h3_int8_convrot.safetensors",
+        "type": "minimax",
+        "device": "default"
+      },
+      "inputs": {},
+      "label": "Load CLIP — H3 TEXT ENCODER"
+    },
+    {
+      "key": "n3",
+      "type": "KSamplerSelect",
+      "settings": {
+        "sampler_name": "res_multistep"
+      },
+      "inputs": {},
+      "label": "KSamplerSelect — Sampler algorithm"
+    },
+    {
+      "key": "n4",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_video_vae_fp16.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Video VAE"
+    },
+    {
+      "key": "n5",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_audio_vae_fp32.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Audio VAE"
+    },
+    {
+      "key": "n6",
+      "type": "Note",
+      "settings": {
+        "text": "REF2VA PROMPT FORMAT — SIX SECTIONS\n\n1. subject_definitions:\n2. summary:\n3. retention_analysis:\n4. detailed_description:\n5. overall_soundscape:\n6. non_diegetic_music:\n\nWrite stable @tags in the Plan. Tagged Ref2VA activates only registered @tags present in the resolved scene prompt and compiles them to native <Picture N> labels; it does not insert definitions for you."
+      },
+      "inputs": {},
+      "label": "Note — REF2VA SIX-SECTION PROMPT FORMAT"
+    },
+    {
+      "key": "n9",
+      "type": "MiniMaxH3ChainLoopStart",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true
+      },
+      "inputs": {
+        "plan": [
+          "n36",
+          "plan"
+        ],
+        "external_context": [
+          "n40",
+          "external_context"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Start — LOOP START / RESUME"
+    },
+    {
+      "key": "n12",
+      "type": "MiniMaxH3ChainCurrent",
+      "settings": {
+        "align_audio_reference": false
+      },
+      "inputs": {
+        "state": [
+          "n9",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Current Shot — CURRENT REF2V SCENE — PROMPT / SEED / TIMING"
+    },
+    {
+      "key": "n13",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "cc0_soldier_crabs_ref2va_extension_recovered_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n30",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — RECOVERY: ASSEMBLE WITHOUT RENDERING",
+      "mode": 2
+    },
+    {
+      "key": "n15",
+      "type": "RandomNoise",
+      "settings": {
+        "noise_seed": 0,
+        "control_after_generate": "fixed"
+      },
+      "inputs": {
+        "noise_seed": [
+          "n12",
+          "noise_seed"
+        ]
+      },
+      "label": "RandomNoise — Per-shot noise seed"
+    },
+    {
+      "key": "n16",
+      "type": "MiniMaxH3TaggedReferenceToVideo",
+      "settings": {
+        "clip_index": 1,
+        "clip_count": 2,
+        "prompt": "subject_definitions:\n@crabs is the reference image for <Subject 1>, defining the real light-blue soldier crabs, blue-grey carapaces, tan jointed legs, dark eye stalks, natural scale, damp beach sand, low camera height, cloudy coastal light, distant shoreline, and photographic wildlife-documentary realism.\n<Subject 1> is the same colony of light-blue soldier crabs established by @crabs and the incoming protected audiovisual prefix.\n\nsummary:\n[video continuation + reference generation] The target continues the imported soldier-crab footage as one uninterrupted low-angle documentary shot, using @crabs only to stabilize species appearance while the incoming protected prefix controls current pose, motion, camera, light, environment, and timing.\n\nretention_analysis:\n<Subject 1> (appears in [Shot 1]): fully_preserved - retain the colony's real anatomy, blue-grey shells, tan legs, eye stalks, scale variation, natural gait, and separation between individual crabs.\n@crabs: fully_preserved - retain its species appearance, sand-level viewpoint, cloudy coastal palette, shallow depth of field, and naturalistic photographic texture without pulling the moving crabs back to the still pose.\n\ndetailed_description:\n[Shot 1] Continue directly from the protected ending of the imported source video with no cut, reset, repeated action, or re-establishment. The same <Subject 1> crabs already crossing the damp sand complete their current steps at the same speed. The camera remains only a few centimeters above the beach and continues its gentle rightward drift. Foreground crabs pass close to the lens while smaller animals remain readable in the middle distance; preserve correct occlusion and never merge or duplicate bodies.\n\nThe densest part of the colony gradually turns toward a narrow reflective strip of wet sand. One foreground crab pauses, raises its carapace slightly, then sidesteps around another animal as the rest continue flowing behind it. A shallow ripple approaches from frame left, darkening the sand without becoming a dramatic wave. The crabs react independently with quick lateral adjustments, then resume their forward movement. Keep the shoreline buildings and heavy cloud layer stable in the distance. End with the camera and colony still moving right so the next extension inherits active motion rather than a held pose.\n\noverall_soundscape:\nContinue the source beach ambience without a seam: steady coastal wind, soft distant surf, faint water movement, and subtle leg clicks and sand scratches close to the microphone.\n\nnon_diegetic_music:\nN/A",
+        "width": 960,
+        "height": 544,
+        "length": 192,
+        "ref_image_size": "match",
+        "reference_policy": "strict",
+        "semantic_anchor_size": "512",
+        "semantic_anchor_mode": "timestamped_video",
+        "cache_for_upscale": true,
+        "conditioning_backend": "native_ref2va"
+      },
+      "inputs": {
+        "clip": [
+          "n2",
+          "CLIP"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "audio_vae": [
+          "n5",
+          "VAE"
+        ],
+        "references": [
+          "n42",
+          "references"
+        ],
+        "clip_index": [
+          "n12",
+          "clip_index"
+        ],
+        "clip_count": [
+          "n12",
+          "clip_count"
+        ],
+        "prompt": [
+          "n12",
+          "prompt"
+        ],
+        "width": [
+          "n12",
+          "width"
+        ],
+        "height": [
+          "n12",
+          "height"
+        ],
+        "length": [
+          "n12",
+          "length"
+        ]
+      },
+      "label": "MiniMax H3 Tagged Ref2VA — TAGGED REF2VA — @crabs + MASKED AV PREFIX"
+    },
+    {
+      "key": "n17",
+      "type": "MiniMaxH3ChainContext",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n12",
+          "state"
+        ],
+        "conditioning": [
+          "n16",
+          "positive"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "latent": [
+          "n16",
+          "latent"
+        ],
+        "audio_vae": [
+          "n5",
+          "VAE"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Context — MASKED AV CONTEXT — PRESERVE PREFIX / GENERATE FUTURE"
+    },
+    {
+      "key": "n18",
+      "type": "MiniMaxH3SigmaShift",
+      "settings": {
+        "shift_video": 12,
+        "shift_audio": 3
+      },
+      "inputs": {
+        "model": [
+          "n29",
+          "MODEL"
+        ]
+      }
+    },
+    {
+      "key": "n21",
+      "type": "BasicGuider",
+      "settings": {},
+      "inputs": {
+        "model": [
+          "n18",
+          "MODEL"
+        ],
+        "conditioning": [
+          "n17",
+          "conditioning"
+        ]
+      },
+      "label": "Basic Guider — Loop guider"
+    },
+    {
+      "key": "n22",
+      "type": "BasicScheduler",
+      "settings": {
+        "scheduler": "simple",
+        "steps": 20,
+        "denoise": 1
+      },
+      "inputs": {
+        "model": [
+          "n18",
+          "MODEL"
+        ],
+        "steps": [
+          "n12",
+          "steps"
+        ]
+      },
+      "label": "BasicScheduler — Per-shot scheduler steps"
+    },
+    {
+      "key": "n23",
+      "type": "SamplerCustomAdvanced",
+      "settings": {},
+      "inputs": {
+        "noise": [
+          "n15",
+          "NOISE"
+        ],
+        "guider": [
+          "n21",
+          "GUIDER"
+        ],
+        "sampler": [
+          "n3",
+          "SAMPLER"
+        ],
+        "sigmas": [
+          "n22",
+          "SIGMAS"
+        ],
+        "latent_image": [
+          "n17",
+          "latent"
+        ]
+      },
+      "label": "SamplerCustomAdvanced — H3 sampler — SINGLE LOOP BODY"
+    },
+    {
+      "key": "n24",
+      "type": "VAEDecode",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n23",
+          "output"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode — Decode current clip frames"
+    },
+    {
+      "key": "n25",
+      "type": "VAEDecodeAudio",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n23",
+          "output"
+        ],
+        "vae": [
+          "n5",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode Audio — Decode current clip audio"
+    },
+    {
+      "key": "n26",
+      "type": "MiniMaxH3LoopTrim",
+      "settings": {
+        "trim_frames": 0,
+        "fps": 24,
+        "match_tail": true,
+        "retain_overlap_frames": 39
+      },
+      "inputs": {
+        "images": [
+          "n24",
+          "IMAGE"
+        ],
+        "audio": [
+          "n25",
+          "AUDIO"
+        ],
+        "trim_frames": [
+          "n17",
+          "trim_frames"
+        ],
+        "state": [
+          "n12",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Trim — TRIM CONTEXT / AUTO-RESOLVE SCENE BLEND"
+    },
+    {
+      "key": "n27",
+      "type": "MiniMaxH3ChainSegmentSave",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n12",
+          "state"
+        ],
+        "images": [
+          "n26",
+          "images"
+        ],
+        "sampled_latent": [
+          "n23",
+          "output"
+        ],
+        "audio": [
+          "n26",
+          "audio"
+        ],
+        "images_with_overlap": [
+          "n26",
+          "images_with_overlap"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Segment + Checkpoint — SAVE DELIVERED + BLEND-READY SEGMENTS"
+    },
+    {
+      "key": "n28",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "cc0_soldier_crabs_ref2va_extension_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n34",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — FINAL ASSEMBLY — 5-FRAME VISUAL BLEND"
+    },
+    {
+      "key": "n29",
+      "type": "ModelAttentionBackend",
+      "settings": {
+        "attention": "pytorch attention"
+      },
+      "inputs": {
+        "model": [
+          "n1",
+          "MODEL"
+        ]
+      },
+      "label": "ModelAttentionBackend — COMFY KITCHEN ATTENTION"
+    },
+    {
+      "key": "n30",
+      "type": "MiniMaxH3ChainManifestLoad",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n36",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Load Manifest — RECOVERY: LOAD ALL SAVED CLIPS",
+      "mode": 2
+    },
+    {
+      "key": "n31",
+      "type": "Note",
+      "settings": {
+        "text": "The two amber recovery nodes are MUTED by default.\n\nIf all segments finished but final assembly did not, mute the main green Assemble node, enable both recovery nodes, and queue. They validate every SHA-256 checkpoint pair and assemble without rerendering the completed clips.\n\nFor an interrupted generation, leave recovery muted and set Loop Start's start_clip to the first unfinished clip."
+      },
+      "inputs": {},
+      "label": "Note — RECOVERY / ASSEMBLE LATER"
+    },
+    {
+      "key": "n32",
+      "type": "Note",
+      "settings": {
+        "text": "SOFT AV EXTENSION — THREE-SCENE LOOP + REFERENCE IMAGE\n\nThe source video's last 39 frames/65 audio steps protect scene 1. Soft AV keeps each picture prefix hard while releasing only the final eight audio ticks with a half-cosine feather. Each accepted generated scene then supplies the protected prefix for the next loop iteration. @crabs is active in all three prompts only as identity/appearance guidance; the incoming latent prefix remains authoritative for pose, motion, camera, light, and audio timing. Loop Trim retains all 39 repeated visual frames for linear seam blending, and the original source is prepended once during final assembly."
+      },
+      "inputs": {},
+      "label": "Note — REF2V STUDIO TAGGED — HOW TO USE"
+    },
+    {
+      "key": "n33",
+      "type": "MiniMaxH3ChainReview",
+      "settings": {
+        "enabled": true,
+        "play_notification_sound": false,
+        "auto_continue_timeout_minutes": 0,
+        "unload_models_while_waiting": false,
+        "assemble_partial_on_stop": true,
+        "partial_audio_source": "checkpointed",
+        "candidate_count": 1,
+        "review_each_candidate": false
+      },
+      "inputs": {
+        "state": [
+          "n12",
+          "state"
+        ],
+        "segment": [
+          "n27",
+          "segment"
+        ],
+        "audio": [
+          "n26",
+          "audio"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Review Gate — REVIEW GATE — APPROVE / EDIT+RETRY / REROLL / STOP"
+    },
+    {
+      "key": "n34",
+      "type": "MiniMaxH3ChainLoopEnd",
+      "settings": {
+        "between_scene_cleanup": "off"
+      },
+      "inputs": {
+        "flow": [
+          "n9",
+          "flow"
+        ],
+        "state": [
+          "n12",
+          "state"
+        ],
+        "images": [
+          "n26",
+          "images"
+        ],
+        "sampled_latent": [
+          "n23",
+          "output"
+        ],
+        "segment": [
+          "n33",
+          "segment"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop End — LOOP END — ADVANCE REF2V SCENE"
+    },
+    {
+      "key": "n35",
+      "type": "Note",
+      "settings": {
+        "text": "SOURCE ASSETS — CC0\n\nThe bundled 2015 soldier-crab WebM is CC0 1.0, as recorded by Wikimedia Commons. The PNG is one frame extracted from that same CC0 video.\n\nhttps://commons.wikimedia.org/wiki/File:Light-blue_soldier_crabs_on_Bribie_Island.webm\n\nCopy both soldier_crabs_bribie_island_cc0.webm and soldier_crabs_reference_cc0.png from example_workflows/assets/ to ComfyUI/input/. Prompts are original and do not reuse Crab Rave."
+      },
+      "inputs": {},
+      "label": "Note — REF2V PROMPT / IMAGE SOURCE"
+    },
+    {
+      "key": "n36",
+      "type": "MiniMaxH3ChainPlanStudio",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true,
+        "plan_json": "{\n  \"shots\": [\n    {\n      \"id\": \"intro\",\n      \"prompt\": \"Describe the opening shot.\"\n    },\n    {\n      \"id\": \"continuation\",\n      \"prompt\": \"Continue the same take.\"\n    }\n  ]\n}",
+        "run_name": "h3_chain",
+        "generation_fingerprint": "",
+        "width": 960,
+        "height": 544,
+        "context_length": 22,
+        "encode_mode": "video",
+        "anchor_mode": "head",
+        "crop": "disabled",
+        "audio_mode": "generated_audio",
+        "audio_context_length": 22,
+        "default_duration_seconds": 15.0,
+        "default_steps": 20,
+        "base_seed": 0,
+        "segment_crf": 18,
+        "video_blend_frames": 0,
+        "continuation_mode": "guide",
+        "alternate_take_json": ""
+      },
+      "inputs": {
+        "plan": [
+          "n38",
+          "plan"
+        ],
+        "tagged_references": [
+          "n42",
+          "references"
+        ],
+        "project_assets": [
+          "n42",
+          "project_assets"
+        ]
+      },
+      "label": "MiniMax H3 Plan Studio — TIMELINE / TAKES / TRIMS"
+    },
+    {
+      "key": "n37",
+      "type": "MiniMaxH3ChainRichScenePromptEditor",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n36",
+          "plan"
+        ]
+      }
+    },
+    {
+      "key": "n38",
+      "type": "MiniMaxH3ChainPlanModern",
+      "settings": {
+        "plan_json": "{\n  \"prompt_prefix\": \"\",\n  \"shots\": [\n    {\n      \"id\": \"tidal_edge\",\n      \"prompt\": \"subject_definitions:\\n@crabs is the reference image for <Subject 1>, defining the real light-blue soldier crabs, blue-grey carapaces, tan jointed legs, dark eye stalks, natural scale, damp beach sand, low camera height, cloudy coastal light, distant shoreline, and photographic wildlife-documentary realism.\\n<Subject 1> is the same colony of light-blue soldier crabs established by @crabs and the incoming protected audiovisual prefix.\\n\\nsummary:\\n[video continuation + reference generation] The target continues the imported soldier-crab footage as one uninterrupted low-angle documentary shot, using @crabs only to stabilize species appearance while the incoming protected prefix controls current pose, motion, camera, light, environment, and timing.\\n\\nretention_analysis:\\n<Subject 1> (appears in [Shot 1]): fully_preserved - retain the colony's real anatomy, blue-grey shells, tan legs, eye stalks, scale variation, natural gait, and separation between individual crabs.\\n@crabs: fully_preserved - retain its species appearance, sand-level viewpoint, cloudy coastal palette, shallow depth of field, and naturalistic photographic texture without pulling the moving crabs back to the still pose.\\n\\ndetailed_description:\\n[Shot 1] Continue directly from the protected ending of the imported source video with no cut, reset, repeated action, or re-establishment. The same <Subject 1> crabs already crossing the damp sand complete their current steps at the same speed. The camera remains only a few centimeters above the beach and continues its gentle rightward drift. Foreground crabs pass close to the lens while smaller animals remain readable in the middle distance; preserve correct occlusion and never merge or duplicate bodies.\\n\\nThe densest part of the colony gradually turns toward a narrow reflective strip of wet sand. One foreground crab pauses, raises its carapace slightly, then sidesteps around another animal as the rest continue flowing behind it. A shallow ripple approaches from frame left, darkening the sand without becoming a dramatic wave. The crabs react independently with quick lateral adjustments, then resume their forward movement. Keep the shoreline buildings and heavy cloud layer stable in the distance. End with the camera and colony still moving right so the next extension inherits active motion rather than a held pose.\\n\\noverall_soundscape:\\nContinue the source beach ambience without a seam: steady coastal wind, soft distant surf, faint water movement, and subtle leg clicks and sand scratches close to the microphone.\\n\\nnon_diegetic_music:\\nN/A\",\n      \"length\": 192,\n      \"steps\": 20,\n      \"seed\": \"24051511\"\n    },\n    {\n      \"id\": \"channel_crossing\",\n      \"prompt\": \"subject_definitions:\\n@crabs is the continuity image for <Subject 1>, preserving the real light-blue soldier-crab anatomy, blue-grey shells, tan legs, eye stalks, natural scale, damp sand, low wildlife-camera viewpoint, cloudy coastal light, and documentary texture.\\n<Subject 1> is the same moving colony inherited from the protected audiovisual prefix and stabilized by @crabs.\\n\\nsummary:\\n[video continuation + reference generation] The uninterrupted sand-level shot follows <Subject 1> as the colony reorganizes around a shallow tidal channel while retaining the incoming movement and sound.\\n\\nretention_analysis:\\n<Subject 1> (appears in [Shot 1]): fully_preserved - preserve identity as a natural colony, correct crab anatomy, individual trajectories, gait phase, scale, and spatial separation across the continuation.\\n@crabs: fully_preserved - preserve species detail, beach palette, natural lens character, and low composition without copying its static arrangement.\\n\\ndetailed_description:\\n[Shot 1] Continue the exact motion already in progress from the protected H3 prefix. Do not restart the crabs from rest or reset the camera. The low camera keeps drifting right as <Subject 1> reaches the reflective tidal strip established at the end of the previous scene. The leading crabs descend the slight sand lip one by one, their legs touching the thin water layer and making small circular ripples. Animals behind them fan into two natural streams around a raised patch of sand.\\n\\nThe camera makes a slow, shallow push forward while maintaining its sand-level height. Focus transfers gradually from one large foreground crab to the moving cluster beyond it; the foreground animal crosses out of frame rather than vanishing. A breeze presses faint patterns into the shallow water. Several crabs briefly align in lateral motion, then separate naturally as they climb the opposite lip. Preserve the distant buildings, cloud direction, soft daylight, and realistic motion blur. End while the rear group is still entering the water and the leading group is climbing, leaving both near and far motion available to the next extension.\\n\\noverall_soundscape:\\nCarry the same wind and surf continuously. Add only synchronized delicate water taps, tiny splashes, shell clicks, and wet sand scratches caused by the visible crossing.\\n\\nnon_diegetic_music:\\nN/A\",\n      \"length\": 192,\n      \"steps\": 20,\n      \"seed\": \"24051512\"\n    },\n    {\n      \"id\": \"firm_sand\",\n      \"prompt\": \"subject_definitions:\\n@crabs is the continuity image for <Subject 1>, defining the real soldier-crab species, blue-grey shells, tan articulated legs, dark eye stalks, beach scale, cloudy natural light, low camera placement, and wildlife-documentary realism.\\n<Subject 1> is the same colony continuing from the protected audiovisual prefix, with no replacement animals or stylized redesign.\\n\\nsummary:\\n[video continuation + reference generation] The continuous documentary shot completes the tidal crossing and follows <Subject 1> onto firm sand, where their lateral paths form a brief natural visual rhythm before dispersing.\\n\\nretention_analysis:\\n<Subject 1> (appears in [Shot 1]): fully_preserved - retain correct anatomy, shell color, gait, individual continuity, scale, and non-anthropomorphic behavior.\\n@crabs: fully_preserved - retain the source species, beach environment, cloudy palette, shallow focus, and photographic realism while allowing new movement.\\n\\ndetailed_description:\\n[Shot 1] Continue immediately from the protected prefix with the leading <Subject 1> crabs already climbing out of the shallow tidal strip and the rear group still crossing. Preserve every visible action phase, the low rightward camera drift, focus distance, light direction, shoreline geography, and damp-sand texture. The camera eases backward slightly to reveal a broader section of the colony without jumping or cutting.\\n\\nAs the crabs reach firmer sand, several parallel paths create a short wave of coordinated lateral movement across the frame. The rhythm remains entirely natural: no upright dancing, human gestures, impossible jumps, or synchronized cloning. One large crab passes close to the lens, briefly filling the lower-right foreground before revealing dozens of smaller moving silhouettes behind it. Wind ruffles a thin film of water and a brighter break in the clouds gives the shells a restrained blue sheen. The colony gradually disperses across the beach while the camera slows but does not freeze. End on a stable wide low-angle composition with multiple crabs still moving and the original beach ambience intact.\\n\\noverall_soundscape:\\nContinue the coastal wind, distant surf, shallow-water movement, small shell clicks, and layered sand scratches at consistent level and perspective. No speech or abrupt synthetic sound.\\n\\nnon_diegetic_music:\\nN/A\",\n      \"length\": 192,\n      \"steps\": 20,\n      \"seed\": \"24051513\"\n    }\n  ]\n}",
+        "run_name": "masked_av_extension_chain_reference_image_minimax_h3_0_6_json",
+        "generation_fingerprint": "h3-v06-release-example",
+        "width": 960,
+        "height": 544,
+        "encode_mode": "video",
+        "crop": "disabled",
+        "default_duration_seconds": 8.0,
+        "default_steps": 20,
+        "base_seed": 0,
+        "segment_crf": 20,
+        "video_blend_frames": 39
+      },
+      "inputs": {
+        "chain_policy": [
+          "n41",
+          "chain_policy"
+        ],
+        "project_assets": [
+          "n42",
+          "project_assets"
+        ]
+      },
+      "label": "MiniMax H3 Production Plan — 0.6 SCENE COLUMNS"
+    },
+    {
+      "key": "n39",
+      "type": "LoadVideo",
+      "settings": {
+        "file": "soldier_crabs_bribie_island_cc0.webm"
+      },
+      "inputs": {},
+      "label": "Source Video"
+    },
+    {
+      "key": "n40",
+      "type": "MiniMaxH3ChainExternalVideo",
+      "settings": {
+        "source_fps": 24,
+        "prepend_original": true
+      },
+      "inputs": {
+        "plan": [
+          "n36",
+          "plan"
+        ],
+        "source_video": [
+          "n39",
+          "VIDEO"
+        ]
+      },
+      "label": "MiniMax H3 Existing Video Context — CC0 SOURCE VIDEO → MASKED SCENE 1 PREFIX"
+    },
+    {
+      "key": "n41",
+      "type": "MiniMaxH3GenerationProfile",
+      "settings": {
+        "scene_continuity": "Hard picture + smooth audio",
+        "audio_profile": "Generate audio"
+      },
+      "inputs": {},
+      "label": "MiniMax H3 Generation Profile — RELEASE DEFAULTS"
+    },
+    {
+      "key": "n42",
+      "type": "MiniMaxH3ProjectAssetManager",
+      "settings": {
+        "run_name": "masked_av_extension_chain_reference_image_minimax_h3_0_6_json",
+        "catalog_json": "",
+        "semantic_anchor_size": "512",
+        "semantic_anchor_mode": "timestamped_video",
+        "operation_json": ""
+      },
+      "inputs": {},
+      "label": "MiniMax H3 Project Asset Carousel — IMPORT RELEASE REFERENCES"
+    },
+    {
+      "key": "n43",
+      "type": "MiniMaxH3ChainCheckpointManager",
+      "settings": {
+        "selection_json": ""
+      },
+      "inputs": {
+        "plan": [
+          "n36",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Checkpoint Manager — BRANCHES / PREVIEWS / RESTORE"
+    },
+    {
+      "key": "n44",
+      "type": "Note",
+      "settings": {
+        "text": "0.6 Studio quick start\n\n1. Open the Project Asset Carousel.\n2. Import soldier_crabs_reference_cc0.png; tag crabs (Picture).\n3. Edit scenes in Production Plan or Plan Studio.\n4. Queue; inspect, branch, trim, or restore in Checkpoint Manager."
+      },
+      "inputs": {},
+      "label": "0.6 STUDIO QUICK START"
+    },
+    {
+      "key": "native_video_note",
+      "type": "Note",
+      "settings": {
+        "text": "NATIVE SOURCE VIDEO\n\nCore Load Video connects directly to Existing Video Context's source_video input. The node reads embedded audio and the actual video frame rate, fits the source to the Plan canvas, and prepares the protected tail. There is no VHS frame cap or manual FPS conversion. Leave source_frames and source_audio disconnected unless intentionally switching to the separate IMAGE/AUDIO route or overriding the soundtrack."
+      },
+      "inputs": {}
+    }
+  ]
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Masked AV Extension - Single Clip - MiniMax H3 0.6.json b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Masked AV Extension - Single Clip - MiniMax H3 0.6.json
new file mode 100644
index 0000000000000000000000000000000000000000..b1c4fc15441ea90b7d11e31d5f44bde38df30f6d
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Masked AV Extension - Single Clip - MiniMax H3 0.6.json	
@@ -0,0 +1,662 @@
+{
+  "nodes": [
+    {
+      "key": "n1",
+      "type": "UNETLoader",
+      "settings": {
+        "unet_name": "minimax_h3_fl2va_pruned_int8_convrot.safetensors",
+        "weight_dtype": "default"
+      },
+      "inputs": {},
+      "label": "Load Diffusion Model — H3 MODEL — REQUIRED"
+    },
+    {
+      "key": "n2",
+      "type": "CLIPLoader",
+      "settings": {
+        "clip_name": "qwen3vl_32b_minimax_h3_int8_convrot.safetensors",
+        "type": "minimax",
+        "device": "default"
+      },
+      "inputs": {},
+      "label": "Load CLIP — H3 TEXT ENCODER"
+    },
+    {
+      "key": "n3",
+      "type": "KSamplerSelect",
+      "settings": {
+        "sampler_name": "res_multistep"
+      },
+      "inputs": {},
+      "label": "KSamplerSelect — Sampler algorithm"
+    },
+    {
+      "key": "n4",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_video_vae_fp16.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Video VAE"
+    },
+    {
+      "key": "n5",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_audio_vae_fp32.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Audio VAE"
+    },
+    {
+      "key": "n6",
+      "type": "Note",
+      "settings": {
+        "text": "SOURCE ASSET — CC0\n\nLight-blue soldier crabs on Bribie Island, filmed in 2015 by Watermark Resort Caloundra. Wikimedia Commons records the video as CC0 1.0.\n\nhttps://commons.wikimedia.org/wiki/File:Light-blue_soldier_crabs_on_Bribie_Island.webm\n\nCopy soldier_crabs_bribie_island_cc0.webm from example_workflows/assets/ to ComfyUI/input/. The prompt and generated continuation are original repository example material; they do not reuse Crab Rave music, video, choreography, or branding."
+      },
+      "inputs": {},
+      "label": "Note — PROMPT SOURCE / ATTRIBUTION"
+    },
+    {
+      "key": "n7",
+      "type": "Note",
+      "settings": {
+        "text": "T2VA PROMPT FORMAT\n\nT2VA begins directly with these three fields in this exact order—there is no Picture alignment instruction:\n\nintegrated_multimodal_description: [Shot 1] Describe visible style, composition, subjects, actions, camera movement, dialogue, and synchronized diegetic events.\n\noverall_soundscape: Summarize ambience, physical sounds, and non-verbal human sounds.\n\nnon_diegetic_music: Describe audience-only music, or use N/A.\n\nFor a chained continuation, explicitly continue the incoming pose, action phase, camera position and motion, lighting, environment, object states, ambience, and speaker identity. Do not re-establish or reset the shot unless a cut is intentional."
+      },
+      "inputs": {},
+      "label": "Note — T2VA PROMPT FORMAT"
+    },
+    {
+      "key": "n10",
+      "type": "MiniMaxH3ChainLoopStart",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true
+      },
+      "inputs": {
+        "plan": [
+          "n33",
+          "plan"
+        ],
+        "external_context": [
+          "n40",
+          "external_context"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Start — LOOP START / RESUME"
+    },
+    {
+      "key": "n13",
+      "type": "MiniMaxH3ChainCurrent",
+      "settings": {
+        "align_audio_reference": false
+      },
+      "inputs": {
+        "state": [
+          "n10",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Current Shot — CURRENT T2V SCENE — PROMPT / SEED / TIMING"
+    },
+    {
+      "key": "n14",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "cc0_soldier_crabs_single_extension_recovered_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n34",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — RECOVERY: ASSEMBLE WITHOUT RENDERING",
+      "mode": 2
+    },
+    {
+      "key": "n16",
+      "type": "RandomNoise",
+      "settings": {
+        "noise_seed": 0,
+        "control_after_generate": "fixed"
+      },
+      "inputs": {
+        "noise_seed": [
+          "n13",
+          "noise_seed"
+        ]
+      },
+      "label": "RandomNoise — Per-shot noise seed"
+    },
+    {
+      "key": "n17",
+      "type": "MiniMaxH3ImageToVideo",
+      "settings": {
+        "prompt": "integrated_multimodal_description:\n[Shot 1] Continue directly from the protected ending of the incoming low-angle wildlife footage with no cut, reset, repeated action, or change of camera. Preserve the same real light-blue soldier crabs, damp sand, distant shoreline buildings, cloudy late-afternoon sky, shallow depth of field, natural color, lens height, and documentary realism. The crabs already moving laterally continue at their current pace while more animals enter from the middle distance. The camera remains close to the sand and makes a slow, small rightward pan to follow the densest group. Individual crabs step around grains of sand and one another without merging, duplicating, or changing species. A thin wash of water reaches the edge of the group; the nearest crabs lift their bodies, sidestep around it, and continue toward firmer sand. End on uninterrupted motion with the camera still drifting right.\n\noverall_soundscape:\nContinue the protected beach ambience seamlessly: steady coastal wind, soft distant surf, faint water movement, and subtle dry clicks and sand scratches from many crab legs. Do not introduce speech or an abrupt acoustic change.\n\nnon_diegetic_music:\nN/A",
+        "width": 960,
+        "height": 544,
+        "length": 192
+      },
+      "inputs": {
+        "clip": [
+          "n2",
+          "CLIP"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "prompt": [
+          "n13",
+          "prompt"
+        ],
+        "width": [
+          "n13",
+          "width"
+        ],
+        "height": [
+          "n13",
+          "height"
+        ],
+        "length": [
+          "n13",
+          "length"
+        ]
+      },
+      "label": "MiniMax H3 Image to Video — CORE H3 T2VA — SOURCE LIVES IN TARGET LATENT"
+    },
+    {
+      "key": "n18",
+      "type": "MiniMaxH3ChainContext",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n13",
+          "state"
+        ],
+        "conditioning": [
+          "n17",
+          "positive"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "latent": [
+          "n17",
+          "LATENT"
+        ],
+        "audio_vae": [
+          "n5",
+          "VAE"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Context — AUTO CONTEXT — clip 1 bypass / continuation"
+    },
+    {
+      "key": "n19",
+      "type": "MiniMaxH3SigmaShift",
+      "settings": {
+        "shift_video": 12,
+        "shift_audio": 3
+      },
+      "inputs": {
+        "model": [
+          "n30",
+          "MODEL"
+        ]
+      }
+    },
+    {
+      "key": "n22",
+      "type": "BasicGuider",
+      "settings": {},
+      "inputs": {
+        "model": [
+          "n19",
+          "MODEL"
+        ],
+        "conditioning": [
+          "n18",
+          "conditioning"
+        ]
+      },
+      "label": "Basic Guider — Loop guider"
+    },
+    {
+      "key": "n23",
+      "type": "BasicScheduler",
+      "settings": {
+        "scheduler": "simple",
+        "steps": 20,
+        "denoise": 1
+      },
+      "inputs": {
+        "model": [
+          "n19",
+          "MODEL"
+        ],
+        "steps": [
+          "n13",
+          "steps"
+        ]
+      },
+      "label": "BasicScheduler — Per-shot scheduler steps"
+    },
+    {
+      "key": "n24",
+      "type": "SamplerCustomAdvanced",
+      "settings": {},
+      "inputs": {
+        "noise": [
+          "n16",
+          "NOISE"
+        ],
+        "guider": [
+          "n22",
+          "GUIDER"
+        ],
+        "sampler": [
+          "n3",
+          "SAMPLER"
+        ],
+        "sigmas": [
+          "n23",
+          "SIGMAS"
+        ],
+        "latent_image": [
+          "n18",
+          "latent"
+        ]
+      },
+      "label": "SamplerCustomAdvanced — H3 sampler — SINGLE LOOP BODY"
+    },
+    {
+      "key": "n25",
+      "type": "VAEDecode",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n24",
+          "output"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode — Decode current clip frames"
+    },
+    {
+      "key": "n26",
+      "type": "VAEDecodeAudio",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n24",
+          "output"
+        ],
+        "vae": [
+          "n5",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode Audio — Decode current clip audio"
+    },
+    {
+      "key": "n27",
+      "type": "MiniMaxH3LoopTrim",
+      "settings": {
+        "trim_frames": 0,
+        "fps": 24,
+        "match_tail": true,
+        "retain_overlap_frames": 39
+      },
+      "inputs": {
+        "images": [
+          "n25",
+          "IMAGE"
+        ],
+        "audio": [
+          "n26",
+          "AUDIO"
+        ],
+        "trim_frames": [
+          "n18",
+          "trim_frames"
+        ],
+        "state": [
+          "n13",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Trim — TRIM CONTEXT / AUTO-RESOLVE SCENE BLEND"
+    },
+    {
+      "key": "n28",
+      "type": "MiniMaxH3ChainSegmentSave",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n13",
+          "state"
+        ],
+        "images": [
+          "n27",
+          "images"
+        ],
+        "sampled_latent": [
+          "n24",
+          "output"
+        ],
+        "audio": [
+          "n27",
+          "audio"
+        ],
+        "images_with_overlap": [
+          "n27",
+          "images_with_overlap"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Segment + Checkpoint — SAVE DELIVERED + BLEND-READY SEGMENTS"
+    },
+    {
+      "key": "n29",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "cc0_soldier_crabs_single_extension_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n36",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — FINAL ASSEMBLY — 5-FRAME VISUAL BLEND"
+    },
+    {
+      "key": "n30",
+      "type": "ModelAttentionBackend",
+      "settings": {
+        "attention": "pytorch attention"
+      },
+      "inputs": {
+        "model": [
+          "n1",
+          "MODEL"
+        ]
+      },
+      "label": "ModelAttentionBackend — COMFY KITCHEN ATTENTION"
+    },
+    {
+      "key": "n31",
+      "type": "MiniMaxH3ChainRichScenePromptEditor",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n33",
+          "plan"
+        ]
+      }
+    },
+    {
+      "key": "n32",
+      "type": "MiniMaxH3ChainPlanModern",
+      "settings": {
+        "plan_json": "{\n  \"defaults\": {\n    \"length\": 192,\n    \"steps\": 20\n  },\n  \"shots\": [\n    {\n      \"id\": \"soldier_crabs_extension\",\n      \"prompt\": \"integrated_multimodal_description:\\n[Shot 1] Continue directly from the protected ending of the incoming low-angle wildlife footage with no cut, reset, repeated action, or change of camera. Preserve the same real light-blue soldier crabs, damp sand, distant shoreline buildings, cloudy late-afternoon sky, shallow depth of field, natural color, lens height, and documentary realism. The crabs already moving laterally continue at their current pace while more animals enter from the middle distance. The camera remains close to the sand and makes a slow, small rightward pan to follow the densest group. Individual crabs step around grains of sand and one another without merging, duplicating, or changing species. A thin wash of water reaches the edge of the group; the nearest crabs lift their bodies, sidestep around it, and continue toward firmer sand. End on uninterrupted motion with the camera still drifting right.\\n\\noverall_soundscape:\\nContinue the protected beach ambience seamlessly: steady coastal wind, soft distant surf, faint water movement, and subtle dry clicks and sand scratches from many crab legs. Do not introduce speech or an abrupt acoustic change.\\n\\nnon_diegetic_music:\\nN/A\",\n      \"length\": 192,\n      \"steps\": 20,\n      \"seed\": \"24051501\"\n    }\n  ]\n}",
+        "run_name": "masked_av_extension_single_clip_minimax_h3_0_6_json",
+        "generation_fingerprint": "h3-v06-release-example",
+        "width": 960,
+        "height": 544,
+        "encode_mode": "video",
+        "crop": "disabled",
+        "default_duration_seconds": 8.0,
+        "default_steps": 20,
+        "base_seed": 0,
+        "segment_crf": 20,
+        "video_blend_frames": 39
+      },
+      "inputs": {
+        "chain_policy": [
+          "n41",
+          "chain_policy"
+        ],
+        "project_assets": [
+          "n42",
+          "project_assets"
+        ]
+      },
+      "label": "MiniMax H3 Production Plan — 0.6 SCENE COLUMNS"
+    },
+    {
+      "key": "n33",
+      "type": "MiniMaxH3ChainPlanStudio",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true,
+        "plan_json": "{\n  \"shots\": [\n    {\n      \"id\": \"intro\",\n      \"prompt\": \"Describe the opening shot.\"\n    },\n    {\n      \"id\": \"continuation\",\n      \"prompt\": \"Continue the same take.\"\n    }\n  ]\n}",
+        "run_name": "h3_chain",
+        "generation_fingerprint": "",
+        "width": 960,
+        "height": 544,
+        "context_length": 22,
+        "encode_mode": "video",
+        "anchor_mode": "head",
+        "crop": "disabled",
+        "audio_mode": "generated_audio",
+        "audio_context_length": 22,
+        "default_duration_seconds": 15.0,
+        "default_steps": 20,
+        "base_seed": 0,
+        "segment_crf": 18,
+        "video_blend_frames": 0,
+        "continuation_mode": "guide",
+        "alternate_take_json": ""
+      },
+      "inputs": {
+        "plan": [
+          "n32",
+          "plan"
+        ],
+        "tagged_references": [
+          "n42",
+          "references"
+        ],
+        "project_assets": [
+          "n42",
+          "project_assets"
+        ]
+      },
+      "label": "MiniMax H3 Plan Studio — TIMELINE / TAKES / TRIMS"
+    },
+    {
+      "key": "n34",
+      "type": "MiniMaxH3ChainManifestLoad",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n33",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Load Manifest — RECOVERY: LOAD ALL SAVED CLIPS",
+      "mode": 2
+    },
+    {
+      "key": "n35",
+      "type": "Note",
+      "settings": {
+        "text": "The two amber recovery nodes are MUTED by default.\n\nIf all segments finished but final assembly did not, mute the main green Assemble node, enable both recovery nodes, and queue. They validate every SHA-256 checkpoint pair and assemble without rerendering the completed clips.\n\nFor an interrupted generation, leave recovery muted and set Loop Start's start_clip to the first unfinished clip."
+      },
+      "inputs": {},
+      "label": "Note — RECOVERY / ASSEMBLE LATER"
+    },
+    {
+      "key": "n36",
+      "type": "MiniMaxH3ChainLoopEnd",
+      "settings": {
+        "between_scene_cleanup": "off"
+      },
+      "inputs": {
+        "flow": [
+          "n10",
+          "flow"
+        ],
+        "state": [
+          "n13",
+          "state"
+        ],
+        "images": [
+          "n27",
+          "images"
+        ],
+        "sampled_latent": [
+          "n24",
+          "output"
+        ],
+        "segment": [
+          "n37",
+          "segment"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop End — LOOP END — ADVANCE T2V SCENE"
+    },
+    {
+      "key": "n37",
+      "type": "MiniMaxH3ChainReview",
+      "settings": {
+        "enabled": true,
+        "play_notification_sound": false,
+        "auto_continue_timeout_minutes": 0,
+        "unload_models_while_waiting": false,
+        "assemble_partial_on_stop": true,
+        "partial_audio_source": "checkpointed",
+        "candidate_count": 1,
+        "review_each_candidate": false
+      },
+      "inputs": {
+        "state": [
+          "n13",
+          "state"
+        ],
+        "segment": [
+          "n28",
+          "segment"
+        ],
+        "audio": [
+          "n27",
+          "audio"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Review Gate — REVIEW GATE — APPROVE / EDIT+RETRY / REROLL / STOP"
+    },
+    {
+      "key": "n38",
+      "type": "Note",
+      "settings": {
+        "text": "SOFT AV EXTENSION — SINGLE LOOP ITERATION\n\nThe complete CC0 source is normalized to 24 fps and persisted as the prelude. Its last 39 frames and matching 65 audio latent steps become scene 1's clean protected target prefix. Soft AV keeps the picture prefix hard while releasing the last eight audio ticks with a half-cosine feather. H3 generates 153 new frames (6.375s); Loop Trim removes the repeated prefix, retains all 39 visual overlap frames for the final linear blend, and Assemble prepends the original 13-second source.\n\nThis intentionally uses the same recursive loop as long chains, with a one-scene Plan rather than a separate one-off extension stack."
+      },
+      "inputs": {},
+      "label": "Note — T2V STUDIO — HOW TO USE"
+    },
+    {
+      "key": "n39",
+      "type": "LoadVideo",
+      "settings": {
+        "file": "soldier_crabs_bribie_island_cc0.webm"
+      },
+      "inputs": {},
+      "label": "Source Video"
+    },
+    {
+      "key": "n40",
+      "type": "MiniMaxH3ChainExternalVideo",
+      "settings": {
+        "source_fps": 24,
+        "prepend_original": true
+      },
+      "inputs": {
+        "plan": [
+          "n33",
+          "plan"
+        ],
+        "source_video": [
+          "n39",
+          "VIDEO"
+        ]
+      },
+      "label": "MiniMax H3 Existing Video Context — CC0 SOURCE VIDEO → MASKED SCENE 1 PREFIX"
+    },
+    {
+      "key": "n41",
+      "type": "MiniMaxH3GenerationProfile",
+      "settings": {
+        "scene_continuity": "Hard picture + smooth audio",
+        "audio_profile": "Generate audio"
+      },
+      "inputs": {},
+      "label": "MiniMax H3 Generation Profile — RELEASE DEFAULTS"
+    },
+    {
+      "key": "n42",
+      "type": "MiniMaxH3ProjectAssetManager",
+      "settings": {
+        "run_name": "masked_av_extension_single_clip_minimax_h3_0_6_json",
+        "catalog_json": "",
+        "semantic_anchor_size": "512",
+        "semantic_anchor_mode": "timestamped_video",
+        "operation_json": ""
+      },
+      "inputs": {},
+      "label": "MiniMax H3 Project Asset Carousel — IMPORT RELEASE REFERENCES"
+    },
+    {
+      "key": "n43",
+      "type": "MiniMaxH3ChainCheckpointManager",
+      "settings": {
+        "selection_json": ""
+      },
+      "inputs": {
+        "plan": [
+          "n33",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Checkpoint Manager — BRANCHES / PREVIEWS / RESTORE"
+    },
+    {
+      "key": "n44",
+      "type": "Note",
+      "settings": {
+        "text": "0.6 Studio quick start\n\n1. Open the Project Asset Carousel.\n2. Keep the bundled source media selected in the existing loader nodes; use the Carousel for additional project assets.\n3. Edit scenes in Production Plan or Plan Studio.\n4. Queue; inspect, branch, trim, or restore in Checkpoint Manager."
+      },
+      "inputs": {},
+      "label": "0.6 STUDIO QUICK START"
+    },
+    {
+      "key": "native_video_note",
+      "type": "Note",
+      "settings": {
+        "text": "NATIVE SOURCE VIDEO\n\nCore Load Video connects directly to Existing Video Context's source_video input. The node reads embedded audio and the actual video frame rate, fits the source to the Plan canvas, and prepares the protected tail. There is no VHS frame cap or manual FPS conversion. Leave source_frames and source_audio disconnected unless intentionally switching to the separate IMAGE/AUDIO route or overriding the soundtrack."
+      },
+      "inputs": {}
+    }
+  ]
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Masked Video Inpaint - MiniMax H3 0.6.json b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Masked Video Inpaint - MiniMax H3 0.6.json
new file mode 100644
index 0000000000000000000000000000000000000000..e81606c4cbfab661d4ab933e189f00f39473be2f
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Masked Video Inpaint - MiniMax H3 0.6.json	
@@ -0,0 +1,780 @@
+{
+  "nodes": [
+    {
+      "key": "core_source_note",
+      "type": "Note",
+      "settings": {
+        "text": "CORE SOURCE VIDEO\n\nLoad Video feeds Get Video Components. Keep all three images, audio, and fps outputs connected to Loop Source AV Target: that node converts the native source rate to H3's 24 fps and fits each scene to the Plan canvas. Do not replace the fps connection with a fixed 24 for non-24-fps input. The included single-frame mask is broadcast across the scene; if using a tracked mask video, supply that mask's actual source frame rate to Mask Slice."
+      },
+      "inputs": {}
+    },
+    {
+      "key": "n1",
+      "type": "UNETLoader",
+      "settings": {
+        "unet_name": "minimax_h3_fl2va_pruned_int8_convrot.safetensors",
+        "weight_dtype": "default"
+      },
+      "inputs": {},
+      "label": "Load Diffusion Model — H3 MODEL — REQUIRED"
+    },
+    {
+      "key": "n2",
+      "type": "CLIPLoader",
+      "settings": {
+        "clip_name": "qwen3vl_32b_minimax_h3_int8_convrot.safetensors",
+        "type": "minimax",
+        "device": "default"
+      },
+      "inputs": {},
+      "label": "Load CLIP — H3 TEXT ENCODER"
+    },
+    {
+      "key": "n3",
+      "type": "KSamplerSelect",
+      "settings": {
+        "sampler_name": "res_multistep"
+      },
+      "inputs": {},
+      "label": "KSamplerSelect — Sampler algorithm"
+    },
+    {
+      "key": "n4",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_video_vae_fp16.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Video VAE"
+    },
+    {
+      "key": "n5",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_audio_vae_fp32.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Audio VAE"
+    },
+    {
+      "key": "n6",
+      "type": "Note",
+      "settings": {
+        "text": "SOURCE ASSET — CC0\n\nLight-blue soldier crabs on Bribie Island, filmed in 2015 by Watermark Resort Caloundra. Wikimedia Commons records the video as CC0 1.0.\n\nhttps://commons.wikimedia.org/wiki/File:Light-blue_soldier_crabs_on_Bribie_Island.webm\n\nCopy soldier_crabs_bribie_island_cc0.webm and soldier_crabs_inpaint_mask.png from example_workflows/assets/ to ComfyUI/input/."
+      },
+      "inputs": {},
+      "label": "Note — PROMPT SOURCE / ATTRIBUTION"
+    },
+    {
+      "key": "n7",
+      "type": "Note",
+      "settings": {
+        "text": "T2VA PROMPT FORMAT\n\nT2VA begins directly with these three fields in this exact order—there is no Picture alignment instruction:\n\nintegrated_multimodal_description: [Shot 1] Describe visible style, composition, subjects, actions, camera movement, dialogue, and synchronized diegetic events.\n\noverall_soundscape: Summarize ambience, physical sounds, and non-verbal human sounds.\n\nnon_diegetic_music: Describe audience-only music, or use N/A.\n\nFor a chained continuation, explicitly continue the incoming pose, action phase, camera position and motion, lighting, environment, object states, ambience, and speaker identity. Do not re-establish or reset the shot unless a cut is intentional."
+      },
+      "inputs": {},
+      "label": "Note — T2VA PROMPT FORMAT"
+    },
+    {
+      "key": "n10",
+      "type": "MiniMaxH3ChainLoopStart",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true
+      },
+      "inputs": {
+        "plan": [
+          "n33",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Start — LOOP START — NO EXTERNAL CONTINUATION"
+    },
+    {
+      "key": "n13",
+      "type": "MiniMaxH3ChainCurrent",
+      "settings": {
+        "align_audio_reference": false
+      },
+      "inputs": {
+        "state": [
+          "n10",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Current Shot — CURRENT T2V SCENE — PROMPT / SEED / TIMING"
+    },
+    {
+      "key": "n14",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "cc0_soldier_crabs_loop_inpaint_recovered_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n34",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — RECOVERY: ASSEMBLE WITHOUT RENDERING",
+      "mode": 2
+    },
+    {
+      "key": "n16",
+      "type": "RandomNoise",
+      "settings": {
+        "noise_seed": 0,
+        "control_after_generate": "fixed"
+      },
+      "inputs": {
+        "noise_seed": [
+          "n13",
+          "noise_seed"
+        ]
+      },
+      "label": "RandomNoise — Per-shot noise seed"
+    },
+    {
+      "key": "n17",
+      "type": "MiniMaxH3ImageToVideo",
+      "settings": {
+        "prompt": "integrated_multimodal_description:\n[Shot 1] Edit the supplied wildlife source video in place. Preserve the original camera trajectory, cloudy coastal lighting, sand, water, distant shoreline, depth of field, motion timing, and every pixel outside the white mask. Inside the masked lower-central beach region only, replace the moving soldier crabs with small polished red metal crab sculptures that occupy the corresponding positions and follow the original animals' grounded lateral motion. Maintain correct perspective, contact shadows, sand interaction, occlusion, scale, and motion blur at the mask boundary. Do not alter the duration, frame rate, camera, background, or unmasked crabs.\n\noverall_soundscape:\nPreserve the source audio exactly, including coastal wind, distant surf, water movement, and all location ambience. Generate no replacement sound.\n\nnon_diegetic_music:\nN/A",
+        "width": 960,
+        "height": 544,
+        "length": 175
+      },
+      "inputs": {
+        "clip": [
+          "n2",
+          "CLIP"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "prompt": [
+          "n13",
+          "prompt"
+        ],
+        "width": [
+          "n13",
+          "width"
+        ],
+        "height": [
+          "n13",
+          "height"
+        ],
+        "length": [
+          "n13",
+          "length"
+        ]
+      },
+      "label": "MiniMax H3 Image to Video — CORE H3 T2VA — EMPTY GRID DEFINES AV SHAPES"
+    },
+    {
+      "key": "n18",
+      "type": "MiniMaxH3ChainContext",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n13",
+          "state"
+        ],
+        "conditioning": [
+          "n17",
+          "positive"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "latent": [
+          "n40",
+          "source_target"
+        ],
+        "audio_vae": [
+          "n5",
+          "VAE"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Context — AUTO CONTEXT — clip 1 bypass / continuation"
+    },
+    {
+      "key": "n19",
+      "type": "MiniMaxH3SigmaShift",
+      "settings": {
+        "shift_video": 12,
+        "shift_audio": 3
+      },
+      "inputs": {
+        "model": [
+          "n30",
+          "MODEL"
+        ]
+      }
+    },
+    {
+      "key": "n22",
+      "type": "BasicGuider",
+      "settings": {},
+      "inputs": {
+        "model": [
+          "n19",
+          "MODEL"
+        ],
+        "conditioning": [
+          "n18",
+          "conditioning"
+        ]
+      },
+      "label": "Basic Guider — Loop guider"
+    },
+    {
+      "key": "n23",
+      "type": "BasicScheduler",
+      "settings": {
+        "scheduler": "simple",
+        "steps": 20,
+        "denoise": 1
+      },
+      "inputs": {
+        "model": [
+          "n19",
+          "MODEL"
+        ],
+        "steps": [
+          "n13",
+          "steps"
+        ]
+      },
+      "label": "BasicScheduler — Per-shot scheduler steps"
+    },
+    {
+      "key": "n24",
+      "type": "SamplerCustomAdvanced",
+      "settings": {},
+      "inputs": {
+        "noise": [
+          "n16",
+          "NOISE"
+        ],
+        "guider": [
+          "n22",
+          "GUIDER"
+        ],
+        "sampler": [
+          "n3",
+          "SAMPLER"
+        ],
+        "sigmas": [
+          "n23",
+          "SIGMAS"
+        ],
+        "latent_image": [
+          "n41",
+          "masked_target"
+        ]
+      },
+      "label": "SamplerCustomAdvanced — H3 sampler — SINGLE LOOP BODY"
+    },
+    {
+      "key": "n25",
+      "type": "VAEDecode",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n24",
+          "output"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode — Decode current clip frames"
+    },
+    {
+      "key": "n26",
+      "type": "VAEDecodeAudio",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n24",
+          "output"
+        ],
+        "vae": [
+          "n5",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode Audio — Decode current clip audio"
+    },
+    {
+      "key": "n27",
+      "type": "MiniMaxH3LoopTrim",
+      "settings": {
+        "trim_frames": 0,
+        "fps": 24,
+        "match_tail": true,
+        "retain_overlap_frames": 5
+      },
+      "inputs": {
+        "images": [
+          "n25",
+          "IMAGE"
+        ],
+        "audio": [
+          "n26",
+          "AUDIO"
+        ],
+        "trim_frames": [
+          "n18",
+          "trim_frames"
+        ],
+        "state": [
+          "n13",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Trim — TRIM CONTEXT / AUTO-RESOLVE SCENE BLEND"
+    },
+    {
+      "key": "n28",
+      "type": "MiniMaxH3ChainSegmentSave",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n13",
+          "state"
+        ],
+        "images": [
+          "n27",
+          "images"
+        ],
+        "sampled_latent": [
+          "n24",
+          "output"
+        ],
+        "audio": [
+          "n27",
+          "audio"
+        ],
+        "images_with_overlap": [
+          "n27",
+          "images_with_overlap"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Segment + Checkpoint — SAVE DELIVERED + BLEND-READY SEGMENTS"
+    },
+    {
+      "key": "n29",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "cc0_soldier_crabs_loop_inpaint_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n36",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — FINAL ASSEMBLY — 5-FRAME VISUAL BLEND"
+    },
+    {
+      "key": "n30",
+      "type": "ModelAttentionBackend",
+      "settings": {
+        "attention": "pytorch attention"
+      },
+      "inputs": {
+        "model": [
+          "n1",
+          "MODEL"
+        ]
+      },
+      "label": "ModelAttentionBackend — COMFY KITCHEN ATTENTION"
+    },
+    {
+      "key": "n31",
+      "type": "MiniMaxH3ChainRichScenePromptEditor",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n33",
+          "plan"
+        ]
+      }
+    },
+    {
+      "key": "n32",
+      "type": "MiniMaxH3ChainPlanModern",
+      "settings": {
+        "plan_json": "{\n  \"defaults\": {\n    \"length\": 175,\n    \"steps\": 20\n  },\n  \"shots\": [\n    {\n      \"id\": \"source_inpaint_a\",\n      \"prompt\": \"integrated_multimodal_description:\\n[Shot 1] Edit the supplied wildlife source video in place. Preserve the original camera trajectory, cloudy coastal lighting, sand, water, distant shoreline, depth of field, motion timing, and every pixel outside the white mask. Inside the masked lower-central beach region only, replace the moving soldier crabs with small polished red metal crab sculptures that occupy the corresponding positions and follow the original animals' grounded lateral motion. Maintain correct perspective, contact shadows, sand interaction, occlusion, scale, and motion blur at the mask boundary. Do not alter the duration, frame rate, camera, background, or unmasked crabs.\\n\\noverall_soundscape:\\nPreserve the source audio exactly, including coastal wind, distant surf, water movement, and all location ambience. Generate no replacement sound.\\n\\nnon_diegetic_music:\\nN/A\",\n      \"length\": 175,\n      \"steps\": 20,\n      \"seed\": \"24051521\"\n    },\n    {\n      \"id\": \"source_inpaint_b\",\n      \"prompt\": \"integrated_multimodal_description:\\n[Shot 1] Edit the supplied wildlife source video in place. Preserve the original camera trajectory, cloudy coastal lighting, sand, water, distant shoreline, depth of field, motion timing, and every pixel outside the white mask. Inside the masked lower-central beach region only, replace the moving soldier crabs with small polished red metal crab sculptures that occupy the corresponding positions and follow the original animals' grounded lateral motion. Maintain correct perspective, contact shadows, sand interaction, occlusion, scale, and motion blur at the mask boundary. Do not alter the duration, frame rate, camera, background, or unmasked crabs.\\n\\noverall_soundscape:\\nPreserve the source audio exactly, including coastal wind, distant surf, water movement, and all location ambience. Generate no replacement sound.\\n\\nnon_diegetic_music:\\nN/A\",\n      \"length\": 175,\n      \"steps\": 20,\n      \"seed\": \"24051522\"\n    }\n  ]\n}",
+        "run_name": "masked_video_inpaint_minimax_h3_0_6_json",
+        "generation_fingerprint": "h3-v06-release-example",
+        "width": 960,
+        "height": 544,
+        "encode_mode": "video",
+        "crop": "center",
+        "default_duration_seconds": 8.0,
+        "default_steps": 20,
+        "base_seed": 0,
+        "segment_crf": 20,
+        "video_blend_frames": 5
+      },
+      "inputs": {
+        "chain_policy": [
+          "n47",
+          "chain_policy"
+        ],
+        "project_assets": [
+          "n48",
+          "project_assets"
+        ]
+      },
+      "label": "MiniMax H3 Production Plan — 0.6 SCENE COLUMNS"
+    },
+    {
+      "key": "n33",
+      "type": "MiniMaxH3ChainPlanStudio",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true,
+        "plan_json": "{\n  \"shots\": [\n    {\n      \"id\": \"intro\",\n      \"prompt\": \"Describe the opening shot.\"\n    },\n    {\n      \"id\": \"continuation\",\n      \"prompt\": \"Continue the same take.\"\n    }\n  ]\n}",
+        "run_name": "h3_chain",
+        "generation_fingerprint": "",
+        "width": 960,
+        "height": 544,
+        "context_length": 22,
+        "encode_mode": "video",
+        "anchor_mode": "head",
+        "crop": "disabled",
+        "audio_mode": "generated_audio",
+        "audio_context_length": 22,
+        "default_duration_seconds": 15.0,
+        "default_steps": 20,
+        "base_seed": 0,
+        "segment_crf": 18,
+        "video_blend_frames": 0,
+        "continuation_mode": "guide",
+        "alternate_take_json": ""
+      },
+      "inputs": {
+        "plan": [
+          "n32",
+          "plan"
+        ],
+        "tagged_references": [
+          "n48",
+          "references"
+        ],
+        "project_assets": [
+          "n48",
+          "project_assets"
+        ]
+      },
+      "label": "MiniMax H3 Plan Studio — TIMELINE / TAKES / TRIMS"
+    },
+    {
+      "key": "n34",
+      "type": "MiniMaxH3ChainManifestLoad",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n33",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Load Manifest — RECOVERY: LOAD ALL SAVED CLIPS",
+      "mode": 2
+    },
+    {
+      "key": "n35",
+      "type": "Note",
+      "settings": {
+        "text": "The two amber recovery nodes are MUTED by default.\n\nIf all segments finished but final assembly did not, mute the main green Assemble node, enable both recovery nodes, and queue. They validate every SHA-256 checkpoint pair and assemble without rerendering the completed clips.\n\nFor an interrupted generation, leave recovery muted and set Loop Start's start_clip to the first unfinished clip."
+      },
+      "inputs": {},
+      "label": "Note — RECOVERY / ASSEMBLE LATER"
+    },
+    {
+      "key": "n36",
+      "type": "MiniMaxH3ChainLoopEnd",
+      "settings": {
+        "between_scene_cleanup": "off"
+      },
+      "inputs": {
+        "flow": [
+          "n10",
+          "flow"
+        ],
+        "state": [
+          "n13",
+          "state"
+        ],
+        "images": [
+          "n27",
+          "images"
+        ],
+        "sampled_latent": [
+          "n24",
+          "output"
+        ],
+        "segment": [
+          "n37",
+          "segment"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop End — LOOP END — ADVANCE T2V SCENE"
+    },
+    {
+      "key": "n37",
+      "type": "MiniMaxH3ChainReview",
+      "settings": {
+        "enabled": true,
+        "play_notification_sound": false,
+        "auto_continue_timeout_minutes": 0,
+        "unload_models_while_waiting": false,
+        "assemble_partial_on_stop": true,
+        "partial_audio_source": "checkpointed",
+        "candidate_count": 1,
+        "review_each_candidate": false
+      },
+      "inputs": {
+        "state": [
+          "n13",
+          "state"
+        ],
+        "segment": [
+          "n28",
+          "segment"
+        ],
+        "audio": [
+          "n27",
+          "audio"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Review Gate — REVIEW GATE — APPROVE / EDIT+RETRY / REROLL / STOP"
+    },
+    {
+      "key": "n38",
+      "type": "Note",
+      "settings": {
+        "text": "MASKED VIDEO INPAINT — CHAIN LOOP\n\nThis is a real Chain Loop workflow, including Current Shot, checkpoint/review, Loop End, resume, and disk assembly. Two 175-frame generations share a 39-frame protected overlap, delivering the largest valid span contained by the bundled 313-frame source: 311 frames. Scene 1 selects source frames 0..174; scene 2 selects 136..310 and retains the preceding edited result in its protected prefix.\n\nThe pack-native Loop Source AV Target selects the current source interval from Chain state, then fits picture and sound to the exact stock H3 joint target. It does not use LTXVConcatAVLatent or LTXVSeparateAVLatent. The source picture and audio therefore share the same frame-derived 24-fps start and duration. Apply Target Mask preserves source audio and every black video cell; only white cells are regenerated. Loop Mask Slice broadcasts the bundled one-frame mask explicitly. Replace its mask input with a tracked MASK batch covering the complete source timeline to follow a moving object; scene 2 automatically receives mask frames 136..310, including the same 39-frame overlap as source AV."
+      },
+      "inputs": {},
+      "label": "Note — T2V STUDIO — HOW TO USE"
+    },
+    {
+      "key": "n39",
+      "type": "LoadVideo",
+      "settings": {
+        "file": "soldier_crabs_bribie_island_cc0.webm"
+      },
+      "inputs": {},
+      "label": "Source Video — CC0 Soldier Crabs"
+    },
+    {
+      "key": "source_components",
+      "type": "GetVideoComponents",
+      "settings": {},
+      "inputs": {"video": ["n39", "VIDEO"]}
+    },
+    {
+      "key": "n40",
+      "type": "MiniMaxH3ContexLoopSourceAVTarget",
+      "settings": {
+        "source_fps": 24,
+        "crop": "center"
+      },
+      "inputs": {
+        "state": [
+          "n13",
+          "state"
+        ],
+        "latent": [
+          "n17",
+          "LATENT"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "audio_vae": [
+          "n5",
+          "VAE"
+        ],
+        "source_frames": [
+          "source_components",
+          "images"
+        ],
+        "source_audio": [
+          "source_components",
+          "audio"
+        ],
+        "source_fps": [
+          "source_components",
+          "fps"
+        ]
+      },
+      "label": "MiniMax H3 Masking · Loop Source AV Target — FRAME-LOCK CURRENT LOOP SCENE TO SOURCE AV"
+    },
+    {
+      "key": "n41",
+      "type": "MiniMaxH3ContexMaskedTarget",
+      "settings": {
+        "mask_meaning": "white = generate",
+        "audio_mode": "preserve source audio",
+        "mask_conversion": "H3 exact (causal/token max)"
+      },
+      "inputs": {
+        "target_latent": [
+          "n18",
+          "latent"
+        ],
+        "mask": [
+          "n43",
+          "snapped_mask"
+        ]
+      },
+      "label": "MiniMax H3 Masking · Apply Target Mask — APPLY SPATIAL MASK — SOURCE AUDIO PRESERVED"
+    },
+    {
+      "key": "n42",
+      "type": "LoadImageMask",
+      "settings": {
+        "image": "soldier_crabs_inpaint_mask.png",
+        "channel": "red"
+      },
+      "inputs": {},
+      "label": "Load Image (as Mask) — STATIC MASK — REPLACE WITH TRACKED MASK BATCH"
+    },
+    {
+      "key": "n43",
+      "type": "MiniMaxH3ContexMaskGridPreview",
+      "settings": {
+        "cell_selection": "runtime exact (latent max)",
+        "cell_adjust": 0,
+        "preview_frame": 0,
+        "overlay_opacity": 0.38,
+        "show_grid": true,
+        "show_source_outline": true,
+        "mask_meaning": "white = generate"
+      },
+      "inputs": {
+        "image": [
+          "n40",
+          "scene_frames"
+        ],
+        "mask": [
+          "n46",
+          "scene_mask"
+        ]
+      },
+      "label": "MiniMax H3 Masking · Grid Preview — PREVIEW EXACT H3 32PX MASK CELLS"
+    },
+    {
+      "key": "n44",
+      "type": "PreviewImage",
+      "settings": {},
+      "inputs": {
+        "images": [
+          "n43",
+          "grid_preview"
+        ]
+      },
+      "label": "Preview Image — Verify generated 32×32 cells"
+    },
+    {
+      "key": "n45",
+      "type": "PreviewAny",
+      "settings": {},
+      "inputs": {
+        "source": [
+          "n40",
+          "status"
+        ]
+      },
+      "label": "Preview as Text — SOURCE AV ALIGNMENT STATUS"
+    },
+    {
+      "key": "n46",
+      "type": "MiniMaxH3ContexLoopMaskSlice",
+      "settings": {
+        "source_fps": 24
+      },
+      "inputs": {
+        "state": [
+          "n13",
+          "state"
+        ],
+        "mask": [
+          "n42",
+          "MASK"
+        ]
+      },
+      "label": "MiniMax H3 Masking · Loop Mask Slice — SLICE TRACKED MASK TO CURRENT LOOP SCENE"
+    },
+    {
+      "key": "n47",
+      "type": "MiniMaxH3GenerationProfile",
+      "settings": {
+        "scene_continuity": "Hard picture + protected audio",
+        "audio_profile": "Generate audio"
+      },
+      "inputs": {},
+      "label": "MiniMax H3 Generation Profile — RELEASE DEFAULTS"
+    },
+    {
+      "key": "n48",
+      "type": "MiniMaxH3ProjectAssetManager",
+      "settings": {
+        "run_name": "masked_video_inpaint_minimax_h3_0_6_json",
+        "catalog_json": "",
+        "semantic_anchor_size": "512",
+        "semantic_anchor_mode": "timestamped_video",
+        "operation_json": ""
+      },
+      "inputs": {},
+      "label": "MiniMax H3 Project Asset Carousel — IMPORT RELEASE REFERENCES"
+    },
+    {
+      "key": "n49",
+      "type": "MiniMaxH3ChainCheckpointManager",
+      "settings": {
+        "selection_json": ""
+      },
+      "inputs": {
+        "plan": [
+          "n33",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Checkpoint Manager — BRANCHES / PREVIEWS / RESTORE"
+    },
+    {
+      "key": "n50",
+      "type": "Note",
+      "settings": {
+        "text": "0.6 Studio quick start\n\n1. Open the Project Asset Carousel.\n2. Keep the bundled source media selected in the existing loader nodes; use the Carousel for additional project assets.\n3. Edit scenes in Production Plan or Plan Studio.\n4. Queue; inspect, branch, trim, or restore in Checkpoint Manager."
+      },
+      "inputs": {},
+      "label": "0.6 STUDIO QUICK START"
+    }
+  ]
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Ref2V Basic - MiniMax H3 0.6.json b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Ref2V Basic - MiniMax H3 0.6.json
new file mode 100644
index 0000000000000000000000000000000000000000..9d1e18e5799f6a62340ff3538ec7bf536a04ac81
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Ref2V Basic - MiniMax H3 0.6.json	
@@ -0,0 +1,584 @@
+{
+  "nodes": [
+    {
+      "key": "n1",
+      "type": "UNETLoader",
+      "settings": {
+        "unet_name": "minimax_h3_ref2va_pruned_int8_convrot.safetensors",
+        "weight_dtype": "default"
+      },
+      "inputs": {},
+      "label": "Load Diffusion Model — H3 MODEL — REQUIRED"
+    },
+    {
+      "key": "n2",
+      "type": "CLIPLoader",
+      "settings": {
+        "clip_name": "qwen3vl_32b_minimax_h3_int8_convrot.safetensors",
+        "type": "minimax",
+        "device": "default"
+      },
+      "inputs": {},
+      "label": "Load CLIP — H3 TEXT ENCODER"
+    },
+    {
+      "key": "n3",
+      "type": "KSamplerSelect",
+      "settings": {
+        "sampler_name": "res_multistep"
+      },
+      "inputs": {},
+      "label": "KSamplerSelect — Sampler algorithm"
+    },
+    {
+      "key": "n4",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_video_vae_fp16.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Video VAE"
+    },
+    {
+      "key": "n5",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_audio_vae_fp32.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Audio VAE"
+    },
+    {
+      "key": "n6",
+      "type": "Note",
+      "settings": {
+        "text": "0.6 ORIGINAL REFERENCE EXAMPLE\n\nThe matching courier and greenhouse pictures were generated specifically for this catalog. They replace the old community demonstration assets and prompts."
+      },
+      "inputs": {},
+      "label": "0.6 ORIGINAL REFERENCE EXAMPLE"
+    },
+    {
+      "key": "n7",
+      "type": "MiniMaxH3ChainScenePromptEditor",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n34",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Scene Prompt Editor — SCENE PROMPT EDITOR — STANDARD AUTHORING"
+    },
+    {
+      "key": "n8",
+      "type": "Note",
+      "settings": {
+        "text": "REF2VA PROMPT FORMAT — SIX SECTIONS\n\nKeep subject_definitions, summary, retention_analysis, detailed_description, overall_soundscape, and non_diegetic_music in that order. References define identity; the prompt defines the new action."
+      },
+      "inputs": {},
+      "label": "REF2VA PROMPT FORMAT — SIX SECTIONS"
+    },
+    {
+      "key": "n11",
+      "type": "MiniMaxH3ChainLoopStart",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true
+      },
+      "inputs": {
+        "plan": [
+          "n40",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Start — LOOP START / RESUME"
+    },
+    {
+      "key": "n14",
+      "type": "MiniMaxH3ChainCurrent",
+      "settings": {
+        "align_audio_reference": false
+      },
+      "inputs": {
+        "state": [
+          "n11",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Current Shot — CURRENT REF2V SCENE — PROMPT / SEED / TIMING"
+    },
+    {
+      "key": "n15",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "t2v_normal_recovered_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n35",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — RECOVERY: ASSEMBLE WITHOUT RENDERING",
+      "mode": 2
+    },
+    {
+      "key": "n17",
+      "type": "RandomNoise",
+      "settings": {
+        "noise_seed": 0,
+        "control_after_generate": "fixed"
+      },
+      "inputs": {
+        "noise_seed": [
+          "n14",
+          "noise_seed"
+        ]
+      },
+      "label": "RandomNoise — Per-shot noise seed"
+    },
+    {
+      "key": "n18",
+      "type": "MiniMaxH3ReferenceToVideo",
+      "settings": {
+        "prompt": "subject_definitions:\n<Picture 1> defines <Subject 1>, the exact adult bicycle courier, including his face, mustard-yellow waterproof jacket, dark teal trousers, charcoal helmet, olive messenger bag, silver bicycle, kraft parcel, proportions, and photographic rendering.\n<Picture 2> defines the greenhouse delivery destination, including the glass structure, wooden potting table, dense plants, warm practical bulbs, wet floor reflections, and the same courier's end pose.\n<Subject 1> is the single courier shown by both references. Preserve his identity, clothing, equipment, and scale while allowing the described movement.\n\nsummary:\n[reference generation] One continuous delivery moves <Subject 1> from the wet greenhouse entrance in <Picture 1> toward the completed parcel placement in <Picture 2>.\n\nretention_analysis:\n<Subject 1> (appears in [Shot 1]): fully_preserved - retain the exact face, adult age, body proportions, mustard jacket, teal trousers, helmet, bag, bicycle, and parcel across the complete shot.\n<Picture 1>: fully_preserved - use its courier identity, wardrobe, bicycle geometry, exterior doorway, wet paving, camera height, and cool daylight as the opening state.\n<Picture 2>: reference - use its potting table, plants, warm bulbs, interior reflections, and delivery pose as the destination; do not copy the final pose before the action reaches it.\n\ndetailed_description:\n[Shot 1] Begin at the greenhouse entrance with exactly one courier and one bicycle. He walks the bicycle through the open glass door, glances down to confirm the parcel, then turns toward the wooden potting table. The camera tracks laterally at walking speed with restrained handheld movement. He stops the bicycle with his left hand and sets the parcel on the clear corner of the table with his right hand. Preserve face, hands, clothing, bicycle structure, parcel dimensions, plant layout, lighting direction, and coherent reflections. End immediately after the parcel makes contact; no cut, duplicate subject, added customer, text, logo, or early freeze.\n\noverall_soundscape:\nLight rain on greenhouse glass, wet tire roll, a quiet freewheel tick, rubber soles, door hinge, jacket movement, muted ventilation, and soft cardboard contact on wood. Keep every sound synchronized and spatially plausible.\n\nnon_diegetic_music:\nNo non-diegetic music.",
+        "width": 896,
+        "height": 672,
+        "length": 243,
+        "ref_image_size": "match"
+      },
+      "inputs": {
+        "clip": [
+          "n2",
+          "CLIP"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "audio_vae": [
+          "n5",
+          "VAE"
+        ],
+        "ref_images.ref_image_0": [
+          "n37",
+          "IMAGE"
+        ],
+        "ref_images.ref_image_1": [
+          "n38",
+          "IMAGE"
+        ],
+        "prompt": [
+          "n14",
+          "prompt"
+        ],
+        "width": [
+          "n14",
+          "width"
+        ],
+        "height": [
+          "n14",
+          "height"
+        ],
+        "length": [
+          "n14",
+          "length"
+        ]
+      },
+      "label": "MiniMax H3 Reference to Video — CORE REF2VA — TWO GLOBAL PICTURES"
+    },
+    {
+      "key": "n19",
+      "type": "MiniMaxH3ChainContext",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n14",
+          "state"
+        ],
+        "conditioning": [
+          "n18",
+          "positive"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "latent": [
+          "n18",
+          "LATENT"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Context — AUTO CONTEXT — clip 1 bypass / continuation"
+    },
+    {
+      "key": "n20",
+      "type": "MiniMaxH3SigmaShift",
+      "settings": {
+        "shift_video": 12,
+        "shift_audio": 3
+      },
+      "inputs": {
+        "model": [
+          "n31",
+          "MODEL"
+        ]
+      }
+    },
+    {
+      "key": "n23",
+      "type": "BasicGuider",
+      "settings": {},
+      "inputs": {
+        "model": [
+          "n20",
+          "MODEL"
+        ],
+        "conditioning": [
+          "n19",
+          "conditioning"
+        ]
+      },
+      "label": "Basic Guider — Loop guider"
+    },
+    {
+      "key": "n24",
+      "type": "BasicScheduler",
+      "settings": {
+        "scheduler": "simple",
+        "steps": 20,
+        "denoise": 1
+      },
+      "inputs": {
+        "model": [
+          "n20",
+          "MODEL"
+        ],
+        "steps": [
+          "n14",
+          "steps"
+        ]
+      },
+      "label": "BasicScheduler — Per-shot scheduler steps"
+    },
+    {
+      "key": "n25",
+      "type": "SamplerCustomAdvanced",
+      "settings": {},
+      "inputs": {
+        "noise": [
+          "n17",
+          "NOISE"
+        ],
+        "guider": [
+          "n23",
+          "GUIDER"
+        ],
+        "sampler": [
+          "n3",
+          "SAMPLER"
+        ],
+        "sigmas": [
+          "n24",
+          "SIGMAS"
+        ],
+        "latent_image": [
+          "n19",
+          "latent"
+        ]
+      },
+      "label": "SamplerCustomAdvanced — H3 sampler — SINGLE LOOP BODY"
+    },
+    {
+      "key": "n26",
+      "type": "VAEDecode",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n25",
+          "output"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode — Decode current clip frames"
+    },
+    {
+      "key": "n27",
+      "type": "VAEDecodeAudio",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n25",
+          "output"
+        ],
+        "vae": [
+          "n5",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode Audio — Decode current clip audio"
+    },
+    {
+      "key": "n28",
+      "type": "MiniMaxH3LoopTrim",
+      "settings": {
+        "trim_frames": 0,
+        "fps": 24,
+        "match_tail": true,
+        "retain_overlap_frames": 0
+      },
+      "inputs": {
+        "images": [
+          "n26",
+          "IMAGE"
+        ],
+        "audio": [
+          "n27",
+          "AUDIO"
+        ],
+        "trim_frames": [
+          "n19",
+          "trim_frames"
+        ],
+        "state": [
+          "n14",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Trim — TRIM CONTEXT / AUTO-RESOLVE SCENE BLEND"
+    },
+    {
+      "key": "n29",
+      "type": "MiniMaxH3ChainSegmentSave",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n14",
+          "state"
+        ],
+        "images": [
+          "n28",
+          "images"
+        ],
+        "sampled_latent": [
+          "n25",
+          "output"
+        ],
+        "audio": [
+          "n28",
+          "audio"
+        ],
+        "images_with_overlap": [
+          "n28",
+          "images_with_overlap"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Segment + Checkpoint — SAVE DELIVERED + BLEND-READY SEGMENTS"
+    },
+    {
+      "key": "n30",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "t2v_normal_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n32",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — FINAL ASSEMBLY — 5-FRAME VISUAL BLEND"
+    },
+    {
+      "key": "n31",
+      "type": "ModelAttentionBackend",
+      "settings": {
+        "attention": "pytorch attention"
+      },
+      "inputs": {
+        "model": [
+          "n1",
+          "MODEL"
+        ]
+      },
+      "label": "ModelAttentionBackend — COMFY KITCHEN ATTENTION"
+    },
+    {
+      "key": "n32",
+      "type": "MiniMaxH3ChainLoopEnd",
+      "settings": {
+        "between_scene_cleanup": "off"
+      },
+      "inputs": {
+        "flow": [
+          "n11",
+          "flow"
+        ],
+        "state": [
+          "n14",
+          "state"
+        ],
+        "images": [
+          "n28",
+          "images"
+        ],
+        "sampled_latent": [
+          "n25",
+          "output"
+        ],
+        "segment": [
+          "n39",
+          "segment"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop End — LOOP END — ADVANCE REF2V SCENE"
+    },
+    {
+      "key": "n33",
+      "type": "Note",
+      "settings": {
+        "text": "REF2V 0.6 QUICK START\n\nCopy both courier PNGs to ComfyUI/input. The two picture references are activated as courier_arrival and greenhouse_delivery. Edit the Plan, then queue and approve each checkpointed scene."
+      },
+      "inputs": {},
+      "label": "REF2V 0.6 QUICK START"
+    },
+    {
+      "key": "n34",
+      "type": "MiniMaxH3ChainPlanModern",
+      "settings": {
+        "plan_json": "{\n  \"defaults\": {\n    \"steps\": 20\n  },\n  \"shots\": [\n    {\n      \"id\": \"reference_delivery\",\n      \"prompt\": \"subject_definitions:\\n<Picture 1> defines <Subject 1>, the exact adult bicycle courier, including his face, mustard-yellow waterproof jacket, dark teal trousers, charcoal helmet, olive messenger bag, silver bicycle, kraft parcel, proportions, and photographic rendering.\\n<Picture 2> defines the greenhouse delivery destination, including the glass structure, wooden potting table, dense plants, warm practical bulbs, wet floor reflections, and the same courier's end pose.\\n<Subject 1> is the single courier shown by both references. Preserve his identity, clothing, equipment, and scale while allowing the described movement.\\n\\nsummary:\\n[reference generation] One continuous delivery moves <Subject 1> from the wet greenhouse entrance in <Picture 1> toward the completed parcel placement in <Picture 2>.\\n\\nretention_analysis:\\n<Subject 1> (appears in [Shot 1]): fully_preserved - retain the exact face, adult age, body proportions, mustard jacket, teal trousers, helmet, bag, bicycle, and parcel across the complete shot.\\n<Picture 1>: fully_preserved - use its courier identity, wardrobe, bicycle geometry, exterior doorway, wet paving, camera height, and cool daylight as the opening state.\\n<Picture 2>: reference - use its potting table, plants, warm bulbs, interior reflections, and delivery pose as the destination; do not copy the final pose before the action reaches it.\\n\\ndetailed_description:\\n[Shot 1] Begin at the greenhouse entrance with exactly one courier and one bicycle. He walks the bicycle through the open glass door, glances down to confirm the parcel, then turns toward the wooden potting table. The camera tracks laterally at walking speed with restrained handheld movement. He stops the bicycle with his left hand and sets the parcel on the clear corner of the table with his right hand. Preserve face, hands, clothing, bicycle structure, parcel dimensions, plant layout, lighting direction, and coherent reflections. End immediately after the parcel makes contact; no cut, duplicate subject, added customer, text, logo, or early freeze.\\n\\noverall_soundscape:\\nLight rain on greenhouse glass, wet tire roll, a quiet freewheel tick, rubber soles, door hinge, jacket movement, muted ventilation, and soft cardboard contact on wood. Keep every sound synchronized and spatially plausible.\\n\\nnon_diegetic_music:\\nNo non-diegetic music.\",\n      \"length\": 243,\n      \"steps\": 20,\n      \"seed\": \"6101\"\n    },\n    {\n      \"id\": \"reference_confirmation\",\n      \"prompt\": \"subject_definitions:\\n<Picture 1> preserves the exact identity, clothing, bicycle, parcel, exterior weather, and entrance geography established before the boundary.\\n<Picture 2> defines the same greenhouse interior, potting table, plants, warm bulbs, and final delivery area.\\n<Subject 1> is the same single adult courier carried by the incoming H3 Motion Context and both references.\\n\\nsummary:\\n[reference generation] The uninterrupted delivery continues inside the greenhouse after the carried overlap and ends with the courier calmly confirming the parcel placement.\\n\\nretention_analysis:\\n<Subject 1> (appears in [Shot 1]): fully_preserved - preserve the exact face, mustard jacket, teal trousers, helmet, bag, body proportions, bicycle, and motion phase inherited from context.\\n<Picture 1>: reference - retain its cool exterior light and entrance geometry only where still visible behind the courier.\\n<Picture 2>: fully_preserved - retain the greenhouse table, plant arrangement, warm practical lights, reflections, parcel position, and photographic rendering.\\n\\ndetailed_description:\\n[Shot 1] Continue directly from the incoming H3 Motion Context. The carried opening overlap already contains the threshold crossing; begin new action only after it and never reset the stride. The courier rolls the same bicycle beside the potting table, steadies it with his left hand, and places the kraft parcel on the dry corner with his right hand. He checks the label area without showing readable text, then gives a small satisfied smile. Keep exactly one person and one bicycle, stable hands, coherent wheels, continuous camera direction, and consistent light. No cut, duplicate, wardrobe change, or early freeze.\\n\\noverall_soundscape:\\nContinue rain-muted greenhouse ambience, footsteps, tire roll, freewheel ticks, clothing movement, ventilation, and the soft parcel contact without restarting any sound at the scene boundary.\\n\\nnon_diegetic_music:\\nNo non-diegetic music.\",\n      \"length\": 243,\n      \"steps\": 20,\n      \"seed\": \"6102\"\n    }\n  ]\n}",
+        "run_name": "ref2v_basic_minimax_h3_0_6_json",
+        "generation_fingerprint": "h3-v06-release-example",
+        "width": 896,
+        "height": 672,
+        "encode_mode": "video",
+        "crop": "disabled",
+        "default_duration_seconds": 10.0,
+        "default_steps": 20,
+        "base_seed": 0,
+        "segment_crf": 20,
+        "video_blend_frames": 0
+      },
+      "inputs": {
+        "chain_policy": [
+          "n41",
+          "chain_policy"
+        ]
+      },
+      "label": "MiniMax H3 Production Plan — 0.6 SCENE COLUMNS"
+    },
+    {
+      "key": "n35",
+      "type": "MiniMaxH3ChainManifestLoad",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n7",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Load Manifest — RECOVERY: LOAD ALL SAVED CLIPS",
+      "mode": 2
+    },
+    {
+      "key": "n36",
+      "type": "Note",
+      "settings": {
+        "text": "The two amber recovery nodes are MUTED by default.\n\nIf all segments finished but final assembly did not, mute the main green Assemble node, enable both recovery nodes, and queue. They validate every SHA-256 checkpoint pair and assemble without rerendering the completed clips.\n\nFor an interrupted generation, leave recovery muted and set Loop Start's start_clip to the first unfinished clip."
+      },
+      "inputs": {},
+      "label": "Note — RECOVERY / ASSEMBLE LATER"
+    },
+    {
+      "key": "n37",
+      "type": "LoadImage",
+      "settings": {
+        "image": "h3_v06_courier_greenhouse_arrival.png"
+      },
+      "inputs": {},
+      "label": "Load Image — 0.6 COURIER ARRIVAL"
+    },
+    {
+      "key": "n38",
+      "type": "LoadImage",
+      "settings": {
+        "image": "h3_v06_courier_greenhouse_delivery.png"
+      },
+      "inputs": {},
+      "label": "Load Image — 0.6 GREENHOUSE DELIVERY"
+    },
+    {
+      "key": "n39",
+      "type": "MiniMaxH3ChainReview",
+      "settings": {
+        "enabled": true,
+        "play_notification_sound": false,
+        "auto_continue_timeout_minutes": 0,
+        "unload_models_while_waiting": false,
+        "assemble_partial_on_stop": true,
+        "partial_audio_source": "checkpointed",
+        "candidate_count": 1,
+        "review_each_candidate": false
+      },
+      "inputs": {
+        "state": [
+          "n14",
+          "state"
+        ],
+        "segment": [
+          "n29",
+          "segment"
+        ],
+        "audio": [
+          "n28",
+          "audio"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Review Gate — REVIEW GATE — APPROVE / EDIT+RETRY / REROLL / STOP"
+    },
+    {
+      "key": "n40",
+      "type": "MiniMaxH3ChainPreflight",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true
+      },
+      "inputs": {
+        "plan": [
+          "n7",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Chain Preflight — 0.6 PREFLIGHT — BLOCKS BEFORE MODELS"
+    },
+    {
+      "key": "n41",
+      "type": "MiniMaxH3GenerationProfile",
+      "settings": {
+        "scene_continuity": "Visual continuity",
+        "audio_profile": "Generate audio"
+      },
+      "inputs": {},
+      "label": "MiniMax H3 Generation Profile — RELEASE DEFAULTS"
+    }
+  ]
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Ref2V Masked Video Inpaint - MiniMax H3 0.6.json b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Ref2V Masked Video Inpaint - MiniMax H3 0.6.json
new file mode 100644
index 0000000000000000000000000000000000000000..8d60a91f0a59b4b146abcb57899c2aacdd94a16d
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Ref2V Masked Video Inpaint - MiniMax H3 0.6.json	
@@ -0,0 +1,798 @@
+{
+  "nodes": [
+    {
+      "key": "core_source_note",
+      "type": "Note",
+      "settings": {
+        "text": "CORE SOURCE VIDEO\n\nLoad Video feeds Get Video Components. Keep all three images, audio, and fps outputs connected to Loop Source AV Target: that node converts the native source rate to H3's 24 fps and fits each scene to the Plan canvas. Do not replace the fps connection with a fixed 24 for non-24-fps input. The included single-frame mask is broadcast across the scene; if using a tracked mask video, supply that mask's actual source frame rate to Mask Slice."
+      },
+      "inputs": {}
+    },
+    {
+      "key": "n1",
+      "type": "UNETLoader",
+      "settings": {
+        "unet_name": "minimax_h3_ref2va_pruned_int8_convrot.safetensors",
+        "weight_dtype": "default"
+      },
+      "inputs": {},
+      "label": "Load Diffusion Model — H3 MODEL — REQUIRED"
+    },
+    {
+      "key": "n2",
+      "type": "CLIPLoader",
+      "settings": {
+        "clip_name": "qwen3vl_32b_minimax_h3_int8_convrot.safetensors",
+        "type": "minimax",
+        "device": "default"
+      },
+      "inputs": {},
+      "label": "Load CLIP — H3 TEXT ENCODER"
+    },
+    {
+      "key": "n3",
+      "type": "KSamplerSelect",
+      "settings": {
+        "sampler_name": "res_multistep"
+      },
+      "inputs": {},
+      "label": "KSamplerSelect — Sampler algorithm"
+    },
+    {
+      "key": "n4",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_video_vae_fp16.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Video VAE"
+    },
+    {
+      "key": "n5",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_audio_vae_fp32.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Audio VAE"
+    },
+    {
+      "key": "n6",
+      "type": "Note",
+      "settings": {
+        "text": "SOURCE ASSETS — CC0\n\nLight-blue soldier crabs on Bribie Island, filmed in 2015 by Watermark Resort Caloundra. Wikimedia Commons records the video as CC0 1.0.\n\nhttps://commons.wikimedia.org/wiki/File:Light-blue_soldier_crabs_on_Bribie_Island.webm\n\nCopy soldier_crabs_bribie_island_cc0.webm, soldier_crabs_inpaint_mask.png, and soldier_crabs_reference_cc0.png from example_workflows/assets/ to ComfyUI/input/.\n\nABLEJONES / DROZ V3.1 MAPPING\n\nApply Target Mask in H3 exact mode implements the same H3 auto + max / max causal-token mask contract as MVEx Mask To Latent Space. The pack-native Loop Source AV Target replaces separate VAEEncode, SetLatentNoiseMask, and LTXVConcatAVLatent wiring. Subject Crop / Uncrop remains an optional external efficiency and compositing stage, not a requirement for correct masked H3 sampling."
+      },
+      "inputs": {},
+      "label": "Note — CC0 ASSETS + ABLEJONES V3.1 COMPATIBILITY"
+    },
+    {
+      "key": "n7",
+      "type": "Note",
+      "settings": {
+        "text": "REF2VA MASKED-EDIT PROMPT FORMAT\n\nUse these six fields in order: subject_definitions, summary, retention_analysis, detailed_description, overall_soundscape, and non_diegetic_music.\n\nPicture 1 defines only the replacement appearance. The movie remains the real masked target latent and is intentionally not connected a second time as a Ref2VA video. The source target supplies motion, camera, protected pixels, and synchronized audio; the picture supplies subject appearance."
+      },
+      "inputs": {},
+      "label": "Note — REF2VA MASKED-EDIT PROMPT FORMAT"
+    },
+    {
+      "key": "n10",
+      "type": "MiniMaxH3ChainLoopStart",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true
+      },
+      "inputs": {
+        "plan": [
+          "n33",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Start — LOOP START — NO EXTERNAL CONTINUATION"
+    },
+    {
+      "key": "n13",
+      "type": "MiniMaxH3ChainCurrent",
+      "settings": {
+        "align_audio_reference": false
+      },
+      "inputs": {
+        "state": [
+          "n10",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Current Shot — CURRENT REF2V EDIT SCENE — PROMPT / SEED / TIMING"
+    },
+    {
+      "key": "n14",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "cc0_soldier_crabs_ref2v_inpaint_recovered_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n34",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — RECOVERY: ASSEMBLE WITHOUT RENDERING",
+      "mode": 2
+    },
+    {
+      "key": "n16",
+      "type": "RandomNoise",
+      "settings": {
+        "noise_seed": 0,
+        "control_after_generate": "fixed"
+      },
+      "inputs": {
+        "noise_seed": [
+          "n13",
+          "noise_seed"
+        ]
+      },
+      "label": "RandomNoise — Per-shot noise seed"
+    },
+    {
+      "key": "n17",
+      "type": "MiniMaxH3ReferenceToVideo",
+      "settings": {
+        "prompt": "subject_definitions:\n<Subject 1> is the adult light-blue soldier crab appearance defined by <Picture 1>: a glossy deep cobalt-blue oval carapace, pale sand-tan jointed legs, paired raised claws, small black eye stalks, realistic wet-shell highlights, and natural animal proportions.\n\nsummary:\n[reference generation + video editing + audio reuse] The target video is a spatially masked edit of the supplied source target. Only the crabs inside the editable lower-central beach region are rebuilt as clear, photorealistic instances of <Subject 1>; the protected source picture, performance, environment, and camera remain unchanged, and the synchronized source soundtrack is reused in full.\n\nretention_analysis:\n<Subject 1> (appears in [Shot 1]): fully_preserved - retain the referenced cobalt-blue carapace, sand-tan legs, raised claws, black eye stalks, wet-shell texture, realistic scale, and natural soldier-crab anatomy wherever the masked replacement is visible.\n\ndetailed_description:\nThe target remains live-action natural-history footage with the same cloudy coastal daylight, documentary optics, and realistic color response as the protected source.\n[Shot 1] Treat the supplied source target as the authoritative edit plate. Preserve its original camera trajectory, lens behavior, framing, cloudy lighting, sand, shallow water, distant shoreline, depth of field, source motion timing, and every protected pixel. Inside the editable lower-central beach region only, rebuild the visible moving crabs as coherent instances of <Subject 1> from <Picture 1>. The source frames supply each selected crab's position, grounded lateral movement, action phase, speed, perspective, scale, occlusion timing, and motion blur; <Picture 1> supplies the visible species anatomy, shell color, leg color, claw shape, eyes, and wet surface detail. Keep feet in contact with the sand and water, reproduce plausible contact shadows and tiny reflections, and maintain stable anatomy from frame to frame. Blend the generated animals cleanly into the protected plate without a halo, border flicker, duplicated limbs, or changes to nearby unmasked crabs. Do not introduce sculptures, stylization, text, a new camera move, a new background, or a cut.\n\noverall_soundscape:\nReuse the protected synchronized source soundtrack exactly as the complete final soundtrack. Generate no replacement sound.\n\nnon_diegetic_music:\nN/A",
+        "width": 960,
+        "height": 544,
+        "length": 175,
+        "ref_image_size": "match"
+      },
+      "inputs": {
+        "clip": [
+          "n2",
+          "CLIP"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "audio_vae": [
+          "n5",
+          "VAE"
+        ],
+        "ref_images.ref_image_0": [
+          "n47",
+          "IMAGE"
+        ],
+        "prompt": [
+          "n13",
+          "prompt"
+        ],
+        "width": [
+          "n13",
+          "width"
+        ],
+        "height": [
+          "n13",
+          "height"
+        ],
+        "length": [
+          "n13",
+          "length"
+        ]
+      },
+      "label": "MiniMax H3 Reference to Video — CORE H3 REF2VA — PICTURE + MASKED SOURCE TARGET"
+    },
+    {
+      "key": "n18",
+      "type": "MiniMaxH3ChainContext",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n13",
+          "state"
+        ],
+        "conditioning": [
+          "n17",
+          "positive"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "latent": [
+          "n40",
+          "source_target"
+        ],
+        "audio_vae": [
+          "n5",
+          "VAE"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Context — AUTO CONTEXT — clip 1 bypass / continuation"
+    },
+    {
+      "key": "n19",
+      "type": "MiniMaxH3SigmaShift",
+      "settings": {
+        "shift_video": 12,
+        "shift_audio": 3
+      },
+      "inputs": {
+        "model": [
+          "n30",
+          "MODEL"
+        ]
+      }
+    },
+    {
+      "key": "n22",
+      "type": "BasicGuider",
+      "settings": {},
+      "inputs": {
+        "model": [
+          "n19",
+          "MODEL"
+        ],
+        "conditioning": [
+          "n18",
+          "conditioning"
+        ]
+      },
+      "label": "Basic Guider — Loop guider"
+    },
+    {
+      "key": "n23",
+      "type": "BasicScheduler",
+      "settings": {
+        "scheduler": "simple",
+        "steps": 20,
+        "denoise": 1
+      },
+      "inputs": {
+        "model": [
+          "n19",
+          "MODEL"
+        ],
+        "steps": [
+          "n13",
+          "steps"
+        ]
+      },
+      "label": "BasicScheduler — Per-shot scheduler steps"
+    },
+    {
+      "key": "n24",
+      "type": "SamplerCustomAdvanced",
+      "settings": {},
+      "inputs": {
+        "noise": [
+          "n16",
+          "NOISE"
+        ],
+        "guider": [
+          "n22",
+          "GUIDER"
+        ],
+        "sampler": [
+          "n3",
+          "SAMPLER"
+        ],
+        "sigmas": [
+          "n23",
+          "SIGMAS"
+        ],
+        "latent_image": [
+          "n41",
+          "masked_target"
+        ]
+      },
+      "label": "SamplerCustomAdvanced — H3 sampler — SINGLE LOOP BODY"
+    },
+    {
+      "key": "n25",
+      "type": "VAEDecode",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n24",
+          "output"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode — Decode current clip frames"
+    },
+    {
+      "key": "n26",
+      "type": "VAEDecodeAudio",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n24",
+          "output"
+        ],
+        "vae": [
+          "n5",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode Audio — Decode current clip audio"
+    },
+    {
+      "key": "n27",
+      "type": "MiniMaxH3LoopTrim",
+      "settings": {
+        "trim_frames": 0,
+        "fps": 24,
+        "match_tail": true,
+        "retain_overlap_frames": 5
+      },
+      "inputs": {
+        "images": [
+          "n25",
+          "IMAGE"
+        ],
+        "audio": [
+          "n26",
+          "AUDIO"
+        ],
+        "trim_frames": [
+          "n18",
+          "trim_frames"
+        ],
+        "state": [
+          "n13",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Trim — TRIM CONTEXT / AUTO-RESOLVE SCENE BLEND"
+    },
+    {
+      "key": "n28",
+      "type": "MiniMaxH3ChainSegmentSave",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n13",
+          "state"
+        ],
+        "images": [
+          "n27",
+          "images"
+        ],
+        "sampled_latent": [
+          "n24",
+          "output"
+        ],
+        "audio": [
+          "n27",
+          "audio"
+        ],
+        "images_with_overlap": [
+          "n27",
+          "images_with_overlap"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Segment + Checkpoint — SAVE DELIVERED + BLEND-READY SEGMENTS"
+    },
+    {
+      "key": "n29",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "cc0_soldier_crabs_ref2v_inpaint_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n36",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — FINAL ASSEMBLY — 5-FRAME VISUAL BLEND"
+    },
+    {
+      "key": "n30",
+      "type": "ModelAttentionBackend",
+      "settings": {
+        "attention": "pytorch attention"
+      },
+      "inputs": {
+        "model": [
+          "n1",
+          "MODEL"
+        ]
+      },
+      "label": "ModelAttentionBackend — COMFY KITCHEN ATTENTION"
+    },
+    {
+      "key": "n31",
+      "type": "MiniMaxH3ChainRichScenePromptEditor",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n33",
+          "plan"
+        ]
+      }
+    },
+    {
+      "key": "n32",
+      "type": "MiniMaxH3ChainPlanModern",
+      "settings": {
+        "plan_json": "{\n  \"defaults\": {\n    \"length\": 175,\n    \"steps\": 20\n  },\n  \"shots\": [\n    {\n      \"id\": \"ref2v_masked_inpaint_a\",\n      \"prompt\": \"subject_definitions:\\n<Subject 1> is the adult light-blue soldier crab appearance defined by <Picture 1>: a glossy deep cobalt-blue oval carapace, pale sand-tan jointed legs, paired raised claws, small black eye stalks, realistic wet-shell highlights, and natural animal proportions.\\n\\nsummary:\\n[reference generation + video editing + audio reuse] The target video is a spatially masked edit of the supplied source target. Only the crabs inside the editable lower-central beach region are rebuilt as clear, photorealistic instances of <Subject 1>; the protected source picture, performance, environment, and camera remain unchanged, and the synchronized source soundtrack is reused in full.\\n\\nretention_analysis:\\n<Subject 1> (appears in [Shot 1]): fully_preserved - retain the referenced cobalt-blue carapace, sand-tan legs, raised claws, black eye stalks, wet-shell texture, realistic scale, and natural soldier-crab anatomy wherever the masked replacement is visible.\\n\\ndetailed_description:\\nThe target remains live-action natural-history footage with the same cloudy coastal daylight, documentary optics, and realistic color response as the protected source.\\n[Shot 1] Treat the supplied source target as the authoritative edit plate. Preserve its original camera trajectory, lens behavior, framing, cloudy lighting, sand, shallow water, distant shoreline, depth of field, source motion timing, and every protected pixel. Inside the editable lower-central beach region only, rebuild the visible moving crabs as coherent instances of <Subject 1> from <Picture 1>. The source frames supply each selected crab's position, grounded lateral movement, action phase, speed, perspective, scale, occlusion timing, and motion blur; <Picture 1> supplies the visible species anatomy, shell color, leg color, claw shape, eyes, and wet surface detail. Keep feet in contact with the sand and water, reproduce plausible contact shadows and tiny reflections, and maintain stable anatomy from frame to frame. Blend the generated animals cleanly into the protected plate without a halo, border flicker, duplicated limbs, or changes to nearby unmasked crabs. Do not introduce sculptures, stylization, text, a new camera move, a new background, or a cut.\\n\\noverall_soundscape:\\nReuse the protected synchronized source soundtrack exactly as the complete final soundtrack. Generate no replacement sound.\\n\\nnon_diegetic_music:\\nN/A\",\n      \"length\": 175,\n      \"steps\": 20,\n      \"seed\": \"24051621\"\n    },\n    {\n      \"id\": \"ref2v_masked_inpaint_b\",\n      \"prompt\": \"subject_definitions:\\n<Subject 1> is the same adult light-blue soldier crab appearance defined by <Picture 1> and established in the protected incoming overlap: a glossy deep cobalt-blue oval carapace, pale sand-tan jointed legs, paired raised claws, small black eye stalks, realistic wet-shell highlights, and natural animal proportions.\\n\\nsummary:\\n[reference generation + video editing + audio reuse] The target video continues the spatially masked edit of the supplied source target directly from the protected incoming overlap. Keep the same <Subject 1> identity inside the editable lower-central beach region while the protected source picture, performance, environment, and camera remain unchanged, and the synchronized source soundtrack is reused in full.\\n\\nretention_analysis:\\n<Subject 1> (appears in [Shot 1]): fully_preserved - carry forward the exact crab anatomy, cobalt-blue shell, sand-tan legs, claws, eyes, wet texture, scale, and frame-to-frame identity already visible at the incoming boundary.\\n\\ndetailed_description:\\nThe target continues the same live-action natural-history shot without a cut or visual reset.\\n[Shot 1] Begin from the protected incoming overlap exactly as supplied. Do not alter its crab identities, action phase, camera position, lens behavior, framing, cloudy coastal light, sand, water, shoreline, depth of field, or motion blur. As the supplied source target advances, edit only the lower-central masked region. Continue rendering every selected moving crab as the same coherent <Subject 1> established from <Picture 1> and the incoming frames. The corresponding source frames remain authoritative for position, grounded lateral motion, speed, pose, perspective, scale, occlusion timing, sand contact, and interaction with shallow water. Preserve the referenced cobalt-blue carapace, sand-tan legs, raised claws, black eye stalks, realistic shell highlights, and stable anatomy throughout the new frames. Maintain clean contact shadows and reflections and cross the end of the protected overlap with no identity jump, brightness pulse, outline flicker, duplicated limb, temporal stall, or camera change. Preserve every protected pixel and every unmasked crab. Do not introduce a new background, stylization, text, or a cut.\\n\\noverall_soundscape:\\nReuse the protected synchronized source soundtrack exactly as the complete final soundtrack. Generate no replacement sound.\\n\\nnon_diegetic_music:\\nN/A\",\n      \"length\": 175,\n      \"steps\": 20,\n      \"seed\": \"24051622\"\n    }\n  ]\n}",
+        "run_name": "ref2v_masked_video_inpaint_minimax_h3_0_6_json",
+        "generation_fingerprint": "h3-v06-release-example",
+        "width": 960,
+        "height": 544,
+        "encode_mode": "video",
+        "crop": "center",
+        "default_duration_seconds": 8.0,
+        "default_steps": 20,
+        "base_seed": 0,
+        "segment_crf": 20,
+        "video_blend_frames": 5
+      },
+      "inputs": {
+        "chain_policy": [
+          "n48",
+          "chain_policy"
+        ],
+        "project_assets": [
+          "n49",
+          "project_assets"
+        ]
+      },
+      "label": "MiniMax H3 Production Plan — 0.6 SCENE COLUMNS"
+    },
+    {
+      "key": "n33",
+      "type": "MiniMaxH3ChainPlanStudio",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true,
+        "plan_json": "{\n  \"shots\": [\n    {\n      \"id\": \"intro\",\n      \"prompt\": \"Describe the opening shot.\"\n    },\n    {\n      \"id\": \"continuation\",\n      \"prompt\": \"Continue the same take.\"\n    }\n  ]\n}",
+        "run_name": "h3_chain",
+        "generation_fingerprint": "",
+        "width": 960,
+        "height": 544,
+        "context_length": 22,
+        "encode_mode": "video",
+        "anchor_mode": "head",
+        "crop": "disabled",
+        "audio_mode": "generated_audio",
+        "audio_context_length": 22,
+        "default_duration_seconds": 15.0,
+        "default_steps": 20,
+        "base_seed": 0,
+        "segment_crf": 18,
+        "video_blend_frames": 0,
+        "continuation_mode": "guide",
+        "alternate_take_json": ""
+      },
+      "inputs": {
+        "plan": [
+          "n32",
+          "plan"
+        ],
+        "tagged_references": [
+          "n49",
+          "references"
+        ],
+        "project_assets": [
+          "n49",
+          "project_assets"
+        ]
+      },
+      "label": "MiniMax H3 Plan Studio — TIMELINE / TAKES / TRIMS"
+    },
+    {
+      "key": "n34",
+      "type": "MiniMaxH3ChainManifestLoad",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n33",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Load Manifest — RECOVERY: LOAD ALL SAVED CLIPS",
+      "mode": 2
+    },
+    {
+      "key": "n35",
+      "type": "Note",
+      "settings": {
+        "text": "The two amber recovery nodes are MUTED by default.\n\nIf all segments finished but final assembly did not, mute the main green Assemble node, enable both recovery nodes, and queue. They validate every SHA-256 checkpoint pair and assemble without rerendering the completed clips.\n\nFor an interrupted generation, leave recovery muted and set Loop Start's start_clip to the first unfinished clip."
+      },
+      "inputs": {},
+      "label": "Note — RECOVERY / ASSEMBLE LATER"
+    },
+    {
+      "key": "n36",
+      "type": "MiniMaxH3ChainLoopEnd",
+      "settings": {
+        "between_scene_cleanup": "off"
+      },
+      "inputs": {
+        "flow": [
+          "n10",
+          "flow"
+        ],
+        "state": [
+          "n13",
+          "state"
+        ],
+        "images": [
+          "n27",
+          "images"
+        ],
+        "sampled_latent": [
+          "n24",
+          "output"
+        ],
+        "segment": [
+          "n37",
+          "segment"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop End — LOOP END — ADVANCE T2V SCENE"
+    },
+    {
+      "key": "n37",
+      "type": "MiniMaxH3ChainReview",
+      "settings": {
+        "enabled": true,
+        "play_notification_sound": false,
+        "auto_continue_timeout_minutes": 0,
+        "unload_models_while_waiting": false,
+        "assemble_partial_on_stop": true,
+        "partial_audio_source": "checkpointed",
+        "candidate_count": 1,
+        "review_each_candidate": false
+      },
+      "inputs": {
+        "state": [
+          "n13",
+          "state"
+        ],
+        "segment": [
+          "n28",
+          "segment"
+        ],
+        "audio": [
+          "n27",
+          "audio"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Review Gate — REVIEW GATE — APPROVE / EDIT+RETRY / REROLL / STOP"
+    },
+    {
+      "key": "n38",
+      "type": "Note",
+      "settings": {
+        "text": "REF2V MASKED VIDEO INPAINT — CHAIN LOOP\n\nThis is the picture-conditioned counterpart to the T2VA masked-inpaint demo. Picture 1 supplies the species appearance; the source video is encoded as the actual joint AV target. Do not connect the source video again as ref_video_0.\n\nTwo 175-frame generations share a 39-frame protected overlap and deliver 311 frames. Scene 1 selects source frames 0..174; scene 2 selects 136..310. Loop Source AV Target aligns picture and sound to the stock Ref2VA target grid. Chain Context preserves the accepted edited overlap. Apply Target Mask then intersects that temporal protection with the spatial edit mask, so preservation wins.\n\nThe bundled one-frame mask is broadcast. Replace it with a tracked MASK batch for moving subjects; Loop Mask Slice selects the corresponding source interval automatically. Grid Preview shows the exact H3 causal and 32px token coverage before sampling. Source audio remains protected."
+      },
+      "inputs": {},
+      "label": "Note — REF2V MASKED INPAINT — HOW TO USE"
+    },
+    {
+      "key": "n39",
+      "type": "LoadVideo",
+      "settings": {
+        "file": "soldier_crabs_bribie_island_cc0.webm"
+      },
+      "inputs": {},
+      "label": "Source Video — CC0 Soldier Crabs"
+    },
+    {
+      "key": "source_components",
+      "type": "GetVideoComponents",
+      "settings": {},
+      "inputs": {"video": ["n39", "VIDEO"]}
+    },
+    {
+      "key": "n40",
+      "type": "MiniMaxH3ContexLoopSourceAVTarget",
+      "settings": {
+        "source_fps": 24,
+        "crop": "center"
+      },
+      "inputs": {
+        "state": [
+          "n13",
+          "state"
+        ],
+        "latent": [
+          "n17",
+          "LATENT"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "audio_vae": [
+          "n5",
+          "VAE"
+        ],
+        "source_frames": [
+          "source_components",
+          "images"
+        ],
+        "source_audio": [
+          "source_components",
+          "audio"
+        ],
+        "source_fps": [
+          "source_components",
+          "fps"
+        ]
+      },
+      "label": "MiniMax H3 Masking · Loop Source AV Target — FRAME-LOCK CURRENT LOOP SCENE TO SOURCE AV"
+    },
+    {
+      "key": "n41",
+      "type": "MiniMaxH3ContexMaskedTarget",
+      "settings": {
+        "mask_meaning": "white = generate",
+        "audio_mode": "preserve source audio",
+        "mask_conversion": "H3 exact (causal/token max)"
+      },
+      "inputs": {
+        "target_latent": [
+          "n18",
+          "latent"
+        ],
+        "mask": [
+          "n43",
+          "snapped_mask"
+        ]
+      },
+      "label": "MiniMax H3 Masking · Apply Target Mask — APPLY EXACT SPATIAL MASK — SOURCE AUDIO PRESERVED"
+    },
+    {
+      "key": "n42",
+      "type": "LoadImageMask",
+      "settings": {
+        "image": "soldier_crabs_inpaint_mask.png",
+        "channel": "red"
+      },
+      "inputs": {},
+      "label": "Load Image (as Mask) — STATIC MASK — REPLACE WITH TRACKED MASK BATCH"
+    },
+    {
+      "key": "n43",
+      "type": "MiniMaxH3ContexMaskGridPreview",
+      "settings": {
+        "cell_selection": "runtime exact (latent max)",
+        "cell_adjust": 0,
+        "preview_frame": 0,
+        "overlay_opacity": 0.38,
+        "show_grid": true,
+        "show_source_outline": true,
+        "mask_meaning": "white = generate"
+      },
+      "inputs": {
+        "image": [
+          "n40",
+          "scene_frames"
+        ],
+        "mask": [
+          "n46",
+          "scene_mask"
+        ]
+      },
+      "label": "MiniMax H3 Masking · Grid Preview — PREVIEW EXACT H3 32PX MASK CELLS"
+    },
+    {
+      "key": "n44",
+      "type": "PreviewImage",
+      "settings": {},
+      "inputs": {
+        "images": [
+          "n43",
+          "grid_preview"
+        ]
+      },
+      "label": "Preview Image — Verify generated 32×32 cells"
+    },
+    {
+      "key": "n45",
+      "type": "PreviewAny",
+      "settings": {},
+      "inputs": {
+        "source": [
+          "n40",
+          "status"
+        ]
+      },
+      "label": "Preview as Text — SOURCE AV ALIGNMENT STATUS"
+    },
+    {
+      "key": "n46",
+      "type": "MiniMaxH3ContexLoopMaskSlice",
+      "settings": {
+        "source_fps": 24
+      },
+      "inputs": {
+        "state": [
+          "n13",
+          "state"
+        ],
+        "mask": [
+          "n42",
+          "MASK"
+        ]
+      },
+      "label": "MiniMax H3 Masking · Loop Mask Slice — SLICE TRACKED MASK TO CURRENT LOOP SCENE"
+    },
+    {
+      "key": "n47",
+      "type": "LoadImage",
+      "settings": {
+        "image": "soldier_crabs_reference_cc0.png"
+      },
+      "inputs": {},
+      "label": "Load Image — <Picture 1> — CC0 SOLDIER CRAB APPEARANCE"
+    },
+    {
+      "key": "n48",
+      "type": "MiniMaxH3GenerationProfile",
+      "settings": {
+        "scene_continuity": "Hard picture + protected audio",
+        "audio_profile": "Generate audio"
+      },
+      "inputs": {},
+      "label": "MiniMax H3 Generation Profile — RELEASE DEFAULTS"
+    },
+    {
+      "key": "n49",
+      "type": "MiniMaxH3ProjectAssetManager",
+      "settings": {
+        "run_name": "ref2v_masked_video_inpaint_minimax_h3_0_6_json",
+        "catalog_json": "",
+        "semantic_anchor_size": "512",
+        "semantic_anchor_mode": "timestamped_video",
+        "operation_json": ""
+      },
+      "inputs": {},
+      "label": "MiniMax H3 Project Asset Carousel — IMPORT RELEASE REFERENCES"
+    },
+    {
+      "key": "n50",
+      "type": "MiniMaxH3ChainCheckpointManager",
+      "settings": {
+        "selection_json": ""
+      },
+      "inputs": {
+        "plan": [
+          "n33",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Checkpoint Manager — BRANCHES / PREVIEWS / RESTORE"
+    },
+    {
+      "key": "n51",
+      "type": "Note",
+      "settings": {
+        "text": "0.6 Studio quick start\n\n1. Open the Project Asset Carousel.\n2. Keep the bundled source media selected in the existing loader nodes; use the Carousel for additional project assets.\n3. Edit scenes in Production Plan or Plan Studio.\n4. Queue; inspect, branch, trim, or restore in Checkpoint Manager."
+      },
+      "inputs": {},
+      "label": "0.6 STUDIO QUICK START"
+    }
+  ]
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Ref2V Sequential Motion - EXPERIMENTAL - MiniMax H3 0.6.json b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Ref2V Sequential Motion - EXPERIMENTAL - MiniMax H3 0.6.json
new file mode 100644
index 0000000000000000000000000000000000000000..083e4fb7b40439c3efa3c0c5d11c1924ffcc1fb8
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Ref2V Sequential Motion - EXPERIMENTAL - MiniMax H3 0.6.json	
@@ -0,0 +1,699 @@
+{
+  "nodes": [
+    {
+      "key": "n1",
+      "type": "UNETLoader",
+      "settings": {
+        "unet_name": "minimax_h3_ref2va_pruned_int8_convrot.safetensors",
+        "weight_dtype": "default"
+      },
+      "inputs": {},
+      "label": "Load Diffusion Model — H3 MODEL — REQUIRED"
+    },
+    {
+      "key": "n2",
+      "type": "CLIPLoader",
+      "settings": {
+        "clip_name": "qwen3vl_32b_minimax_h3_int8_convrot.safetensors",
+        "type": "minimax",
+        "device": "default"
+      },
+      "inputs": {},
+      "label": "Load CLIP — H3 TEXT ENCODER"
+    },
+    {
+      "key": "n3",
+      "type": "KSamplerSelect",
+      "settings": {
+        "sampler_name": "res_multistep"
+      },
+      "inputs": {},
+      "label": "KSamplerSelect — Sampler algorithm"
+    },
+    {
+      "key": "n4",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_video_vae_fp16.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Video VAE"
+    },
+    {
+      "key": "n5",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_audio_vae_fp32.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Audio VAE"
+    },
+    {
+      "key": "n6",
+      "type": "Note",
+      "settings": {
+        "text": "0.6 ORIGINAL REFERENCE EXAMPLE\n\nThe matching courier and greenhouse pictures were generated specifically for this catalog. They replace the old community demonstration assets and prompts."
+      },
+      "inputs": {},
+      "label": "0.6 ORIGINAL REFERENCE EXAMPLE"
+    },
+    {
+      "key": "n7",
+      "type": "MiniMaxH3ChainScenePromptEditor",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n34",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Scene Prompt Editor — SCENE PROMPT EDITOR — STANDARD AUTHORING"
+    },
+    {
+      "key": "n8",
+      "type": "Note",
+      "settings": {
+        "text": "REF2VA PROMPT FORMAT — SIX SECTIONS\n\nKeep subject_definitions, summary, retention_analysis, detailed_description, overall_soundscape, and non_diegetic_music in that order. References define identity; the prompt defines the new action."
+      },
+      "inputs": {},
+      "label": "REF2VA PROMPT FORMAT — SIX SECTIONS"
+    },
+    {
+      "key": "n11",
+      "type": "MiniMaxH3ChainLoopStart",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true
+      },
+      "inputs": {
+        "plan": [
+          "n46",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Start — LOOP START / RESUME"
+    },
+    {
+      "key": "n14",
+      "type": "MiniMaxH3ChainCurrent",
+      "settings": {
+        "align_audio_reference": false
+      },
+      "inputs": {
+        "state": [
+          "n11",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Current Shot — CURRENT REF2V SCENE — PROMPT / SEED / TIMING"
+    },
+    {
+      "key": "n15",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "t2v_normal_recovered_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n36",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — RECOVERY: ASSEMBLE WITHOUT RENDERING",
+      "mode": 2
+    },
+    {
+      "key": "n17",
+      "type": "RandomNoise",
+      "settings": {
+        "noise_seed": 0,
+        "control_after_generate": "fixed"
+      },
+      "inputs": {
+        "noise_seed": [
+          "n14",
+          "noise_seed"
+        ]
+      },
+      "label": "RandomNoise — Per-shot noise seed"
+    },
+    {
+      "key": "n18",
+      "type": "MiniMaxH3TaggedReferenceToVideo",
+      "settings": {
+        "clip_index": 1,
+        "clip_count": 2,
+        "prompt": "subject_definitions:\n@courier_arrival defines <Subject 1>, the exact adult bicycle courier, including his face, mustard-yellow waterproof jacket, dark teal trousers, charcoal helmet, olive messenger bag, silver bicycle, kraft parcel, proportions, and photographic rendering.\n@greenhouse_delivery defines the greenhouse delivery destination, including the glass structure, wooden potting table, dense plants, warm practical bulbs, wet floor reflections, and the same courier's end pose.\n@courier_motion is a motion-only guide for the walk, turn, and parcel placement; it must not replace the courier's appearance. @courier_motion_audio is its synchronized embedded sound guide.\n<Subject 1> is the single courier shown by both references. Preserve his identity, clothing, equipment, and scale while allowing the described movement.\n\nsummary:\n[reference generation] One continuous delivery moves <Subject 1> from the wet greenhouse entrance in @courier_arrival toward the completed parcel placement in @greenhouse_delivery.\n\nretention_analysis:\n<Subject 1> (appears in [Shot 1]): fully_preserved - retain the exact face, adult age, body proportions, mustard jacket, teal trousers, helmet, bag, bicycle, and parcel across the complete shot.\n@courier_arrival: fully_preserved - use its courier identity, wardrobe, bicycle geometry, exterior doorway, wet paving, camera height, and cool daylight as the opening state.\n@greenhouse_delivery: reference - use its potting table, plants, warm bulbs, interior reflections, and delivery pose as the destination; do not copy the final pose before the action reaches it.\n\ndetailed_description:\n[Shot 1] Begin at the greenhouse entrance with exactly one courier and one bicycle. He walks the bicycle through the open glass door, glances down to confirm the parcel, then turns toward the wooden potting table. The camera tracks laterally at walking speed with restrained handheld movement. He stops the bicycle with his left hand and sets the parcel on the clear corner of the table with his right hand. Preserve face, hands, clothing, bicycle structure, parcel dimensions, plant layout, lighting direction, and coherent reflections. End immediately after the parcel makes contact; no cut, duplicate subject, added customer, text, logo, or early freeze.\n\noverall_soundscape:\nLight rain on greenhouse glass, wet tire roll, a quiet freewheel tick, rubber soles, door hinge, jacket movement, muted ventilation, and soft cardboard contact on wood. Keep every sound synchronized and spatially plausible.\n\nnon_diegetic_music:\nNo non-diegetic music.",
+        "width": 896,
+        "height": 672,
+        "length": 243,
+        "ref_image_size": "match",
+        "reference_policy": "strict",
+        "semantic_anchor_size": "512",
+        "semantic_anchor_mode": "timestamped_video",
+        "cache_for_upscale": true,
+        "conditioning_backend": "native_ref2va"
+      },
+      "inputs": {
+        "clip": [
+          "n2",
+          "CLIP"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "audio_vae": [
+          "n5",
+          "VAE"
+        ],
+        "references": [
+          "n44",
+          "references"
+        ],
+        "clip_index": [
+          "n14",
+          "clip_index"
+        ],
+        "clip_count": [
+          "n14",
+          "clip_count"
+        ],
+        "prompt": [
+          "n14",
+          "prompt"
+        ],
+        "width": [
+          "n14",
+          "width"
+        ],
+        "height": [
+          "n14",
+          "height"
+        ],
+        "length": [
+          "n14",
+          "length"
+        ],
+        "state": [
+          "n14",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Tagged Ref2VA — EXPERIMENTAL TAGGED REF2VA — STATE REQUIRED"
+    },
+    {
+      "key": "n19",
+      "type": "MiniMaxH3ChainContext",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n14",
+          "state"
+        ],
+        "conditioning": [
+          "n45",
+          "conditioning"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "latent": [
+          "n18",
+          "latent"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Context — AUTO CONTEXT — clip 1 bypass / continuation"
+    },
+    {
+      "key": "n20",
+      "type": "MiniMaxH3SigmaShift",
+      "settings": {
+        "shift_video": 12,
+        "shift_audio": 3
+      },
+      "inputs": {
+        "model": [
+          "n31",
+          "MODEL"
+        ]
+      }
+    },
+    {
+      "key": "n23",
+      "type": "BasicGuider",
+      "settings": {},
+      "inputs": {
+        "model": [
+          "n20",
+          "MODEL"
+        ],
+        "conditioning": [
+          "n19",
+          "conditioning"
+        ]
+      },
+      "label": "Basic Guider — Loop guider"
+    },
+    {
+      "key": "n24",
+      "type": "BasicScheduler",
+      "settings": {
+        "scheduler": "simple",
+        "steps": 20,
+        "denoise": 1
+      },
+      "inputs": {
+        "model": [
+          "n20",
+          "MODEL"
+        ],
+        "steps": [
+          "n14",
+          "steps"
+        ]
+      },
+      "label": "BasicScheduler — Per-shot scheduler steps"
+    },
+    {
+      "key": "n25",
+      "type": "SamplerCustomAdvanced",
+      "settings": {},
+      "inputs": {
+        "noise": [
+          "n17",
+          "NOISE"
+        ],
+        "guider": [
+          "n23",
+          "GUIDER"
+        ],
+        "sampler": [
+          "n3",
+          "SAMPLER"
+        ],
+        "sigmas": [
+          "n24",
+          "SIGMAS"
+        ],
+        "latent_image": [
+          "n19",
+          "latent"
+        ]
+      },
+      "label": "SamplerCustomAdvanced — H3 sampler — SINGLE LOOP BODY"
+    },
+    {
+      "key": "n26",
+      "type": "VAEDecode",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n25",
+          "output"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode — Decode current clip frames"
+    },
+    {
+      "key": "n27",
+      "type": "VAEDecodeAudio",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n25",
+          "output"
+        ],
+        "vae": [
+          "n5",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode Audio — Decode current clip audio"
+    },
+    {
+      "key": "n28",
+      "type": "MiniMaxH3LoopTrim",
+      "settings": {
+        "trim_frames": 0,
+        "fps": 24,
+        "match_tail": true,
+        "retain_overlap_frames": 0
+      },
+      "inputs": {
+        "images": [
+          "n26",
+          "IMAGE"
+        ],
+        "audio": [
+          "n27",
+          "AUDIO"
+        ],
+        "trim_frames": [
+          "n19",
+          "trim_frames"
+        ],
+        "state": [
+          "n14",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Trim — TRIM CONTEXT / AUTO-RESOLVE SCENE BLEND"
+    },
+    {
+      "key": "n29",
+      "type": "MiniMaxH3ChainSegmentSave",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n14",
+          "state"
+        ],
+        "images": [
+          "n28",
+          "images"
+        ],
+        "sampled_latent": [
+          "n25",
+          "output"
+        ],
+        "audio": [
+          "n28",
+          "audio"
+        ],
+        "images_with_overlap": [
+          "n28",
+          "images_with_overlap"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Segment + Checkpoint — SAVE DELIVERED + BLEND-READY SEGMENTS"
+    },
+    {
+      "key": "n30",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "t2v_normal_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n32",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — FINAL ASSEMBLY — 5-FRAME VISUAL BLEND"
+    },
+    {
+      "key": "n31",
+      "type": "ModelAttentionBackend",
+      "settings": {
+        "attention": "pytorch attention"
+      },
+      "inputs": {
+        "model": [
+          "n1",
+          "MODEL"
+        ]
+      },
+      "label": "ModelAttentionBackend — COMFY KITCHEN ATTENTION"
+    },
+    {
+      "key": "n32",
+      "type": "MiniMaxH3ChainLoopEnd",
+      "settings": {
+        "between_scene_cleanup": "off"
+      },
+      "inputs": {
+        "flow": [
+          "n11",
+          "flow"
+        ],
+        "state": [
+          "n14",
+          "state"
+        ],
+        "images": [
+          "n28",
+          "images"
+        ],
+        "sampled_latent": [
+          "n25",
+          "output"
+        ],
+        "segment": [
+          "n35",
+          "segment"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop End — LOOP END — ADVANCE REF2V SCENE"
+    },
+    {
+      "key": "n33",
+      "type": "Note",
+      "settings": {
+        "text": "SEQUENTIAL MOTION 0.6 QUICK START\n\nCopy both courier PNGs to ComfyUI/input and select a motion video with embedded audio lasting at least 19.333 seconds. Keep tags @courier_arrival, @greenhouse_delivery, @courier_motion, and @courier_motion_audio in the prompts. The motion window advances with each scene."
+      },
+      "inputs": {},
+      "label": "SEQUENTIAL MOTION 0.6 QUICK START"
+    },
+    {
+      "key": "n34",
+      "type": "MiniMaxH3ChainPlanModern",
+      "settings": {
+        "plan_json": "{\n  \"defaults\": {\n    \"steps\": 20\n  },\n  \"shots\": [\n    {\n      \"id\": \"reference_delivery\",\n      \"prompt\": \"subject_definitions:\\n@courier_arrival defines <Subject 1>, the exact adult bicycle courier, including his face, mustard-yellow waterproof jacket, dark teal trousers, charcoal helmet, olive messenger bag, silver bicycle, kraft parcel, proportions, and photographic rendering.\\n@greenhouse_delivery defines the greenhouse delivery destination, including the glass structure, wooden potting table, dense plants, warm practical bulbs, wet floor reflections, and the same courier's end pose.\\n@courier_motion is a motion-only guide for the walk, turn, and parcel placement; it must not replace the courier's appearance. @courier_motion_audio is its synchronized embedded sound guide.\\n<Subject 1> is the single courier shown by both references. Preserve his identity, clothing, equipment, and scale while allowing the described movement.\\n\\nsummary:\\n[reference generation] One continuous delivery moves <Subject 1> from the wet greenhouse entrance in @courier_arrival toward the completed parcel placement in @greenhouse_delivery.\\n\\nretention_analysis:\\n<Subject 1> (appears in [Shot 1]): fully_preserved - retain the exact face, adult age, body proportions, mustard jacket, teal trousers, helmet, bag, bicycle, and parcel across the complete shot.\\n@courier_arrival: fully_preserved - use its courier identity, wardrobe, bicycle geometry, exterior doorway, wet paving, camera height, and cool daylight as the opening state.\\n@greenhouse_delivery: reference - use its potting table, plants, warm bulbs, interior reflections, and delivery pose as the destination; do not copy the final pose before the action reaches it.\\n\\ndetailed_description:\\n[Shot 1] Begin at the greenhouse entrance with exactly one courier and one bicycle. He walks the bicycle through the open glass door, glances down to confirm the parcel, then turns toward the wooden potting table. The camera tracks laterally at walking speed with restrained handheld movement. He stops the bicycle with his left hand and sets the parcel on the clear corner of the table with his right hand. Preserve face, hands, clothing, bicycle structure, parcel dimensions, plant layout, lighting direction, and coherent reflections. End immediately after the parcel makes contact; no cut, duplicate subject, added customer, text, logo, or early freeze.\\n\\noverall_soundscape:\\nLight rain on greenhouse glass, wet tire roll, a quiet freewheel tick, rubber soles, door hinge, jacket movement, muted ventilation, and soft cardboard contact on wood. Keep every sound synchronized and spatially plausible.\\n\\nnon_diegetic_music:\\nNo non-diegetic music.\",\n      \"length\": 243,\n      \"steps\": 20,\n      \"seed\": \"6101\"\n    },\n    {\n      \"id\": \"reference_confirmation\",\n      \"prompt\": \"subject_definitions:\\n@courier_arrival preserves the exact identity, clothing, bicycle, parcel, exterior weather, and entrance geography established before the boundary.\\n@greenhouse_delivery defines the same greenhouse interior, potting table, plants, warm bulbs, and final delivery area.\\n<Subject 1> is the same single adult courier carried by the incoming H3 Motion Context and both references.\\n@courier_motion remains the motion-only walk and parcel-placement guide. @courier_motion_audio remains its synchronized embedded sound guide.\\n\\nsummary:\\n[reference generation] The uninterrupted delivery continues inside the greenhouse after the carried overlap and ends with the courier calmly confirming the parcel placement.\\n\\nretention_analysis:\\n<Subject 1> (appears in [Shot 1]): fully_preserved - preserve the exact face, mustard jacket, teal trousers, helmet, bag, body proportions, bicycle, and motion phase inherited from context.\\n@courier_arrival: reference - retain its cool exterior light and entrance geometry only where still visible behind the courier.\\n@greenhouse_delivery: fully_preserved - retain the greenhouse table, plant arrangement, warm practical lights, reflections, parcel position, and photographic rendering.\\n\\ndetailed_description:\\n[Shot 1] Continue directly from the incoming H3 Motion Context. The carried opening overlap already contains the threshold crossing; begin new action only after it and never reset the stride. The courier rolls the same bicycle beside the potting table, steadies it with his left hand, and places the kraft parcel on the dry corner with his right hand. He checks the label area without showing readable text, then gives a small satisfied smile. Keep exactly one person and one bicycle, stable hands, coherent wheels, continuous camera direction, and consistent light. No cut, duplicate, wardrobe change, or early freeze.\\n\\noverall_soundscape:\\nContinue rain-muted greenhouse ambience, footsteps, tire roll, freewheel ticks, clothing movement, ventilation, and the soft parcel contact without restarting any sound at the scene boundary.\\n\\nnon_diegetic_music:\\nNo non-diegetic music.\",\n      \"length\": 243,\n      \"steps\": 20,\n      \"seed\": \"6102\"\n    }\n  ]\n}",
+        "run_name": "ref2v_sequential_motion_experimental_minimax_h3_0_6_json",
+        "generation_fingerprint": "h3-v06-release-example",
+        "width": 896,
+        "height": 672,
+        "encode_mode": "video",
+        "crop": "disabled",
+        "default_duration_seconds": 10.0,
+        "default_steps": 20,
+        "base_seed": 0,
+        "segment_crf": 20,
+        "video_blend_frames": 0
+      },
+      "inputs": {
+        "chain_policy": [
+          "n47",
+          "chain_policy"
+        ],
+        "generation_fingerprint": [
+          "n44",
+          "reference_fingerprint"
+        ]
+      },
+      "label": "MiniMax H3 Production Plan — 0.6 SCENE COLUMNS"
+    },
+    {
+      "key": "n35",
+      "type": "MiniMaxH3ChainReview",
+      "settings": {
+        "enabled": true,
+        "play_notification_sound": false,
+        "auto_continue_timeout_minutes": 0,
+        "unload_models_while_waiting": false,
+        "assemble_partial_on_stop": true,
+        "partial_audio_source": "checkpointed",
+        "candidate_count": 1,
+        "review_each_candidate": false
+      },
+      "inputs": {
+        "state": [
+          "n14",
+          "state"
+        ],
+        "segment": [
+          "n29",
+          "segment"
+        ],
+        "audio": [
+          "n28",
+          "audio"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Review Gate — REVIEW GATE — APPROVE / EDIT+RETRY / REROLL / STOP"
+    },
+    {
+      "key": "n36",
+      "type": "MiniMaxH3ChainManifestLoad",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n7",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Load Manifest — RECOVERY: LOAD ALL SAVED CLIPS",
+      "mode": 2
+    },
+    {
+      "key": "n37",
+      "type": "Note",
+      "settings": {
+        "text": "The two amber recovery nodes are MUTED by default.\n\nIf all segments finished but final assembly did not, mute the main green Assemble node, enable both recovery nodes, and queue. They validate every SHA-256 checkpoint pair and assemble without rerendering the completed clips.\n\nFor an interrupted generation, leave recovery muted and set Loop Start's start_clip to the first unfinished clip."
+      },
+      "inputs": {},
+      "label": "Note — RECOVERY / ASSEMBLE LATER"
+    },
+    {
+      "key": "n38",
+      "type": "LoadImage",
+      "settings": {
+        "image": "h3_v06_courier_greenhouse_arrival.png"
+      },
+      "inputs": {},
+      "label": "Load Image — 0.6 COURIER ARRIVAL"
+    },
+    {
+      "key": "n39",
+      "type": "LoadImage",
+      "settings": {
+        "image": "h3_v06_courier_greenhouse_delivery.png"
+      },
+      "inputs": {},
+      "label": "Load Image — 0.6 GREENHOUSE DELIVERY"
+    },
+    {
+      "key": "n40",
+      "type": "MiniMaxH3TaggedPictureReference",
+      "settings": {
+        "tag": "courier_arrival"
+      },
+      "inputs": {
+        "image": [
+          "n38",
+          "IMAGE"
+        ]
+      },
+      "label": "MiniMax H3 Tagged Picture Ref — @courier_arrival"
+    },
+    {
+      "key": "n41",
+      "type": "MiniMaxH3TaggedPictureReference",
+      "settings": {
+        "tag": "greenhouse_delivery"
+      },
+      "inputs": {
+        "image": [
+          "n39",
+          "IMAGE"
+        ],
+        "previous": [
+          "n40",
+          "references"
+        ]
+      },
+      "label": "MiniMax H3 Tagged Picture Ref — @greenhouse_delivery"
+    },
+    {
+      "key": "n42",
+      "type": "LoadVideo",
+      "settings": {
+        "file": "SELECT_LONG_MOTION_REFERENCE_WITH_AUDIO.mp4"
+      },
+      "inputs": {},
+      "label": "Load Video — SELECT LONG MOTION VIDEO + AUDIO — ≥19.333s"
+    },
+    {
+      "key": "n43",
+      "type": "MiniMaxH3ReferenceVideoPrepare",
+      "settings": {
+        "length": 464,
+        "source_fps": 24
+      },
+      "inputs": {
+        "source_video": [
+          "n42",
+          "VIDEO"
+        ]
+      },
+      "label": "MiniMax H3 Reference Video Prep — PREP FULL 24 FPS TIMELINE — 464 FRAMES"
+    },
+    {
+      "key": "n44",
+      "type": "MiniMaxH3TaggedVideoReference",
+      "settings": {
+        "tag": "courier_motion",
+        "audio_tag": "courier_motion_audio",
+        "timeline_mode": "sequential"
+      },
+      "inputs": {
+        "video": [
+          "n43",
+          "ref_video"
+        ],
+        "audio": [
+          "n43",
+          "source_audio"
+        ],
+        "previous": [
+          "n41",
+          "references"
+        ]
+      },
+      "label": "MiniMax H3 Tagged Video Ref — @courier_motion / SEQUENTIAL"
+    },
+    {
+      "key": "n45",
+      "type": "MiniMaxH3PatchPriority",
+      "settings": {},
+      "inputs": {
+        "conditioning": [
+          "n18",
+          "positive"
+        ]
+      },
+      "label": "MiniMax H3 Patch Priority — PATCH PRIORITY — EXPERIMENTAL COMPATIBILITY"
+    },
+    {
+      "key": "n46",
+      "type": "MiniMaxH3ChainPreflight",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true
+      },
+      "inputs": {
+        "plan": [
+          "n7",
+          "plan"
+        ],
+        "tagged_references": [
+          "n44",
+          "references"
+        ]
+      },
+      "label": "MiniMax H3 Chain Preflight — 0.6 PREFLIGHT — BLOCKS BEFORE MODELS"
+    },
+    {
+      "key": "n47",
+      "type": "MiniMaxH3GenerationProfile",
+      "settings": {
+        "scene_continuity": "Visual continuity",
+        "audio_profile": "Generate audio"
+      },
+      "inputs": {},
+      "label": "MiniMax H3 Generation Profile — RELEASE DEFAULTS"
+    }
+  ]
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Ref2V Studio - MiniMax H3 0.6.json b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Ref2V Studio - MiniMax H3 0.6.json
new file mode 100644
index 0000000000000000000000000000000000000000..8c8109aff9bd8a0cde6009cf736deb146a4737c5
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Ref2V Studio - MiniMax H3 0.6.json	
@@ -0,0 +1,633 @@
+{
+  "nodes": [
+    {
+      "key": "n1",
+      "type": "UNETLoader",
+      "settings": {
+        "unet_name": "minimax_h3_ref2va_pruned_int8_convrot.safetensors",
+        "weight_dtype": "default"
+      },
+      "inputs": {},
+      "label": "Load Diffusion Model — H3 MODEL — REQUIRED"
+    },
+    {
+      "key": "n2",
+      "type": "CLIPLoader",
+      "settings": {
+        "clip_name": "qwen3vl_32b_minimax_h3_int8_convrot.safetensors",
+        "type": "minimax",
+        "device": "default"
+      },
+      "inputs": {},
+      "label": "Load CLIP — H3 TEXT ENCODER"
+    },
+    {
+      "key": "n3",
+      "type": "KSamplerSelect",
+      "settings": {
+        "sampler_name": "res_multistep"
+      },
+      "inputs": {},
+      "label": "KSamplerSelect — Sampler algorithm"
+    },
+    {
+      "key": "n4",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_video_vae_fp16.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Video VAE"
+    },
+    {
+      "key": "n5",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_audio_vae_fp32.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Audio VAE"
+    },
+    {
+      "key": "n6",
+      "type": "Note",
+      "settings": {
+        "text": "0.6 ORIGINAL REFERENCE EXAMPLE\n\nThe matching courier and greenhouse pictures were generated specifically for this catalog. They replace the old community demonstration assets and prompts."
+      },
+      "inputs": {},
+      "label": "0.6 ORIGINAL REFERENCE EXAMPLE"
+    },
+    {
+      "key": "n9",
+      "type": "MiniMaxH3ChainLoopStart",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true
+      },
+      "inputs": {
+        "plan": [
+          "n36",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Start — LOOP START / RESUME"
+    },
+    {
+      "key": "n12",
+      "type": "MiniMaxH3ChainCurrent",
+      "settings": {
+        "align_audio_reference": false
+      },
+      "inputs": {
+        "state": [
+          "n9",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Current Shot — CURRENT REF2V SCENE — PROMPT / SEED / TIMING"
+    },
+    {
+      "key": "n13",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "t2v_studio_recovered_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n30",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — RECOVERY: ASSEMBLE WITHOUT RENDERING",
+      "mode": 2
+    },
+    {
+      "key": "n15",
+      "type": "RandomNoise",
+      "settings": {
+        "noise_seed": 0,
+        "control_after_generate": "fixed"
+      },
+      "inputs": {
+        "noise_seed": [
+          "n12",
+          "noise_seed"
+        ]
+      },
+      "label": "RandomNoise — Per-shot noise seed"
+    },
+    {
+      "key": "n16",
+      "type": "MiniMaxH3TaggedReferenceToVideo",
+      "settings": {
+        "clip_index": 1,
+        "clip_count": 2,
+        "prompt": "subject_definitions:\n@courier_arrival defines <Subject 1>, the exact adult bicycle courier, including his face, mustard-yellow waterproof jacket, dark teal trousers, charcoal helmet, olive messenger bag, silver bicycle, kraft parcel, proportions, and photographic rendering.\n@greenhouse_delivery defines the greenhouse delivery destination, including the glass structure, wooden potting table, dense plants, warm practical bulbs, wet floor reflections, and the same courier's end pose.\n<Subject 1> is the single courier shown by both references. Preserve his identity, clothing, equipment, and scale while allowing the described movement.\n\nsummary:\n[reference generation] One continuous delivery moves <Subject 1> from the wet greenhouse entrance in @courier_arrival toward the completed parcel placement in @greenhouse_delivery.\n\nretention_analysis:\n<Subject 1> (appears in [Shot 1]): fully_preserved - retain the exact face, adult age, body proportions, mustard jacket, teal trousers, helmet, bag, bicycle, and parcel across the complete shot.\n@courier_arrival: fully_preserved - use its courier identity, wardrobe, bicycle geometry, exterior doorway, wet paving, camera height, and cool daylight as the opening state.\n@greenhouse_delivery: reference - use its potting table, plants, warm bulbs, interior reflections, and delivery pose as the destination; do not copy the final pose before the action reaches it.\n\ndetailed_description:\n[Shot 1] Begin at the greenhouse entrance with exactly one courier and one bicycle. He walks the bicycle through the open glass door, glances down to confirm the parcel, then turns toward the wooden potting table. The camera tracks laterally at walking speed with restrained handheld movement. He stops the bicycle with his left hand and sets the parcel on the clear corner of the table with his right hand. Preserve face, hands, clothing, bicycle structure, parcel dimensions, plant layout, lighting direction, and coherent reflections. End immediately after the parcel makes contact; no cut, duplicate subject, added customer, text, logo, or early freeze.\n\noverall_soundscape:\nLight rain on greenhouse glass, wet tire roll, a quiet freewheel tick, rubber soles, door hinge, jacket movement, muted ventilation, and soft cardboard contact on wood. Keep every sound synchronized and spatially plausible.\n\nnon_diegetic_music:\nNo non-diegetic music.",
+        "width": 896,
+        "height": 672,
+        "length": 243,
+        "ref_image_size": "match",
+        "reference_policy": "strict",
+        "semantic_anchor_size": "512",
+        "semantic_anchor_mode": "timestamped_video",
+        "cache_for_upscale": true,
+        "conditioning_backend": "native_ref2va"
+      },
+      "inputs": {
+        "clip": [
+          "n2",
+          "CLIP"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "audio_vae": [
+          "n5",
+          "VAE"
+        ],
+        "references": [
+          "n40",
+          "references"
+        ],
+        "clip_index": [
+          "n12",
+          "clip_index"
+        ],
+        "clip_count": [
+          "n12",
+          "clip_count"
+        ],
+        "prompt": [
+          "n12",
+          "prompt"
+        ],
+        "width": [
+          "n12",
+          "width"
+        ],
+        "height": [
+          "n12",
+          "height"
+        ],
+        "length": [
+          "n12",
+          "length"
+        ]
+      },
+      "label": "MiniMax H3 Tagged Ref2VA — TAGGED REF2VA — COMPILES @TAGS PER SCENE"
+    },
+    {
+      "key": "n17",
+      "type": "MiniMaxH3ChainContext",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n12",
+          "state"
+        ],
+        "conditioning": [
+          "n16",
+          "positive"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "latent": [
+          "n16",
+          "latent"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Context — MASKED AV CONTEXT — PRESERVE PREFIX / GENERATE FUTURE"
+    },
+    {
+      "key": "n18",
+      "type": "MiniMaxH3SigmaShift",
+      "settings": {
+        "shift_video": 12,
+        "shift_audio": 3
+      },
+      "inputs": {
+        "model": [
+          "n29",
+          "MODEL"
+        ]
+      }
+    },
+    {
+      "key": "n21",
+      "type": "BasicGuider",
+      "settings": {},
+      "inputs": {
+        "model": [
+          "n18",
+          "MODEL"
+        ],
+        "conditioning": [
+          "n17",
+          "conditioning"
+        ]
+      },
+      "label": "Basic Guider — Loop guider"
+    },
+    {
+      "key": "n22",
+      "type": "BasicScheduler",
+      "settings": {
+        "scheduler": "simple",
+        "steps": 20,
+        "denoise": 1
+      },
+      "inputs": {
+        "model": [
+          "n18",
+          "MODEL"
+        ],
+        "steps": [
+          "n12",
+          "steps"
+        ]
+      },
+      "label": "BasicScheduler — Per-shot scheduler steps"
+    },
+    {
+      "key": "n23",
+      "type": "SamplerCustomAdvanced",
+      "settings": {},
+      "inputs": {
+        "noise": [
+          "n15",
+          "NOISE"
+        ],
+        "guider": [
+          "n21",
+          "GUIDER"
+        ],
+        "sampler": [
+          "n3",
+          "SAMPLER"
+        ],
+        "sigmas": [
+          "n22",
+          "SIGMAS"
+        ],
+        "latent_image": [
+          "n17",
+          "latent"
+        ]
+      },
+      "label": "SamplerCustomAdvanced — H3 sampler — SINGLE LOOP BODY"
+    },
+    {
+      "key": "n24",
+      "type": "VAEDecode",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n23",
+          "output"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode — Decode current clip frames"
+    },
+    {
+      "key": "n25",
+      "type": "VAEDecodeAudio",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n23",
+          "output"
+        ],
+        "vae": [
+          "n5",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode Audio — Decode current clip audio"
+    },
+    {
+      "key": "n26",
+      "type": "MiniMaxH3LoopTrim",
+      "settings": {
+        "trim_frames": 0,
+        "fps": 24,
+        "match_tail": true,
+        "retain_overlap_frames": 5
+      },
+      "inputs": {
+        "images": [
+          "n24",
+          "IMAGE"
+        ],
+        "audio": [
+          "n25",
+          "AUDIO"
+        ],
+        "trim_frames": [
+          "n17",
+          "trim_frames"
+        ],
+        "state": [
+          "n12",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Trim — TRIM CONTEXT / AUTO-RESOLVE SCENE BLEND"
+    },
+    {
+      "key": "n27",
+      "type": "MiniMaxH3ChainSegmentSave",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n12",
+          "state"
+        ],
+        "images": [
+          "n26",
+          "images"
+        ],
+        "sampled_latent": [
+          "n23",
+          "output"
+        ],
+        "audio": [
+          "n26",
+          "audio"
+        ],
+        "images_with_overlap": [
+          "n26",
+          "images_with_overlap"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Segment + Checkpoint — SAVE DELIVERED + BLEND-READY SEGMENTS"
+    },
+    {
+      "key": "n28",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "t2v_studio_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n34",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — FINAL ASSEMBLY — 5-FRAME VISUAL BLEND"
+    },
+    {
+      "key": "n29",
+      "type": "ModelAttentionBackend",
+      "settings": {
+        "attention": "pytorch attention"
+      },
+      "inputs": {
+        "model": [
+          "n1",
+          "MODEL"
+        ]
+      },
+      "label": "ModelAttentionBackend — COMFY KITCHEN ATTENTION"
+    },
+    {
+      "key": "n30",
+      "type": "MiniMaxH3ChainManifestLoad",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n36",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Load Manifest — RECOVERY: LOAD ALL SAVED CLIPS",
+      "mode": 2
+    },
+    {
+      "key": "n31",
+      "type": "Note",
+      "settings": {
+        "text": "The two amber recovery nodes are MUTED by default.\n\nIf all segments finished but final assembly did not, mute the main green Assemble node, enable both recovery nodes, and queue. They validate every SHA-256 checkpoint pair and assemble without rerendering the completed clips.\n\nFor an interrupted generation, leave recovery muted and set Loop Start's start_clip to the first unfinished clip."
+      },
+      "inputs": {},
+      "label": "Note — RECOVERY / ASSEMBLE LATER"
+    },
+    {
+      "key": "n32",
+      "type": "Note",
+      "settings": {
+        "text": "REF2VA PROMPT FORMAT — SIX SECTIONS\n\nKeep subject_definitions, summary, retention_analysis, detailed_description, overall_soundscape, and non_diegetic_music in that order. References define identity; the prompt defines the new action."
+      },
+      "inputs": {},
+      "label": "REF2VA PROMPT FORMAT — SIX SECTIONS"
+    },
+    {
+      "key": "n33",
+      "type": "MiniMaxH3ChainReview",
+      "settings": {
+        "enabled": true,
+        "play_notification_sound": false,
+        "auto_continue_timeout_minutes": 0,
+        "unload_models_while_waiting": false,
+        "assemble_partial_on_stop": true,
+        "partial_audio_source": "checkpointed",
+        "candidate_count": 1,
+        "review_each_candidate": false
+      },
+      "inputs": {
+        "state": [
+          "n12",
+          "state"
+        ],
+        "segment": [
+          "n27",
+          "segment"
+        ],
+        "audio": [
+          "n26",
+          "audio"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Review Gate — REVIEW GATE — APPROVE / EDIT+RETRY / REROLL / STOP"
+    },
+    {
+      "key": "n34",
+      "type": "MiniMaxH3ChainLoopEnd",
+      "settings": {
+        "between_scene_cleanup": "off"
+      },
+      "inputs": {
+        "flow": [
+          "n9",
+          "flow"
+        ],
+        "state": [
+          "n12",
+          "state"
+        ],
+        "images": [
+          "n26",
+          "images"
+        ],
+        "sampled_latent": [
+          "n23",
+          "output"
+        ],
+        "segment": [
+          "n33",
+          "segment"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop End — LOOP END — ADVANCE REF2V SCENE"
+    },
+    {
+      "key": "n35",
+      "type": "Note",
+      "settings": {
+        "text": "0.6 Studio quick start\n\n1. Open the Project Asset Carousel.\n2. Import h3_v06_courier_greenhouse_arrival.png; tag courier_arrival (Picture).\n3. Import h3_v06_courier_greenhouse_delivery.png; tag greenhouse_delivery (Picture).\n4. Edit scenes in Production Plan or Plan Studio.\n5. Queue; inspect, branch, trim, or restore in Checkpoint Manager."
+      },
+      "inputs": {},
+      "label": "0.6 STUDIO QUICK START"
+    },
+    {
+      "key": "n36",
+      "type": "MiniMaxH3ChainPlanStudio",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true,
+        "plan_json": "{\n  \"shots\": [\n    {\n      \"id\": \"intro\",\n      \"prompt\": \"Describe the opening shot.\"\n    },\n    {\n      \"id\": \"continuation\",\n      \"prompt\": \"Continue the same take.\"\n    }\n  ]\n}",
+        "run_name": "h3_chain",
+        "generation_fingerprint": "",
+        "width": 960,
+        "height": 544,
+        "context_length": 22,
+        "encode_mode": "video",
+        "anchor_mode": "head",
+        "crop": "disabled",
+        "audio_mode": "generated_audio",
+        "audio_context_length": 22,
+        "default_duration_seconds": 15.0,
+        "default_steps": 20,
+        "base_seed": 0,
+        "segment_crf": 18,
+        "video_blend_frames": 0,
+        "continuation_mode": "guide",
+        "alternate_take_json": ""
+      },
+      "inputs": {
+        "plan": [
+          "n38",
+          "plan"
+        ],
+        "tagged_references": [
+          "n40",
+          "references"
+        ],
+        "project_assets": [
+          "n40",
+          "project_assets"
+        ]
+      },
+      "label": "MiniMax H3 Plan Studio — TIMELINE / TAKES / TRIMS"
+    },
+    {
+      "key": "n37",
+      "type": "MiniMaxH3ChainRichScenePromptEditor",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n36",
+          "plan"
+        ]
+      }
+    },
+    {
+      "key": "n38",
+      "type": "MiniMaxH3ChainPlanModern",
+      "settings": {
+        "plan_json": "{\n  \"defaults\": {\n    \"steps\": 20\n  },\n  \"shots\": [\n    {\n      \"id\": \"reference_delivery\",\n      \"prompt\": \"subject_definitions:\\n@courier_arrival defines <Subject 1>, the exact adult bicycle courier, including his face, mustard-yellow waterproof jacket, dark teal trousers, charcoal helmet, olive messenger bag, silver bicycle, kraft parcel, proportions, and photographic rendering.\\n@greenhouse_delivery defines the greenhouse delivery destination, including the glass structure, wooden potting table, dense plants, warm practical bulbs, wet floor reflections, and the same courier's end pose.\\n<Subject 1> is the single courier shown by both references. Preserve his identity, clothing, equipment, and scale while allowing the described movement.\\n\\nsummary:\\n[reference generation] One continuous delivery moves <Subject 1> from the wet greenhouse entrance in @courier_arrival toward the completed parcel placement in @greenhouse_delivery.\\n\\nretention_analysis:\\n<Subject 1> (appears in [Shot 1]): fully_preserved - retain the exact face, adult age, body proportions, mustard jacket, teal trousers, helmet, bag, bicycle, and parcel across the complete shot.\\n@courier_arrival: fully_preserved - use its courier identity, wardrobe, bicycle geometry, exterior doorway, wet paving, camera height, and cool daylight as the opening state.\\n@greenhouse_delivery: reference - use its potting table, plants, warm bulbs, interior reflections, and delivery pose as the destination; do not copy the final pose before the action reaches it.\\n\\ndetailed_description:\\n[Shot 1] Begin at the greenhouse entrance with exactly one courier and one bicycle. He walks the bicycle through the open glass door, glances down to confirm the parcel, then turns toward the wooden potting table. The camera tracks laterally at walking speed with restrained handheld movement. He stops the bicycle with his left hand and sets the parcel on the clear corner of the table with his right hand. Preserve face, hands, clothing, bicycle structure, parcel dimensions, plant layout, lighting direction, and coherent reflections. End immediately after the parcel makes contact; no cut, duplicate subject, added customer, text, logo, or early freeze.\\n\\noverall_soundscape:\\nLight rain on greenhouse glass, wet tire roll, a quiet freewheel tick, rubber soles, door hinge, jacket movement, muted ventilation, and soft cardboard contact on wood. Keep every sound synchronized and spatially plausible.\\n\\nnon_diegetic_music:\\nNo non-diegetic music.\",\n      \"length\": 243,\n      \"steps\": 20,\n      \"seed\": \"6101\"\n    },\n    {\n      \"id\": \"reference_confirmation\",\n      \"prompt\": \"subject_definitions:\\n@courier_arrival preserves the exact identity, clothing, bicycle, parcel, exterior weather, and entrance geography established before the boundary.\\n@greenhouse_delivery defines the same greenhouse interior, potting table, plants, warm bulbs, and final delivery area.\\n<Subject 1> is the same single adult courier carried by the incoming H3 Motion Context and both references.\\n\\nsummary:\\n[reference generation] The uninterrupted delivery continues inside the greenhouse after the carried overlap and ends with the courier calmly confirming the parcel placement.\\n\\nretention_analysis:\\n<Subject 1> (appears in [Shot 1]): fully_preserved - preserve the exact face, mustard jacket, teal trousers, helmet, bag, body proportions, bicycle, and motion phase inherited from context.\\n@courier_arrival: reference - retain its cool exterior light and entrance geometry only where still visible behind the courier.\\n@greenhouse_delivery: fully_preserved - retain the greenhouse table, plant arrangement, warm practical lights, reflections, parcel position, and photographic rendering.\\n\\ndetailed_description:\\n[Shot 1] Continue directly from the incoming H3 Motion Context. The carried opening overlap already contains the threshold crossing; begin new action only after it and never reset the stride. The courier rolls the same bicycle beside the potting table, steadies it with his left hand, and places the kraft parcel on the dry corner with his right hand. He checks the label area without showing readable text, then gives a small satisfied smile. Keep exactly one person and one bicycle, stable hands, coherent wheels, continuous camera direction, and consistent light. No cut, duplicate, wardrobe change, or early freeze.\\n\\noverall_soundscape:\\nContinue rain-muted greenhouse ambience, footsteps, tire roll, freewheel ticks, clothing movement, ventilation, and the soft parcel contact without restarting any sound at the scene boundary.\\n\\nnon_diegetic_music:\\nNo non-diegetic music.\",\n      \"length\": 243,\n      \"steps\": 20,\n      \"seed\": \"6102\"\n    }\n  ]\n}",
+        "run_name": "ref2v_studio_minimax_h3_0_6_json",
+        "generation_fingerprint": "",
+        "width": 896,
+        "height": 672,
+        "encode_mode": "video",
+        "crop": "disabled",
+        "default_duration_seconds": 10.0,
+        "default_steps": 20,
+        "base_seed": 0,
+        "segment_crf": 20,
+        "video_blend_frames": 5
+      },
+      "inputs": {
+        "chain_policy": [
+          "n39",
+          "chain_policy"
+        ],
+        "project_assets": [
+          "n40",
+          "project_assets"
+        ]
+      },
+      "label": "MiniMax H3 Production Plan — 0.6 SCENE COLUMNS"
+    },
+    {
+      "key": "n39",
+      "type": "MiniMaxH3GenerationProfile",
+      "settings": {
+        "scene_continuity": "Hard picture + protected audio",
+        "audio_profile": "Generate audio"
+      },
+      "inputs": {},
+      "label": "MiniMax H3 Generation Profile — RELEASE DEFAULTS"
+    },
+    {
+      "key": "n40",
+      "type": "MiniMaxH3ProjectAssetManager",
+      "settings": {
+        "run_name": "ref2v_studio_minimax_h3_0_6_json",
+        "catalog_json": "",
+        "semantic_anchor_size": "512",
+        "semantic_anchor_mode": "timestamped_video",
+        "operation_json": ""
+      },
+      "inputs": {},
+      "label": "MiniMax H3 Project Asset Carousel — IMPORT RELEASE REFERENCES"
+    },
+    {
+      "key": "n41",
+      "type": "MiniMaxH3ChainCheckpointManager",
+      "settings": {
+        "selection_json": ""
+      },
+      "inputs": {
+        "plan": [
+          "n36",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Checkpoint Manager — BRANCHES / PREVIEWS / RESTORE"
+    }
+  ]
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Ref2V Studio Source Audio - MiniMax H3 0.6.json b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Ref2V Studio Source Audio - MiniMax H3 0.6.json
new file mode 100644
index 0000000000000000000000000000000000000000..3ecdc8e928439a3d5d687841507bc1f2cf83b93d
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Ref2V Studio Source Audio - MiniMax H3 0.6.json	
@@ -0,0 +1,642 @@
+{
+  "setup_steps": "SOURCE AUDIO • IMPORT YOUR SOUNDTRACK HERE\n\n1. In Project Asset Carousel, set a unique run name, then import/drop one audio file.\n2. Select its card: Audio use → Project timeline source.\n3. Keep Generation Profile → Lip-sync to source audio (already selected).\n4. Edit your scenes, then queue the workflow.\n\nThe preset alone does not load an audio file. No separate Load Audio node, AUDIO cable, or @tag is needed:\nCarousel.project_assets already carries the source track to the Plan and loop.\n\nInstall models/packs and set up supplied picture references using example_workflows/README.md.",
+  "nodes": [
+    {
+      "key": "n1",
+      "type": "UNETLoader",
+      "settings": {
+        "unet_name": "minimax_h3_ref2va_pruned_int8_convrot.safetensors",
+        "weight_dtype": "default"
+      },
+      "inputs": {},
+      "label": "Load Diffusion Model — H3 MODEL — REQUIRED"
+    },
+    {
+      "key": "n2",
+      "type": "CLIPLoader",
+      "settings": {
+        "clip_name": "qwen3vl_32b_minimax_h3_int8_convrot.safetensors",
+        "type": "minimax",
+        "device": "default"
+      },
+      "inputs": {},
+      "label": "Load CLIP — H3 TEXT ENCODER"
+    },
+    {
+      "key": "n3",
+      "type": "KSamplerSelect",
+      "settings": {
+        "sampler_name": "res_multistep"
+      },
+      "inputs": {},
+      "label": "KSamplerSelect — Sampler algorithm"
+    },
+    {
+      "key": "n4",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_video_vae_fp16.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Video VAE"
+    },
+    {
+      "key": "n5",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_audio_vae_fp32.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Audio VAE"
+    },
+    {
+      "key": "n6",
+      "type": "Note",
+      "settings": {
+        "text": "0.6 ORIGINAL REFERENCE EXAMPLE\n\nThe matching courier and greenhouse pictures were generated specifically for this catalog. They replace the old community demonstration assets and prompts."
+      },
+      "inputs": {},
+      "label": "0.6 ORIGINAL REFERENCE EXAMPLE"
+    },
+    {
+      "key": "n9",
+      "type": "MiniMaxH3ChainLoopStart",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true
+      },
+      "inputs": {
+        "plan": [
+          "n36",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Start — LOOP START / RESUME"
+    },
+    {
+      "key": "n12",
+      "type": "MiniMaxH3ChainCurrent",
+      "settings": {
+        "align_audio_reference": true
+      },
+      "inputs": {
+        "state": [
+          "n9",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Current Shot — CURRENT REF2V SCENE — PROMPT / SEED / TIMING"
+    },
+    {
+      "key": "n13",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "ref2v_studio_source_audio_recovered_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n30",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — RECOVERY: ASSEMBLE WITHOUT RENDERING",
+      "mode": 2
+    },
+    {
+      "key": "n15",
+      "type": "RandomNoise",
+      "settings": {
+        "noise_seed": 0,
+        "control_after_generate": "fixed"
+      },
+      "inputs": {
+        "noise_seed": [
+          "n12",
+          "noise_seed"
+        ]
+      },
+      "label": "RandomNoise — Per-shot noise seed"
+    },
+    {
+      "key": "n16",
+      "type": "MiniMaxH3TaggedReferenceToVideo",
+      "settings": {
+        "clip_index": 1,
+        "clip_count": 2,
+        "prompt": "subject_definitions:\n@courier_arrival defines <Subject 1>, the exact adult bicycle courier, including his face, mustard-yellow waterproof jacket, dark teal trousers, charcoal helmet, olive messenger bag, silver bicycle, kraft parcel, proportions, and photographic rendering.\n@greenhouse_delivery defines the greenhouse delivery destination, including the glass structure, wooden potting table, dense plants, warm practical bulbs, wet floor reflections, and the same courier's end pose.\n<Subject 1> is the single courier shown by both references. Preserve his identity, clothing, equipment, and scale while allowing the described movement.\n\nsummary:\n[reference generation] One continuous delivery moves <Subject 1> from the wet greenhouse entrance in @courier_arrival toward the completed parcel placement in @greenhouse_delivery.\n\nretention_analysis:\n<Subject 1> (appears in [Shot 1]): fully_preserved - retain the exact face, adult age, body proportions, mustard jacket, teal trousers, helmet, bag, bicycle, and parcel across the complete shot.\n@courier_arrival: fully_preserved - use its courier identity, wardrobe, bicycle geometry, exterior doorway, wet paving, camera height, and cool daylight as the opening state.\n@greenhouse_delivery: reference - use its potting table, plants, warm bulbs, interior reflections, and delivery pose as the destination; do not copy the final pose before the action reaches it.\n\ndetailed_description:\n[Shot 1] Begin at the greenhouse entrance with exactly one courier and one bicycle. He walks the bicycle through the open glass door, glances down to confirm the parcel, then turns toward the wooden potting table. The camera tracks laterally at walking speed with restrained handheld movement. He stops the bicycle with his left hand and sets the parcel on the clear corner of the table with his right hand. Preserve face, hands, clothing, bicycle structure, parcel dimensions, plant layout, lighting direction, and coherent reflections. End immediately after the parcel makes contact; no cut, duplicate subject, added customer, text, logo, or early freeze.\n\noverall_soundscape:\nLight rain on greenhouse glass, wet tire roll, a quiet freewheel tick, rubber soles, door hinge, jacket movement, muted ventilation, and soft cardboard contact on wood. Keep every sound synchronized and spatially plausible.\n\nnon_diegetic_music:\nNo non-diegetic music.",
+        "width": 896,
+        "height": 672,
+        "length": 243,
+        "ref_image_size": "match",
+        "reference_policy": "strict",
+        "semantic_anchor_size": "512",
+        "semantic_anchor_mode": "timestamped_video",
+        "cache_for_upscale": true,
+        "conditioning_backend": "native_ref2va"
+      },
+      "inputs": {
+        "clip": [
+          "n2",
+          "CLIP"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "audio_vae": [
+          "n5",
+          "VAE"
+        ],
+        "references": [
+          "n40",
+          "references"
+        ],
+        "state": [
+          "n12",
+          "state"
+        ],
+        "clip_index": [
+          "n12",
+          "clip_index"
+        ],
+        "clip_count": [
+          "n12",
+          "clip_count"
+        ],
+        "prompt": [
+          "n12",
+          "prompt"
+        ],
+        "width": [
+          "n12",
+          "width"
+        ],
+        "height": [
+          "n12",
+          "height"
+        ],
+        "length": [
+          "n12",
+          "length"
+        ]
+      },
+      "label": "MiniMax H3 Tagged Ref2VA — TAGGED REF2VA — COMPILES @TAGS PER SCENE"
+    },
+    {
+      "key": "n17",
+      "type": "MiniMaxH3ChainContext",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n12",
+          "state"
+        ],
+        "conditioning": [
+          "n16",
+          "positive"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "audio_vae": [
+          "n5",
+          "VAE"
+        ],
+        "latent": [
+          "n16",
+          "latent"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Context — AUTO CONTEXT — clip 1 bypass / continuation"
+    },
+    {
+      "key": "n18",
+      "type": "MiniMaxH3SigmaShift",
+      "settings": {
+        "shift_video": 12,
+        "shift_audio": 3
+      },
+      "inputs": {
+        "model": [
+          "n29",
+          "MODEL"
+        ]
+      }
+    },
+    {
+      "key": "n21",
+      "type": "BasicGuider",
+      "settings": {},
+      "inputs": {
+        "model": [
+          "n18",
+          "MODEL"
+        ],
+        "conditioning": [
+          "n17",
+          "conditioning"
+        ]
+      },
+      "label": "Basic Guider — Loop guider"
+    },
+    {
+      "key": "n22",
+      "type": "BasicScheduler",
+      "settings": {
+        "scheduler": "simple",
+        "steps": 20,
+        "denoise": 1
+      },
+      "inputs": {
+        "model": [
+          "n18",
+          "MODEL"
+        ],
+        "steps": [
+          "n12",
+          "steps"
+        ]
+      },
+      "label": "BasicScheduler — Per-shot scheduler steps"
+    },
+    {
+      "key": "n23",
+      "type": "SamplerCustomAdvanced",
+      "settings": {},
+      "inputs": {
+        "noise": [
+          "n15",
+          "NOISE"
+        ],
+        "guider": [
+          "n21",
+          "GUIDER"
+        ],
+        "sampler": [
+          "n3",
+          "SAMPLER"
+        ],
+        "sigmas": [
+          "n22",
+          "SIGMAS"
+        ],
+        "latent_image": [
+          "n17",
+          "latent"
+        ]
+      },
+      "label": "SamplerCustomAdvanced — H3 sampler — SINGLE LOOP BODY"
+    },
+    {
+      "key": "n24",
+      "type": "VAEDecode",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n23",
+          "output"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode — Decode current clip frames"
+    },
+    {
+      "key": "n25",
+      "type": "VAEDecodeAudio",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n23",
+          "output"
+        ],
+        "vae": [
+          "n5",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode Audio — Decode current clip audio"
+    },
+    {
+      "key": "n26",
+      "type": "MiniMaxH3LoopTrim",
+      "settings": {
+        "trim_frames": 0,
+        "fps": 24,
+        "match_tail": true,
+        "retain_overlap_frames": 5
+      },
+      "inputs": {
+        "images": [
+          "n24",
+          "IMAGE"
+        ],
+        "audio": [
+          "n25",
+          "AUDIO"
+        ],
+        "trim_frames": [
+          "n17",
+          "trim_frames"
+        ],
+        "state": [
+          "n12",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Trim — TRIM CONTEXT / AUTO-RESOLVE SCENE BLEND"
+    },
+    {
+      "key": "n27",
+      "type": "MiniMaxH3ChainSegmentSave",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n12",
+          "state"
+        ],
+        "images": [
+          "n26",
+          "images"
+        ],
+        "sampled_latent": [
+          "n23",
+          "output"
+        ],
+        "audio": [
+          "n26",
+          "audio"
+        ],
+        "images_with_overlap": [
+          "n26",
+          "images_with_overlap"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Segment + Checkpoint — SAVE DELIVERED + BLEND-READY SEGMENTS"
+    },
+    {
+      "key": "n28",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "ref2v_studio_source_audio_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n34",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — FINAL ASSEMBLY — 5-FRAME VISUAL BLEND"
+    },
+    {
+      "key": "n29",
+      "type": "ModelAttentionBackend",
+      "settings": {
+        "attention": "pytorch attention"
+      },
+      "inputs": {
+        "model": [
+          "n1",
+          "MODEL"
+        ]
+      },
+      "label": "ModelAttentionBackend — COMFY KITCHEN ATTENTION"
+    },
+    {
+      "key": "n30",
+      "type": "MiniMaxH3ChainManifestLoad",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n36",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Load Manifest — RECOVERY: LOAD ALL SAVED CLIPS",
+      "mode": 2
+    },
+    {
+      "key": "n31",
+      "type": "Note",
+      "settings": {
+        "text": "The two amber recovery nodes are MUTED by default.\n\nIf all segments finished but final assembly did not, mute the main green Assemble node, enable both recovery nodes, and queue. They validate every SHA-256 checkpoint pair and assemble without rerendering the completed clips.\n\nFor an interrupted generation, leave recovery muted and set Loop Start's start_clip to the first unfinished clip."
+      },
+      "inputs": {},
+      "label": "Note — RECOVERY / ASSEMBLE LATER"
+    },
+    {
+      "key": "n32",
+      "type": "Note",
+      "settings": {
+        "text": "REF2VA PROMPT FORMAT — SIX SECTIONS\n\nKeep subject_definitions, summary, retention_analysis, detailed_description, overall_soundscape, and non_diegetic_music in that order. References define identity; the prompt defines the new action."
+      },
+      "inputs": {},
+      "label": "REF2VA PROMPT FORMAT — SIX SECTIONS"
+    },
+    {
+      "key": "n33",
+      "type": "MiniMaxH3ChainReview",
+      "settings": {
+        "enabled": true,
+        "play_notification_sound": false,
+        "auto_continue_timeout_minutes": 0,
+        "unload_models_while_waiting": false,
+        "assemble_partial_on_stop": true,
+        "partial_audio_source": "checkpointed",
+        "candidate_count": 1,
+        "review_each_candidate": false
+      },
+      "inputs": {
+        "state": [
+          "n12",
+          "state"
+        ],
+        "segment": [
+          "n27",
+          "segment"
+        ],
+        "audio": [
+          "n26",
+          "audio"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Review Gate — REVIEW GATE — APPROVE / EDIT+RETRY / REROLL / STOP"
+    },
+    {
+      "key": "n34",
+      "type": "MiniMaxH3ChainLoopEnd",
+      "settings": {
+        "between_scene_cleanup": "off"
+      },
+      "inputs": {
+        "flow": [
+          "n9",
+          "flow"
+        ],
+        "state": [
+          "n12",
+          "state"
+        ],
+        "images": [
+          "n26",
+          "images"
+        ],
+        "sampled_latent": [
+          "n23",
+          "output"
+        ],
+        "segment": [
+          "n33",
+          "segment"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop End — LOOP END — ADVANCE REF2V SCENE"
+    },
+    {
+      "key": "n35",
+      "type": "Note",
+      "settings": {
+        "text": "0.6 Studio quick start\n\n1. Open the Project Asset Carousel and set a unique run name before importing assets.\n2. Import h3_v06_courier_greenhouse_arrival.png; tag courier_arrival (Picture).\n3. Import h3_v06_courier_greenhouse_delivery.png; tag greenhouse_delivery (Picture).\n4. Import/drop one audio file into the Carousel. Select its card and set Audio use → Project timeline source.\n5. Keep Generation Profile → Lip-sync to source audio (already selected), then edit scenes in Production Plan or Plan Studio.\n6. Queue; inspect, branch, trim, or restore in Checkpoint Manager.\n\nThe preset alone does not load an audio file. Carousel.project_assets already carries the source track to the Plan and loop; no separate Load Audio node, AUDIO cable, or @tag is needed."
+      },
+      "inputs": {},
+      "label": "0.6 STUDIO QUICK START"
+    },
+    {
+      "key": "n36",
+      "type": "MiniMaxH3ChainPlanStudio",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true,
+        "plan_json": "{\n  \"shots\": [\n    {\n      \"id\": \"intro\",\n      \"prompt\": \"Describe the opening shot.\"\n    },\n    {\n      \"id\": \"continuation\",\n      \"prompt\": \"Continue the same take.\"\n    }\n  ]\n}",
+        "run_name": "h3_chain",
+        "generation_fingerprint": "",
+        "width": 960,
+        "height": 544,
+        "context_length": 22,
+        "encode_mode": "video",
+        "anchor_mode": "head",
+        "crop": "disabled",
+        "audio_mode": "generated_audio",
+        "audio_context_length": 22,
+        "default_duration_seconds": 15.0,
+        "default_steps": 20,
+        "base_seed": 0,
+        "segment_crf": 18,
+        "video_blend_frames": 0,
+        "continuation_mode": "guide",
+        "alternate_take_json": ""
+      },
+      "inputs": {
+        "plan": [
+          "n38",
+          "plan"
+        ],
+        "tagged_references": [
+          "n40",
+          "references"
+        ],
+        "project_assets": [
+          "n40",
+          "project_assets"
+        ]
+      },
+      "label": "MiniMax H3 Plan Studio — TIMELINE / TAKES / TRIMS"
+    },
+    {
+      "key": "n37",
+      "type": "MiniMaxH3ChainRichScenePromptEditor",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n36",
+          "plan"
+        ]
+      }
+    },
+    {
+      "key": "n38",
+      "type": "MiniMaxH3ChainPlanModern",
+      "settings": {
+        "plan_json": "{\n  \"defaults\": {\n    \"steps\": 20\n  },\n  \"shots\": [\n    {\n      \"id\": \"reference_delivery\",\n      \"prompt\": \"subject_definitions:\\n@courier_arrival defines <Subject 1>, the exact adult bicycle courier, including his face, mustard-yellow waterproof jacket, dark teal trousers, charcoal helmet, olive messenger bag, silver bicycle, kraft parcel, proportions, and photographic rendering.\\n@greenhouse_delivery defines the greenhouse delivery destination, including the glass structure, wooden potting table, dense plants, warm practical bulbs, wet floor reflections, and the same courier's end pose.\\n<Subject 1> is the single courier shown by both references. Preserve his identity, clothing, equipment, and scale while allowing the described movement.\\n\\nsummary:\\n[reference generation] One continuous delivery moves <Subject 1> from the wet greenhouse entrance in @courier_arrival toward the completed parcel placement in @greenhouse_delivery.\\n\\nretention_analysis:\\n<Subject 1> (appears in [Shot 1]): fully_preserved - retain the exact face, adult age, body proportions, mustard jacket, teal trousers, helmet, bag, bicycle, and parcel across the complete shot.\\n@courier_arrival: fully_preserved - use its courier identity, wardrobe, bicycle geometry, exterior doorway, wet paving, camera height, and cool daylight as the opening state.\\n@greenhouse_delivery: reference - use its potting table, plants, warm bulbs, interior reflections, and delivery pose as the destination; do not copy the final pose before the action reaches it.\\n\\ndetailed_description:\\n[Shot 1] Begin at the greenhouse entrance with exactly one courier and one bicycle. He walks the bicycle through the open glass door, glances down to confirm the parcel, then turns toward the wooden potting table. The camera tracks laterally at walking speed with restrained handheld movement. He stops the bicycle with his left hand and sets the parcel on the clear corner of the table with his right hand. Preserve face, hands, clothing, bicycle structure, parcel dimensions, plant layout, lighting direction, and coherent reflections. End immediately after the parcel makes contact; no cut, duplicate subject, added customer, text, logo, or early freeze.\\n\\noverall_soundscape:\\nLight rain on greenhouse glass, wet tire roll, a quiet freewheel tick, rubber soles, door hinge, jacket movement, muted ventilation, and soft cardboard contact on wood. Keep every sound synchronized and spatially plausible.\\n\\nnon_diegetic_music:\\nNo non-diegetic music.\",\n      \"length\": 243,\n      \"steps\": 20,\n      \"seed\": \"6101\"\n    },\n    {\n      \"id\": \"reference_confirmation\",\n      \"prompt\": \"subject_definitions:\\n@courier_arrival preserves the exact identity, clothing, bicycle, parcel, exterior weather, and entrance geography established before the boundary.\\n@greenhouse_delivery defines the same greenhouse interior, potting table, plants, warm bulbs, and final delivery area.\\n<Subject 1> is the same single adult courier carried by the incoming H3 Motion Context and both references.\\n\\nsummary:\\n[reference generation] The uninterrupted delivery continues inside the greenhouse after the carried overlap and ends with the courier calmly confirming the parcel placement.\\n\\nretention_analysis:\\n<Subject 1> (appears in [Shot 1]): fully_preserved - preserve the exact face, mustard jacket, teal trousers, helmet, bag, body proportions, bicycle, and motion phase inherited from context.\\n@courier_arrival: reference - retain its cool exterior light and entrance geometry only where still visible behind the courier.\\n@greenhouse_delivery: fully_preserved - retain the greenhouse table, plant arrangement, warm practical lights, reflections, parcel position, and photographic rendering.\\n\\ndetailed_description:\\n[Shot 1] Continue directly from the incoming H3 Motion Context. The carried opening overlap already contains the threshold crossing; begin new action only after it and never reset the stride. The courier rolls the same bicycle beside the potting table, steadies it with his left hand, and places the kraft parcel on the dry corner with his right hand. He checks the label area without showing readable text, then gives a small satisfied smile. Keep exactly one person and one bicycle, stable hands, coherent wheels, continuous camera direction, and consistent light. No cut, duplicate, wardrobe change, or early freeze.\\n\\noverall_soundscape:\\nContinue rain-muted greenhouse ambience, footsteps, tire roll, freewheel ticks, clothing movement, ventilation, and the soft parcel contact without restarting any sound at the scene boundary.\\n\\nnon_diegetic_music:\\nNo non-diegetic music.\",\n      \"length\": 243,\n      \"steps\": 20,\n      \"seed\": \"6102\"\n    }\n  ]\n}",
+        "run_name": "ref2v_studio_source_audio_minimax_h3_0_6_json",
+        "generation_fingerprint": "",
+        "width": 896,
+        "height": 672,
+        "encode_mode": "video",
+        "crop": "disabled",
+        "default_duration_seconds": 10.0,
+        "default_steps": 20,
+        "base_seed": 0,
+        "segment_crf": 20,
+        "video_blend_frames": 5
+      },
+      "inputs": {
+        "chain_policy": [
+          "n39",
+          "chain_policy"
+        ],
+        "project_assets": [
+          "n40",
+          "project_assets"
+        ]
+      },
+      "label": "MiniMax H3 Production Plan — 0.6 SCENE COLUMNS"
+    },
+    {
+      "key": "n39",
+      "type": "MiniMaxH3GenerationProfile",
+      "settings": {
+        "scene_continuity": "Visual continuity",
+        "audio_profile": "Lip-sync to source audio"
+      },
+      "inputs": {},
+      "label": "MiniMax H3 Generation Profile — RELEASE DEFAULTS"
+    },
+    {
+      "key": "n40",
+      "type": "MiniMaxH3ProjectAssetManager",
+      "settings": {
+        "run_name": "ref2v_studio_source_audio_minimax_h3_0_6_json",
+        "catalog_json": "",
+        "semantic_anchor_size": "512",
+        "semantic_anchor_mode": "timestamped_video",
+        "operation_json": ""
+      },
+      "inputs": {},
+      "label": "MiniMax H3 Project Asset Carousel — IMPORT RELEASE REFERENCES"
+    },
+    {
+      "key": "n41",
+      "type": "MiniMaxH3ChainCheckpointManager",
+      "settings": {
+        "selection_json": ""
+      },
+      "inputs": {
+        "plan": [
+          "n36",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Checkpoint Manager — BRANCHES / PREVIEWS / RESTORE"
+    }
+  ]
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Ref2V Tagged - MiniMax H3 0.6.json b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Ref2V Tagged - MiniMax H3 0.6.json
new file mode 100644
index 0000000000000000000000000000000000000000..f4e12e8550dd58d48429ba8e4fb99c392fc60db3
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/Ref2V Tagged - MiniMax H3 0.6.json	
@@ -0,0 +1,635 @@
+{
+  "nodes": [
+    {
+      "key": "n1",
+      "type": "UNETLoader",
+      "settings": {
+        "unet_name": "minimax_h3_ref2va_pruned_int8_convrot.safetensors",
+        "weight_dtype": "default"
+      },
+      "inputs": {},
+      "label": "Load Diffusion Model — H3 MODEL — REQUIRED"
+    },
+    {
+      "key": "n2",
+      "type": "CLIPLoader",
+      "settings": {
+        "clip_name": "qwen3vl_32b_minimax_h3_int8_convrot.safetensors",
+        "type": "minimax",
+        "device": "default"
+      },
+      "inputs": {},
+      "label": "Load CLIP — H3 TEXT ENCODER"
+    },
+    {
+      "key": "n3",
+      "type": "KSamplerSelect",
+      "settings": {
+        "sampler_name": "res_multistep"
+      },
+      "inputs": {},
+      "label": "KSamplerSelect — Sampler algorithm"
+    },
+    {
+      "key": "n4",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_video_vae_fp16.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Video VAE"
+    },
+    {
+      "key": "n5",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_audio_vae_fp32.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Audio VAE"
+    },
+    {
+      "key": "n6",
+      "type": "Note",
+      "settings": {
+        "text": "0.6 ORIGINAL REFERENCE EXAMPLE\n\nThe matching courier and greenhouse pictures were generated specifically for this catalog. They replace the old community demonstration assets and prompts."
+      },
+      "inputs": {},
+      "label": "0.6 ORIGINAL REFERENCE EXAMPLE"
+    },
+    {
+      "key": "n7",
+      "type": "MiniMaxH3ChainScenePromptEditor",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n34",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Scene Prompt Editor — SCENE PROMPT EDITOR — STANDARD AUTHORING"
+    },
+    {
+      "key": "n8",
+      "type": "Note",
+      "settings": {
+        "text": "REF2VA PROMPT FORMAT — SIX SECTIONS\n\nKeep subject_definitions, summary, retention_analysis, detailed_description, overall_soundscape, and non_diegetic_music in that order. References define identity; the prompt defines the new action."
+      },
+      "inputs": {},
+      "label": "REF2VA PROMPT FORMAT — SIX SECTIONS"
+    },
+    {
+      "key": "n11",
+      "type": "MiniMaxH3ChainLoopStart",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true
+      },
+      "inputs": {
+        "plan": [
+          "n42",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Start — LOOP START / RESUME"
+    },
+    {
+      "key": "n14",
+      "type": "MiniMaxH3ChainCurrent",
+      "settings": {
+        "align_audio_reference": false
+      },
+      "inputs": {
+        "state": [
+          "n11",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Current Shot — CURRENT REF2V SCENE — PROMPT / SEED / TIMING"
+    },
+    {
+      "key": "n15",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "t2v_normal_recovered_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n36",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — RECOVERY: ASSEMBLE WITHOUT RENDERING",
+      "mode": 2
+    },
+    {
+      "key": "n17",
+      "type": "RandomNoise",
+      "settings": {
+        "noise_seed": 0,
+        "control_after_generate": "fixed"
+      },
+      "inputs": {
+        "noise_seed": [
+          "n14",
+          "noise_seed"
+        ]
+      },
+      "label": "RandomNoise — Per-shot noise seed"
+    },
+    {
+      "key": "n18",
+      "type": "MiniMaxH3TaggedReferenceToVideo",
+      "settings": {
+        "clip_index": 1,
+        "clip_count": 2,
+        "prompt": "subject_definitions:\n@courier_arrival defines <Subject 1>, the exact adult bicycle courier, including his face, mustard-yellow waterproof jacket, dark teal trousers, charcoal helmet, olive messenger bag, silver bicycle, kraft parcel, proportions, and photographic rendering.\n@greenhouse_delivery defines the greenhouse delivery destination, including the glass structure, wooden potting table, dense plants, warm practical bulbs, wet floor reflections, and the same courier's end pose.\n<Subject 1> is the single courier shown by both references. Preserve his identity, clothing, equipment, and scale while allowing the described movement.\n\nsummary:\n[reference generation] One continuous delivery moves <Subject 1> from the wet greenhouse entrance in @courier_arrival toward the completed parcel placement in @greenhouse_delivery.\n\nretention_analysis:\n<Subject 1> (appears in [Shot 1]): fully_preserved - retain the exact face, adult age, body proportions, mustard jacket, teal trousers, helmet, bag, bicycle, and parcel across the complete shot.\n@courier_arrival: fully_preserved - use its courier identity, wardrobe, bicycle geometry, exterior doorway, wet paving, camera height, and cool daylight as the opening state.\n@greenhouse_delivery: reference - use its potting table, plants, warm bulbs, interior reflections, and delivery pose as the destination; do not copy the final pose before the action reaches it.\n\ndetailed_description:\n[Shot 1] Begin at the greenhouse entrance with exactly one courier and one bicycle. He walks the bicycle through the open glass door, glances down to confirm the parcel, then turns toward the wooden potting table. The camera tracks laterally at walking speed with restrained handheld movement. He stops the bicycle with his left hand and sets the parcel on the clear corner of the table with his right hand. Preserve face, hands, clothing, bicycle structure, parcel dimensions, plant layout, lighting direction, and coherent reflections. End immediately after the parcel makes contact; no cut, duplicate subject, added customer, text, logo, or early freeze.\n\noverall_soundscape:\nLight rain on greenhouse glass, wet tire roll, a quiet freewheel tick, rubber soles, door hinge, jacket movement, muted ventilation, and soft cardboard contact on wood. Keep every sound synchronized and spatially plausible.\n\nnon_diegetic_music:\nNo non-diegetic music.",
+        "width": 896,
+        "height": 672,
+        "length": 243,
+        "ref_image_size": "match",
+        "reference_policy": "strict",
+        "semantic_anchor_size": "512",
+        "semantic_anchor_mode": "timestamped_video",
+        "cache_for_upscale": true,
+        "conditioning_backend": "native_ref2va"
+      },
+      "inputs": {
+        "clip": [
+          "n2",
+          "CLIP"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "audio_vae": [
+          "n5",
+          "VAE"
+        ],
+        "references": [
+          "n41",
+          "references"
+        ],
+        "clip_index": [
+          "n14",
+          "clip_index"
+        ],
+        "clip_count": [
+          "n14",
+          "clip_count"
+        ],
+        "prompt": [
+          "n14",
+          "prompt"
+        ],
+        "width": [
+          "n14",
+          "width"
+        ],
+        "height": [
+          "n14",
+          "height"
+        ],
+        "length": [
+          "n14",
+          "length"
+        ]
+      },
+      "label": "MiniMax H3 Tagged Ref2VA — TAGGED REF2VA — COMPILES @TAGS PER SCENE"
+    },
+    {
+      "key": "n19",
+      "type": "MiniMaxH3ChainContext",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n14",
+          "state"
+        ],
+        "conditioning": [
+          "n18",
+          "positive"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "latent": [
+          "n18",
+          "latent"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Context — AUTO CONTEXT — clip 1 bypass / continuation"
+    },
+    {
+      "key": "n20",
+      "type": "MiniMaxH3SigmaShift",
+      "settings": {
+        "shift_video": 12,
+        "shift_audio": 3
+      },
+      "inputs": {
+        "model": [
+          "n31",
+          "MODEL"
+        ]
+      }
+    },
+    {
+      "key": "n23",
+      "type": "BasicGuider",
+      "settings": {},
+      "inputs": {
+        "model": [
+          "n20",
+          "MODEL"
+        ],
+        "conditioning": [
+          "n19",
+          "conditioning"
+        ]
+      },
+      "label": "Basic Guider — Loop guider"
+    },
+    {
+      "key": "n24",
+      "type": "BasicScheduler",
+      "settings": {
+        "scheduler": "simple",
+        "steps": 20,
+        "denoise": 1
+      },
+      "inputs": {
+        "model": [
+          "n20",
+          "MODEL"
+        ],
+        "steps": [
+          "n14",
+          "steps"
+        ]
+      },
+      "label": "BasicScheduler — Per-shot scheduler steps"
+    },
+    {
+      "key": "n25",
+      "type": "SamplerCustomAdvanced",
+      "settings": {},
+      "inputs": {
+        "noise": [
+          "n17",
+          "NOISE"
+        ],
+        "guider": [
+          "n23",
+          "GUIDER"
+        ],
+        "sampler": [
+          "n3",
+          "SAMPLER"
+        ],
+        "sigmas": [
+          "n24",
+          "SIGMAS"
+        ],
+        "latent_image": [
+          "n19",
+          "latent"
+        ]
+      },
+      "label": "SamplerCustomAdvanced — H3 sampler — SINGLE LOOP BODY"
+    },
+    {
+      "key": "n26",
+      "type": "VAEDecode",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n25",
+          "output"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode — Decode current clip frames"
+    },
+    {
+      "key": "n27",
+      "type": "VAEDecodeAudio",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n25",
+          "output"
+        ],
+        "vae": [
+          "n5",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode Audio — Decode current clip audio"
+    },
+    {
+      "key": "n28",
+      "type": "MiniMaxH3LoopTrim",
+      "settings": {
+        "trim_frames": 0,
+        "fps": 24,
+        "match_tail": true,
+        "retain_overlap_frames": 0
+      },
+      "inputs": {
+        "images": [
+          "n26",
+          "IMAGE"
+        ],
+        "audio": [
+          "n27",
+          "AUDIO"
+        ],
+        "trim_frames": [
+          "n19",
+          "trim_frames"
+        ],
+        "state": [
+          "n14",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Trim — TRIM CONTEXT / AUTO-RESOLVE SCENE BLEND"
+    },
+    {
+      "key": "n29",
+      "type": "MiniMaxH3ChainSegmentSave",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n14",
+          "state"
+        ],
+        "images": [
+          "n28",
+          "images"
+        ],
+        "sampled_latent": [
+          "n25",
+          "output"
+        ],
+        "audio": [
+          "n28",
+          "audio"
+        ],
+        "images_with_overlap": [
+          "n28",
+          "images_with_overlap"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Segment + Checkpoint — SAVE DELIVERED + BLEND-READY SEGMENTS"
+    },
+    {
+      "key": "n30",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "t2v_normal_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n32",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — FINAL ASSEMBLY — 5-FRAME VISUAL BLEND"
+    },
+    {
+      "key": "n31",
+      "type": "ModelAttentionBackend",
+      "settings": {
+        "attention": "pytorch attention"
+      },
+      "inputs": {
+        "model": [
+          "n1",
+          "MODEL"
+        ]
+      },
+      "label": "ModelAttentionBackend — COMFY KITCHEN ATTENTION"
+    },
+    {
+      "key": "n32",
+      "type": "MiniMaxH3ChainLoopEnd",
+      "settings": {
+        "between_scene_cleanup": "off"
+      },
+      "inputs": {
+        "flow": [
+          "n11",
+          "flow"
+        ],
+        "state": [
+          "n14",
+          "state"
+        ],
+        "images": [
+          "n28",
+          "images"
+        ],
+        "sampled_latent": [
+          "n25",
+          "output"
+        ],
+        "segment": [
+          "n35",
+          "segment"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop End — LOOP END — ADVANCE REF2V SCENE"
+    },
+    {
+      "key": "n33",
+      "type": "Note",
+      "settings": {
+        "text": "REF2V 0.6 QUICK START\n\nCopy both courier PNGs to ComfyUI/input. The two picture references are activated as courier_arrival and greenhouse_delivery. Edit the Plan, then queue and approve each checkpointed scene."
+      },
+      "inputs": {},
+      "label": "REF2V 0.6 QUICK START"
+    },
+    {
+      "key": "n34",
+      "type": "MiniMaxH3ChainPlanModern",
+      "settings": {
+        "plan_json": "{\n  \"defaults\": {\n    \"steps\": 20\n  },\n  \"shots\": [\n    {\n      \"id\": \"reference_delivery\",\n      \"prompt\": \"subject_definitions:\\n@courier_arrival defines <Subject 1>, the exact adult bicycle courier, including his face, mustard-yellow waterproof jacket, dark teal trousers, charcoal helmet, olive messenger bag, silver bicycle, kraft parcel, proportions, and photographic rendering.\\n@greenhouse_delivery defines the greenhouse delivery destination, including the glass structure, wooden potting table, dense plants, warm practical bulbs, wet floor reflections, and the same courier's end pose.\\n<Subject 1> is the single courier shown by both references. Preserve his identity, clothing, equipment, and scale while allowing the described movement.\\n\\nsummary:\\n[reference generation] One continuous delivery moves <Subject 1> from the wet greenhouse entrance in @courier_arrival toward the completed parcel placement in @greenhouse_delivery.\\n\\nretention_analysis:\\n<Subject 1> (appears in [Shot 1]): fully_preserved - retain the exact face, adult age, body proportions, mustard jacket, teal trousers, helmet, bag, bicycle, and parcel across the complete shot.\\n@courier_arrival: fully_preserved - use its courier identity, wardrobe, bicycle geometry, exterior doorway, wet paving, camera height, and cool daylight as the opening state.\\n@greenhouse_delivery: reference - use its potting table, plants, warm bulbs, interior reflections, and delivery pose as the destination; do not copy the final pose before the action reaches it.\\n\\ndetailed_description:\\n[Shot 1] Begin at the greenhouse entrance with exactly one courier and one bicycle. He walks the bicycle through the open glass door, glances down to confirm the parcel, then turns toward the wooden potting table. The camera tracks laterally at walking speed with restrained handheld movement. He stops the bicycle with his left hand and sets the parcel on the clear corner of the table with his right hand. Preserve face, hands, clothing, bicycle structure, parcel dimensions, plant layout, lighting direction, and coherent reflections. End immediately after the parcel makes contact; no cut, duplicate subject, added customer, text, logo, or early freeze.\\n\\noverall_soundscape:\\nLight rain on greenhouse glass, wet tire roll, a quiet freewheel tick, rubber soles, door hinge, jacket movement, muted ventilation, and soft cardboard contact on wood. Keep every sound synchronized and spatially plausible.\\n\\nnon_diegetic_music:\\nNo non-diegetic music.\",\n      \"length\": 243,\n      \"steps\": 20,\n      \"seed\": \"6101\"\n    },\n    {\n      \"id\": \"reference_confirmation\",\n      \"prompt\": \"subject_definitions:\\n@courier_arrival preserves the exact identity, clothing, bicycle, parcel, exterior weather, and entrance geography established before the boundary.\\n@greenhouse_delivery defines the same greenhouse interior, potting table, plants, warm bulbs, and final delivery area.\\n<Subject 1> is the same single adult courier carried by the incoming H3 Motion Context and both references.\\n\\nsummary:\\n[reference generation] The uninterrupted delivery continues inside the greenhouse after the carried overlap and ends with the courier calmly confirming the parcel placement.\\n\\nretention_analysis:\\n<Subject 1> (appears in [Shot 1]): fully_preserved - preserve the exact face, mustard jacket, teal trousers, helmet, bag, body proportions, bicycle, and motion phase inherited from context.\\n@courier_arrival: reference - retain its cool exterior light and entrance geometry only where still visible behind the courier.\\n@greenhouse_delivery: fully_preserved - retain the greenhouse table, plant arrangement, warm practical lights, reflections, parcel position, and photographic rendering.\\n\\ndetailed_description:\\n[Shot 1] Continue directly from the incoming H3 Motion Context. The carried opening overlap already contains the threshold crossing; begin new action only after it and never reset the stride. The courier rolls the same bicycle beside the potting table, steadies it with his left hand, and places the kraft parcel on the dry corner with his right hand. He checks the label area without showing readable text, then gives a small satisfied smile. Keep exactly one person and one bicycle, stable hands, coherent wheels, continuous camera direction, and consistent light. No cut, duplicate, wardrobe change, or early freeze.\\n\\noverall_soundscape:\\nContinue rain-muted greenhouse ambience, footsteps, tire roll, freewheel ticks, clothing movement, ventilation, and the soft parcel contact without restarting any sound at the scene boundary.\\n\\nnon_diegetic_music:\\nNo non-diegetic music.\",\n      \"length\": 243,\n      \"steps\": 20,\n      \"seed\": \"6102\"\n    }\n  ]\n}",
+        "run_name": "ref2v_tagged_minimax_h3_0_6_json",
+        "generation_fingerprint": "h3-v06-release-example",
+        "width": 896,
+        "height": 672,
+        "encode_mode": "video",
+        "crop": "disabled",
+        "default_duration_seconds": 10.0,
+        "default_steps": 20,
+        "base_seed": 0,
+        "segment_crf": 20,
+        "video_blend_frames": 0
+      },
+      "inputs": {
+        "chain_policy": [
+          "n43",
+          "chain_policy"
+        ],
+        "generation_fingerprint": [
+          "n41",
+          "reference_fingerprint"
+        ]
+      },
+      "label": "MiniMax H3 Production Plan — 0.6 SCENE COLUMNS"
+    },
+    {
+      "key": "n35",
+      "type": "MiniMaxH3ChainReview",
+      "settings": {
+        "enabled": true,
+        "play_notification_sound": false,
+        "auto_continue_timeout_minutes": 0,
+        "unload_models_while_waiting": false,
+        "assemble_partial_on_stop": true,
+        "partial_audio_source": "checkpointed",
+        "candidate_count": 1,
+        "review_each_candidate": false
+      },
+      "inputs": {
+        "state": [
+          "n14",
+          "state"
+        ],
+        "segment": [
+          "n29",
+          "segment"
+        ],
+        "audio": [
+          "n28",
+          "audio"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Review Gate — REVIEW GATE — APPROVE / EDIT+RETRY / REROLL / STOP"
+    },
+    {
+      "key": "n36",
+      "type": "MiniMaxH3ChainManifestLoad",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n7",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Load Manifest — RECOVERY: LOAD ALL SAVED CLIPS",
+      "mode": 2
+    },
+    {
+      "key": "n37",
+      "type": "Note",
+      "settings": {
+        "text": "The two amber recovery nodes are MUTED by default.\n\nIf all segments finished but final assembly did not, mute the main green Assemble node, enable both recovery nodes, and queue. They validate every SHA-256 checkpoint pair and assemble without rerendering the completed clips.\n\nFor an interrupted generation, leave recovery muted and set Loop Start's start_clip to the first unfinished clip."
+      },
+      "inputs": {},
+      "label": "Note — RECOVERY / ASSEMBLE LATER"
+    },
+    {
+      "key": "n38",
+      "type": "LoadImage",
+      "settings": {
+        "image": "h3_v06_courier_greenhouse_arrival.png"
+      },
+      "inputs": {},
+      "label": "Load Image — 0.6 COURIER ARRIVAL"
+    },
+    {
+      "key": "n39",
+      "type": "LoadImage",
+      "settings": {
+        "image": "h3_v06_courier_greenhouse_delivery.png"
+      },
+      "inputs": {},
+      "label": "Load Image — 0.6 GREENHOUSE DELIVERY"
+    },
+    {
+      "key": "n40",
+      "type": "MiniMaxH3TaggedPictureReference",
+      "settings": {
+        "tag": "courier_arrival"
+      },
+      "inputs": {
+        "image": [
+          "n38",
+          "IMAGE"
+        ]
+      },
+      "label": "MiniMax H3 Tagged Picture Ref — @courier_arrival"
+    },
+    {
+      "key": "n41",
+      "type": "MiniMaxH3TaggedPictureReference",
+      "settings": {
+        "tag": "greenhouse_delivery"
+      },
+      "inputs": {
+        "image": [
+          "n39",
+          "IMAGE"
+        ],
+        "previous": [
+          "n40",
+          "references"
+        ]
+      },
+      "label": "MiniMax H3 Tagged Picture Ref — @greenhouse_delivery"
+    },
+    {
+      "key": "n42",
+      "type": "MiniMaxH3ChainPreflight",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true
+      },
+      "inputs": {
+        "plan": [
+          "n7",
+          "plan"
+        ],
+        "tagged_references": [
+          "n41",
+          "references"
+        ]
+      },
+      "label": "MiniMax H3 Chain Preflight — 0.6 PREFLIGHT — BLOCKS BEFORE MODELS"
+    },
+    {
+      "key": "n43",
+      "type": "MiniMaxH3GenerationProfile",
+      "settings": {
+        "scene_continuity": "Visual continuity",
+        "audio_profile": "Generate audio"
+      },
+      "inputs": {},
+      "label": "MiniMax H3 Generation Profile — RELEASE DEFAULTS"
+    }
+  ]
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/T2V Normal - MiniMax H3 0.6.json b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/T2V Normal - MiniMax H3 0.6.json
new file mode 100644
index 0000000000000000000000000000000000000000..b873100088b507d89af52de051eedfb553f826c5
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/T2V Normal - MiniMax H3 0.6.json	
@@ -0,0 +1,541 @@
+{
+  "nodes": [
+    {
+      "key": "n1",
+      "type": "Note",
+      "settings": {
+        "text": "0.6 ORIGINAL PROMPT\n\nThis quiet predawn tram-stop example was written for the 0.6 release catalog. It uses concrete physical action, one counted subject, restrained camera movement, and no third-party character or brand."
+      },
+      "inputs": {},
+      "label": "0.6 ORIGINAL PROMPT"
+    },
+    {
+      "key": "n2",
+      "type": "MiniMaxH3ChainScenePromptEditor",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n8",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Scene Prompt Editor — SCENE PROMPT EDITOR — STANDARD AUTHORING"
+    },
+    {
+      "key": "n3",
+      "type": "Note",
+      "settings": {
+        "text": "T2VA PROMPT FORMAT\n\nEach scene uses the exact three-section H3 shape: integrated_multimodal_description, overall_soundscape, and non_diegetic_music. Scene 2 explicitly treats the carried overlap as already elapsed before new action begins."
+      },
+      "inputs": {},
+      "label": "T2VA PROMPT FORMAT"
+    },
+    {
+      "key": "n5",
+      "type": "MiniMaxH3SigmaShift",
+      "settings": {
+        "shift_video": 12,
+        "shift_audio": 3
+      },
+      "inputs": {
+        "model": [
+          "n40",
+          "MODEL"
+        ]
+      }
+    },
+    {
+      "key": "n8",
+      "type": "MiniMaxH3ChainPlanModern",
+      "settings": {
+        "plan_json": "{\n  \"defaults\": {\n    \"steps\": 20\n  },\n  \"shots\": [\n    {\n      \"id\": \"tram_stop_arrival\",\n      \"prompt\": \"integrated_multimodal_description:\\n[Shot 1] A grounded cinematic wide shot at a rain-darkened neighborhood tram stop just before dawn. One elderly watchmaker in a navy wool coat waits beneath the shelter, holding a small paper parcel with both hands. Sodium streetlights glow in wet pavement while an empty tram approaches from deep background. The camera makes a slow, steady push toward him. He hears the rails sing, looks up, and takes one deliberate step toward the curb. Keep exactly one person, natural body mechanics, restrained contrast, fine rain, and realistic lens breathing. End with the tram entering frame and his step still in progress.\\n\\noverall_soundscape:\\nFine rain on glass, distant tires on wet road, a low electrical rail hum, the approaching tram bell, coat fabric, and one measured footstep. Preserve a quiet predawn acoustic space.\\n\\nnon_diegetic_music:\\nNo non-diegetic music.\",\n      \"length\": 243,\n      \"steps\": 20,\n      \"seed\": \"6101\"\n    },\n    {\n      \"id\": \"tram_boarding\",\n      \"prompt\": \"integrated_multimodal_description:\\n[Shot 1] Continue the same unbroken predawn tram-stop moment from the incoming H3 Motion Context. The carried opening overlap already contains the watchmaker's step and the tram entering frame; begin new action only after that overlap. Preserve his identity, navy coat, parcel, lighting direction, rain density, camera height, lens, and left-to-right tram motion. He completes the step, the doors align beside him and open, and warm interior light reaches across the wet pavement. He gives the parcel a protective glance and boards in one calm motion while the camera settles outside. No cut, no extra pedestrian, no reset of the carried movement.\\n\\noverall_soundscape:\\nContinue the same rain and rail hum through the boundary. Add braking metal, a soft pneumatic door release, one final pavement step, two hollow tram-floor steps, and subdued interior ventilation without restarting the ambience.\\n\\nnon_diegetic_music:\\nNo non-diegetic music.\",\n      \"length\": 243,\n      \"steps\": 20,\n      \"seed\": \"6102\"\n    }\n  ]\n}",
+        "run_name": "t2v_normal_minimax_h3_0_6_json",
+        "generation_fingerprint": "h3-v06-release-example",
+        "width": 544,
+        "height": 960,
+        "encode_mode": "video",
+        "crop": "disabled",
+        "default_duration_seconds": 10,
+        "default_steps": 20,
+        "base_seed": 0,
+        "segment_crf": 20,
+        "video_blend_frames": 0
+      },
+      "inputs": {
+        "chain_policy": [
+          "n9",
+          "chain_policy"
+        ]
+      },
+      "label": "MiniMax H3 Production Plan — 0.6 SCENE COLUMNS"
+    },
+    {
+      "key": "n9",
+      "type": "MiniMaxH3GenerationProfile",
+      "settings": {
+        "scene_continuity": "Visual continuity",
+        "audio_profile": "Generate audio"
+      },
+      "inputs": {},
+      "label": "MiniMax H3 Generation Profile — RELEASE DEFAULTS"
+    },
+    {
+      "key": "n10",
+      "type": "UNETLoader",
+      "settings": {
+        "unet_name": "minimax_h3_fl2va_pruned_int8_convrot.safetensors",
+        "weight_dtype": "default"
+      },
+      "inputs": {},
+      "label": "Load Diffusion Model — H3 MODEL — REQUIRED"
+    },
+    {
+      "key": "n11",
+      "type": "MiniMaxH3ChainLoopStart",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true
+      },
+      "inputs": {
+        "plan": [
+          "n2",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Start — LOOP START / RESUME"
+    },
+    {
+      "key": "n12",
+      "type": "Note",
+      "settings": {
+        "text": "The two amber recovery nodes are MUTED by default.\n\nIf all segments finished but final assembly did not, mute the main green Assemble node, enable both recovery nodes, and queue. They validate every SHA-256 checkpoint pair and assemble without rerendering the completed clips.\n\nFor an interrupted generation, leave recovery muted and set Loop Start's start_clip to the first unfinished clip."
+      },
+      "inputs": {},
+      "label": "Note — RECOVERY / ASSEMBLE LATER"
+    },
+    {
+      "key": "n13",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "t2v_normal_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n14",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — FINAL ASSEMBLY — 5-FRAME VISUAL BLEND"
+    },
+    {
+      "key": "n14",
+      "type": "MiniMaxH3ChainLoopEnd",
+      "settings": {
+        "between_scene_cleanup": "off"
+      },
+      "inputs": {
+        "flow": [
+          "n11",
+          "flow"
+        ],
+        "state": [
+          "n21",
+          "state"
+        ],
+        "images": [
+          "n33",
+          "images"
+        ],
+        "sampled_latent": [
+          "n19",
+          "output"
+        ],
+        "segment": [
+          "n38",
+          "segment"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop End — LOOP END — ADVANCE T2V SCENE"
+    },
+    {
+      "key": "n15",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "t2v_normal_recovered_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n16",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — RECOVERY: ASSEMBLE WITHOUT RENDERING",
+      "mode": 2
+    },
+    {
+      "key": "n16",
+      "type": "MiniMaxH3ChainManifestLoad",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n2",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Load Manifest — RECOVERY: LOAD ALL SAVED CLIPS",
+      "mode": 2
+    },
+    {
+      "key": "n17",
+      "type": "VAEDecodeAudio",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n19",
+          "output"
+        ],
+        "vae": [
+          "n27",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode Audio — Decode current clip audio"
+    },
+    {
+      "key": "n18",
+      "type": "VAEDecode",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n19",
+          "output"
+        ],
+        "vae": [
+          "n29",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode — Decode current clip frames"
+    },
+    {
+      "key": "n19",
+      "type": "SamplerCustomAdvanced",
+      "settings": {},
+      "inputs": {
+        "noise": [
+          "n23",
+          "NOISE"
+        ],
+        "guider": [
+          "n22",
+          "GUIDER"
+        ],
+        "sampler": [
+          "n24",
+          "SAMPLER"
+        ],
+        "sigmas": [
+          "n25",
+          "SIGMAS"
+        ],
+        "latent_image": [
+          "n34",
+          "latent"
+        ]
+      },
+      "label": "SamplerCustomAdvanced — H3 sampler — SINGLE LOOP BODY"
+    },
+    {
+      "key": "n20",
+      "type": "MiniMaxH3ImageToVideo",
+      "settings": {
+        "prompt": "integrated_multimodal_description:\n[Shot 1] A grounded cinematic wide shot at a rain-darkened neighborhood tram stop just before dawn. One elderly watchmaker in a navy wool coat waits beneath the shelter, holding a small paper parcel with both hands. Sodium streetlights glow in wet pavement while an empty tram approaches from deep background. The camera makes a slow, steady push toward him. He hears the rails sing, looks up, and takes one deliberate step toward the curb. Keep exactly one person, natural body mechanics, restrained contrast, fine rain, and realistic lens breathing. End with the tram entering frame and his step still in progress.\n\noverall_soundscape:\nFine rain on glass, distant tires on wet road, a low electrical rail hum, the approaching tram bell, coat fabric, and one measured footstep. Preserve a quiet predawn acoustic space.\n\nnon_diegetic_music:\nNo non-diegetic music.",
+        "width": 544,
+        "height": 960,
+        "length": 243
+      },
+      "inputs": {
+        "clip": [
+          "n26",
+          "CLIP"
+        ],
+        "vae": [
+          "n29",
+          "VAE"
+        ],
+        "prompt": [
+          "n21",
+          "prompt"
+        ],
+        "width": [
+          "n21",
+          "width"
+        ],
+        "height": [
+          "n21",
+          "height"
+        ],
+        "length": [
+          "n21",
+          "length"
+        ]
+      },
+      "label": "MiniMax H3 Image to Video — CORE T2VA — NO IMAGE INPUTS"
+    },
+    {
+      "key": "n21",
+      "type": "MiniMaxH3ChainCurrent",
+      "settings": {
+        "align_audio_reference": false
+      },
+      "inputs": {
+        "state": [
+          "n11",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Current Shot — CURRENT T2V SCENE — PROMPT / SEED / TIMING"
+    },
+    {
+      "key": "n22",
+      "type": "BasicGuider",
+      "settings": {},
+      "inputs": {
+        "model": [
+          "n5",
+          "MODEL"
+        ],
+        "conditioning": [
+          "n34",
+          "conditioning"
+        ]
+      },
+      "label": "Basic Guider — Loop guider"
+    },
+    {
+      "key": "n23",
+      "type": "RandomNoise",
+      "settings": {
+        "noise_seed": 0,
+        "control_after_generate": "fixed"
+      },
+      "inputs": {
+        "noise_seed": [
+          "n21",
+          "noise_seed"
+        ]
+      },
+      "label": "RandomNoise — Per-shot noise seed"
+    },
+    {
+      "key": "n24",
+      "type": "KSamplerSelect",
+      "settings": {
+        "sampler_name": "res_multistep"
+      },
+      "inputs": {},
+      "label": "KSamplerSelect — Sampler algorithm"
+    },
+    {
+      "key": "n25",
+      "type": "BasicScheduler",
+      "settings": {
+        "scheduler": "simple",
+        "steps": 20,
+        "denoise": 1
+      },
+      "inputs": {
+        "model": [
+          "n5",
+          "MODEL"
+        ],
+        "steps": [
+          "n21",
+          "steps"
+        ]
+      },
+      "label": "BasicScheduler — Per-shot scheduler steps"
+    },
+    {
+      "key": "n26",
+      "type": "CLIPLoader",
+      "settings": {
+        "clip_name": "qwen3vl_32b_minimax_h3_int8_convrot.safetensors",
+        "type": "minimax",
+        "device": "default"
+      },
+      "inputs": {},
+      "label": "Load CLIP — H3 TEXT ENCODER"
+    },
+    {
+      "key": "n27",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_audio_vae_fp32.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Audio VAE"
+    },
+    {
+      "key": "n29",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_video_vae_fp16.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Video VAE"
+    },
+    {
+      "key": "n33",
+      "type": "MiniMaxH3LoopTrim",
+      "settings": {
+        "trim_frames": 0,
+        "fps": 24,
+        "match_tail": true,
+        "retain_overlap_frames": 0
+      },
+      "inputs": {
+        "images": [
+          "n18",
+          "IMAGE"
+        ],
+        "audio": [
+          "n17",
+          "AUDIO"
+        ],
+        "state": [
+          "n21",
+          "state"
+        ],
+        "trim_frames": [
+          "n34",
+          "trim_frames"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Trim — TRIM CONTEXT / AUTO-RESOLVE SCENE BLEND"
+    },
+    {
+      "key": "n34",
+      "type": "MiniMaxH3ChainContext",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n21",
+          "state"
+        ],
+        "conditioning": [
+          "n20",
+          "positive"
+        ],
+        "vae": [
+          "n29",
+          "VAE"
+        ],
+        "latent": [
+          "n20",
+          "LATENT"
+        ],
+        "audio_vae": [
+          "n27",
+          "VAE"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Context — AUTO CONTEXT — clip 1 bypass / continuation"
+    },
+    {
+      "key": "n37",
+      "type": "MiniMaxH3ChainSegmentSave",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n21",
+          "state"
+        ],
+        "images": [
+          "n33",
+          "images"
+        ],
+        "sampled_latent": [
+          "n19",
+          "output"
+        ],
+        "audio": [
+          "n33",
+          "audio"
+        ],
+        "images_with_overlap": [
+          "n33",
+          "images_with_overlap"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Segment + Checkpoint — SAVE DELIVERED + BLEND-READY SEGMENTS"
+    },
+    {
+      "key": "n38",
+      "type": "MiniMaxH3ChainReview",
+      "settings": {
+        "enabled": true,
+        "play_notification_sound": false,
+        "auto_continue_timeout_minutes": 0,
+        "unload_models_while_waiting": false,
+        "assemble_partial_on_stop": true,
+        "partial_audio_source": "checkpointed",
+        "candidate_count": 1,
+        "review_each_candidate": false
+      },
+      "inputs": {
+        "state": [
+          "n21",
+          "state"
+        ],
+        "segment": [
+          "n37",
+          "segment"
+        ],
+        "audio": [
+          "n33",
+          "audio"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Review Gate — REVIEW GATE — APPROVE / EDIT+RETRY / REROLL / STOP"
+    },
+    {
+      "key": "n39",
+      "type": "Note",
+      "settings": {
+        "text": "T2V 0.6 QUICK START\n\nSelect installed H3 model, text encoder, video VAE, and audio VAE files. Edit the two scene columns, keep Generation Profile on Visual continuity + Generate audio, then queue and approve each checkpointed scene."
+      },
+      "inputs": {},
+      "label": "T2V 0.6 QUICK START"
+    },
+    {
+      "key": "n40",
+      "type": "ModelAttentionBackend",
+      "settings": {
+        "attention": "pytorch attention"
+      },
+      "inputs": {
+        "model": [
+          "n10",
+          "MODEL"
+        ]
+      },
+      "label": "ModelAttentionBackend — COMFY KITCHEN ATTENTION"
+    }
+  ]
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/T2V Studio - MiniMax H3 0.6.json b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/T2V Studio - MiniMax H3 0.6.json
new file mode 100644
index 0000000000000000000000000000000000000000..0533c55f795f7d004b1e802eb04fafadea10cc00
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tools/v06/recipes/T2V Studio - MiniMax H3 0.6.json	
@@ -0,0 +1,609 @@
+{
+  "nodes": [
+    {
+      "key": "n1",
+      "type": "UNETLoader",
+      "settings": {
+        "unet_name": "minimax_h3_fl2va_pruned_int8_convrot.safetensors",
+        "weight_dtype": "default"
+      },
+      "inputs": {},
+      "label": "Load Diffusion Model — H3 MODEL — REQUIRED"
+    },
+    {
+      "key": "n2",
+      "type": "CLIPLoader",
+      "settings": {
+        "clip_name": "qwen3vl_32b_minimax_h3_int8_convrot.safetensors",
+        "type": "minimax",
+        "device": "default"
+      },
+      "inputs": {},
+      "label": "Load CLIP — H3 TEXT ENCODER"
+    },
+    {
+      "key": "n3",
+      "type": "KSamplerSelect",
+      "settings": {
+        "sampler_name": "res_multistep"
+      },
+      "inputs": {},
+      "label": "KSamplerSelect — Sampler algorithm"
+    },
+    {
+      "key": "n4",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_video_vae_fp16.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Video VAE"
+    },
+    {
+      "key": "n5",
+      "type": "VAELoader",
+      "settings": {
+        "vae_name": "minimax_h3_audio_vae_fp32.safetensors"
+      },
+      "inputs": {},
+      "label": "Load VAE — H3 Audio VAE"
+    },
+    {
+      "key": "n6",
+      "type": "Note",
+      "settings": {
+        "text": "0.6 ORIGINAL PROMPT\n\nThis quiet predawn tram-stop example was written for the 0.6 release catalog. It uses concrete physical action, one counted subject, restrained camera movement, and no third-party character or brand."
+      },
+      "inputs": {},
+      "label": "0.6 ORIGINAL PROMPT"
+    },
+    {
+      "key": "n7",
+      "type": "Note",
+      "settings": {
+        "text": "T2VA PROMPT FORMAT\n\nEach scene uses the exact three-section H3 shape: integrated_multimodal_description, overall_soundscape, and non_diegetic_music. Scene 2 explicitly treats the carried overlap as already elapsed before new action begins."
+      },
+      "inputs": {},
+      "label": "T2VA PROMPT FORMAT"
+    },
+    {
+      "key": "n10",
+      "type": "MiniMaxH3ChainLoopStart",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true
+      },
+      "inputs": {
+        "plan": [
+          "n33",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Start — LOOP START / RESUME"
+    },
+    {
+      "key": "n13",
+      "type": "MiniMaxH3ChainCurrent",
+      "settings": {
+        "align_audio_reference": false
+      },
+      "inputs": {
+        "state": [
+          "n10",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Current Shot — CURRENT T2V SCENE — PROMPT / SEED / TIMING"
+    },
+    {
+      "key": "n14",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "t2v_studio_recovered_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n34",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — RECOVERY: ASSEMBLE WITHOUT RENDERING",
+      "mode": 2
+    },
+    {
+      "key": "n16",
+      "type": "RandomNoise",
+      "settings": {
+        "noise_seed": 0,
+        "control_after_generate": "fixed"
+      },
+      "inputs": {
+        "noise_seed": [
+          "n13",
+          "noise_seed"
+        ]
+      },
+      "label": "RandomNoise — Per-shot noise seed"
+    },
+    {
+      "key": "n17",
+      "type": "MiniMaxH3ImageToVideo",
+      "settings": {
+        "prompt": "integrated_multimodal_description:\n[Shot 1] A grounded cinematic wide shot at a rain-darkened neighborhood tram stop just before dawn. One elderly watchmaker in a navy wool coat waits beneath the shelter, holding a small paper parcel with both hands. Sodium streetlights glow in wet pavement while an empty tram approaches from deep background. The camera makes a slow, steady push toward him. He hears the rails sing, looks up, and takes one deliberate step toward the curb. Keep exactly one person, natural body mechanics, restrained contrast, fine rain, and realistic lens breathing. End with the tram entering frame and his step still in progress.\n\noverall_soundscape:\nFine rain on glass, distant tires on wet road, a low electrical rail hum, the approaching tram bell, coat fabric, and one measured footstep. Preserve a quiet predawn acoustic space.\n\nnon_diegetic_music:\nNo non-diegetic music.",
+        "width": 544,
+        "height": 960,
+        "length": 243
+      },
+      "inputs": {
+        "clip": [
+          "n2",
+          "CLIP"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "prompt": [
+          "n13",
+          "prompt"
+        ],
+        "width": [
+          "n13",
+          "width"
+        ],
+        "height": [
+          "n13",
+          "height"
+        ],
+        "length": [
+          "n13",
+          "length"
+        ]
+      },
+      "label": "MiniMax H3 Image to Video — CORE T2VA — NO IMAGE INPUTS"
+    },
+    {
+      "key": "n18",
+      "type": "MiniMaxH3ChainContext",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n13",
+          "state"
+        ],
+        "conditioning": [
+          "n17",
+          "positive"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ],
+        "latent": [
+          "n17",
+          "LATENT"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Context — AUTO CONTEXT — clip 1 bypass / continuation"
+    },
+    {
+      "key": "n19",
+      "type": "MiniMaxH3SigmaShift",
+      "settings": {
+        "shift_video": 12,
+        "shift_audio": 3
+      },
+      "inputs": {
+        "model": [
+          "n30",
+          "MODEL"
+        ]
+      }
+    },
+    {
+      "key": "n22",
+      "type": "BasicGuider",
+      "settings": {},
+      "inputs": {
+        "model": [
+          "n19",
+          "MODEL"
+        ],
+        "conditioning": [
+          "n18",
+          "conditioning"
+        ]
+      },
+      "label": "Basic Guider — Loop guider"
+    },
+    {
+      "key": "n23",
+      "type": "BasicScheduler",
+      "settings": {
+        "scheduler": "simple",
+        "steps": 20,
+        "denoise": 1
+      },
+      "inputs": {
+        "model": [
+          "n19",
+          "MODEL"
+        ],
+        "steps": [
+          "n13",
+          "steps"
+        ]
+      },
+      "label": "BasicScheduler — Per-shot scheduler steps"
+    },
+    {
+      "key": "n24",
+      "type": "SamplerCustomAdvanced",
+      "settings": {},
+      "inputs": {
+        "noise": [
+          "n16",
+          "NOISE"
+        ],
+        "guider": [
+          "n22",
+          "GUIDER"
+        ],
+        "sampler": [
+          "n3",
+          "SAMPLER"
+        ],
+        "sigmas": [
+          "n23",
+          "SIGMAS"
+        ],
+        "latent_image": [
+          "n18",
+          "latent"
+        ]
+      },
+      "label": "SamplerCustomAdvanced — H3 sampler — SINGLE LOOP BODY"
+    },
+    {
+      "key": "n25",
+      "type": "VAEDecode",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n24",
+          "output"
+        ],
+        "vae": [
+          "n4",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode — Decode current clip frames"
+    },
+    {
+      "key": "n26",
+      "type": "VAEDecodeAudio",
+      "settings": {},
+      "inputs": {
+        "samples": [
+          "n24",
+          "output"
+        ],
+        "vae": [
+          "n5",
+          "VAE"
+        ]
+      },
+      "label": "VAE Decode Audio — Decode current clip audio"
+    },
+    {
+      "key": "n27",
+      "type": "MiniMaxH3LoopTrim",
+      "settings": {
+        "trim_frames": 0,
+        "fps": 24,
+        "match_tail": true,
+        "retain_overlap_frames": 5
+      },
+      "inputs": {
+        "images": [
+          "n25",
+          "IMAGE"
+        ],
+        "audio": [
+          "n26",
+          "AUDIO"
+        ],
+        "trim_frames": [
+          "n18",
+          "trim_frames"
+        ],
+        "state": [
+          "n13",
+          "state"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Trim — TRIM CONTEXT / AUTO-RESOLVE SCENE BLEND"
+    },
+    {
+      "key": "n28",
+      "type": "MiniMaxH3ChainSegmentSave",
+      "settings": {},
+      "inputs": {
+        "state": [
+          "n13",
+          "state"
+        ],
+        "images": [
+          "n27",
+          "images"
+        ],
+        "sampled_latent": [
+          "n24",
+          "output"
+        ],
+        "audio": [
+          "n27",
+          "audio"
+        ],
+        "images_with_overlap": [
+          "n27",
+          "images_with_overlap"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Segment + Checkpoint — SAVE DELIVERED + BLEND-READY SEGMENTS"
+    },
+    {
+      "key": "n29",
+      "type": "MiniMaxH3ChainAssemble",
+      "settings": {
+        "audio_source": "plan",
+        "filename": "t2v_studio_%date:yyyy-MM-dd%",
+        "audio_bitrate": 256,
+        "copy_to_output": false,
+        "output_subfolder": "",
+        "blend_schedule": "plan",
+        "boundary_tone_match": "off",
+        "color_stabilization": "off"
+      },
+      "inputs": {
+        "manifest": [
+          "n36",
+          "manifest"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Assemble — FINAL ASSEMBLY — 5-FRAME VISUAL BLEND"
+    },
+    {
+      "key": "n30",
+      "type": "ModelAttentionBackend",
+      "settings": {
+        "attention": "pytorch attention"
+      },
+      "inputs": {
+        "model": [
+          "n1",
+          "MODEL"
+        ]
+      },
+      "label": "ModelAttentionBackend — COMFY KITCHEN ATTENTION"
+    },
+    {
+      "key": "n31",
+      "type": "MiniMaxH3ChainRichScenePromptEditor",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n33",
+          "plan"
+        ]
+      }
+    },
+    {
+      "key": "n32",
+      "type": "MiniMaxH3ChainPlanModern",
+      "settings": {
+        "plan_json": "{\n  \"defaults\": {\n    \"steps\": 20\n  },\n  \"shots\": [\n    {\n      \"id\": \"tram_stop_arrival\",\n      \"prompt\": \"integrated_multimodal_description:\\n[Shot 1] A grounded cinematic wide shot at a rain-darkened neighborhood tram stop just before dawn. One elderly watchmaker in a navy wool coat waits beneath the shelter, holding a small paper parcel with both hands. Sodium streetlights glow in wet pavement while an empty tram approaches from deep background. The camera makes a slow, steady push toward him. He hears the rails sing, looks up, and takes one deliberate step toward the curb. Keep exactly one person, natural body mechanics, restrained contrast, fine rain, and realistic lens breathing. End with the tram entering frame and his step still in progress.\\n\\noverall_soundscape:\\nFine rain on glass, distant tires on wet road, a low electrical rail hum, the approaching tram bell, coat fabric, and one measured footstep. Preserve a quiet predawn acoustic space.\\n\\nnon_diegetic_music:\\nNo non-diegetic music.\",\n      \"length\": 243,\n      \"steps\": 20,\n      \"seed\": \"6101\"\n    },\n    {\n      \"id\": \"tram_boarding\",\n      \"prompt\": \"integrated_multimodal_description:\\n[Shot 1] Continue the same unbroken predawn tram-stop moment from the incoming H3 Motion Context. The carried opening overlap already contains the watchmaker's step and the tram entering frame; begin new action only after that overlap. Preserve his identity, navy coat, parcel, lighting direction, rain density, camera height, lens, and left-to-right tram motion. He completes the step, the doors align beside him and open, and warm interior light reaches across the wet pavement. He gives the parcel a protective glance and boards in one calm motion while the camera settles outside. No cut, no extra pedestrian, no reset of the carried movement.\\n\\noverall_soundscape:\\nContinue the same rain and rail hum through the boundary. Add braking metal, a soft pneumatic door release, one final pavement step, two hollow tram-floor steps, and subdued interior ventilation without restarting the ambience.\\n\\nnon_diegetic_music:\\nNo non-diegetic music.\",\n      \"length\": 243,\n      \"steps\": 20,\n      \"seed\": \"6102\"\n    }\n  ]\n}",
+        "run_name": "t2v_studio_minimax_h3_0_6_json",
+        "generation_fingerprint": "",
+        "width": 544,
+        "height": 960,
+        "encode_mode": "video",
+        "crop": "disabled",
+        "default_duration_seconds": 10.0,
+        "default_steps": 20,
+        "base_seed": 0,
+        "segment_crf": 20,
+        "video_blend_frames": 5
+      },
+      "inputs": {
+        "chain_policy": [
+          "n39",
+          "chain_policy"
+        ],
+        "project_assets": [
+          "n40",
+          "project_assets"
+        ]
+      },
+      "label": "MiniMax H3 Production Plan — 0.6 SCENE COLUMNS"
+    },
+    {
+      "key": "n33",
+      "type": "MiniMaxH3ChainPlanStudio",
+      "settings": {
+        "start_clip": 1,
+        "scene_range": "",
+        "verify_resume_history": true,
+        "plan_json": "{\n  \"shots\": [\n    {\n      \"id\": \"intro\",\n      \"prompt\": \"Describe the opening shot.\"\n    },\n    {\n      \"id\": \"continuation\",\n      \"prompt\": \"Continue the same take.\"\n    }\n  ]\n}",
+        "run_name": "h3_chain",
+        "generation_fingerprint": "",
+        "width": 960,
+        "height": 544,
+        "context_length": 22,
+        "encode_mode": "video",
+        "anchor_mode": "head",
+        "crop": "disabled",
+        "audio_mode": "generated_audio",
+        "audio_context_length": 22,
+        "default_duration_seconds": 15.0,
+        "default_steps": 20,
+        "base_seed": 0,
+        "segment_crf": 18,
+        "video_blend_frames": 0,
+        "continuation_mode": "guide",
+        "alternate_take_json": ""
+      },
+      "inputs": {
+        "plan": [
+          "n32",
+          "plan"
+        ],
+        "tagged_references": [
+          "n40",
+          "references"
+        ],
+        "project_assets": [
+          "n40",
+          "project_assets"
+        ]
+      },
+      "label": "MiniMax H3 Plan Studio — TIMELINE / TAKES / TRIMS"
+    },
+    {
+      "key": "n34",
+      "type": "MiniMaxH3ChainManifestLoad",
+      "settings": {},
+      "inputs": {
+        "plan": [
+          "n33",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Load Manifest — RECOVERY: LOAD ALL SAVED CLIPS",
+      "mode": 2
+    },
+    {
+      "key": "n35",
+      "type": "Note",
+      "settings": {
+        "text": "The two amber recovery nodes are MUTED by default.\n\nIf all segments finished but final assembly did not, mute the main green Assemble node, enable both recovery nodes, and queue. They validate every SHA-256 checkpoint pair and assemble without rerendering the completed clips.\n\nFor an interrupted generation, leave recovery muted and set Loop Start's start_clip to the first unfinished clip."
+      },
+      "inputs": {},
+      "label": "Note — RECOVERY / ASSEMBLE LATER"
+    },
+    {
+      "key": "n36",
+      "type": "MiniMaxH3ChainLoopEnd",
+      "settings": {
+        "between_scene_cleanup": "off"
+      },
+      "inputs": {
+        "flow": [
+          "n10",
+          "flow"
+        ],
+        "state": [
+          "n13",
+          "state"
+        ],
+        "images": [
+          "n27",
+          "images"
+        ],
+        "sampled_latent": [
+          "n24",
+          "output"
+        ],
+        "segment": [
+          "n37",
+          "segment"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop End — LOOP END — ADVANCE T2V SCENE"
+    },
+    {
+      "key": "n37",
+      "type": "MiniMaxH3ChainReview",
+      "settings": {
+        "enabled": true,
+        "play_notification_sound": false,
+        "auto_continue_timeout_minutes": 0,
+        "unload_models_while_waiting": false,
+        "assemble_partial_on_stop": true,
+        "partial_audio_source": "checkpointed",
+        "candidate_count": 1,
+        "review_each_candidate": false
+      },
+      "inputs": {
+        "state": [
+          "n13",
+          "state"
+        ],
+        "segment": [
+          "n28",
+          "segment"
+        ],
+        "audio": [
+          "n27",
+          "audio"
+        ]
+      },
+      "label": "MiniMax H3 Context Loop Review Gate — REVIEW GATE — APPROVE / EDIT+RETRY / REROLL / STOP"
+    },
+    {
+      "key": "n38",
+      "type": "Note",
+      "settings": {
+        "text": "0.6 Studio quick start\n\n1. Open the Project Asset Carousel.\n2. No reference asset is required; the Carousel can remain empty or hold later project media.\n3. Edit scenes in Production Plan or Plan Studio.\n4. Queue; inspect, branch, trim, or restore in Checkpoint Manager."
+      },
+      "inputs": {},
+      "label": "0.6 STUDIO QUICK START"
+    },
+    {
+      "key": "n39",
+      "type": "MiniMaxH3GenerationProfile",
+      "settings": {
+        "scene_continuity": "Visual continuity",
+        "audio_profile": "Generate audio"
+      },
+      "inputs": {},
+      "label": "MiniMax H3 Generation Profile — RELEASE DEFAULTS"
+    },
+    {
+      "key": "n40",
+      "type": "MiniMaxH3ProjectAssetManager",
+      "settings": {
+        "run_name": "t2v_studio_minimax_h3_0_6_json",
+        "catalog_json": "",
+        "semantic_anchor_size": "512",
+        "semantic_anchor_mode": "timestamped_video",
+        "operation_json": ""
+      },
+      "inputs": {},
+      "label": "MiniMax H3 Project Asset Carousel — IMPORT RELEASE REFERENCES"
+    },
+    {
+      "key": "n41",
+      "type": "MiniMaxH3ChainCheckpointManager",
+      "settings": {
+        "selection_json": ""
+      },
+      "inputs": {
+        "plan": [
+          "n33",
+          "plan"
+        ]
+      },
+      "label": "MiniMax H3 Checkpoint Manager — BRANCHES / PREVIEWS / RESTORE"
+    }
+  ]
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/tools/workflow_schema.py b/ComfyUI-MiniMaxH3-Context-Loop/tools/workflow_schema.py
new file mode 100644
index 0000000000000000000000000000000000000000..e304df53978fe6ac6f2122d3d1f7fa2f326f05da
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/tools/workflow_schema.py
@@ -0,0 +1,121 @@
+"""Offline release-workflow contracts. Local H3 definitions are authoritative.
+
+External contracts are a sanitized snapshot: no local model/media inventory.
+This imports schema methods only; it never loads weights or starts ComfyUI.
+Run as a standalone tooling process because ComfyUI imports are stubbed.
+"""
+from __future__ import annotations
+
+import copy
+import importlib
+import json
+import sys
+import types
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+DATA = ROOT / 'tools' / 'v06'
+PRIMITIVES = {'INT', 'FLOAT', 'STRING', 'BOOLEAN', 'COMBO'}
+
+
+def load_schemas():
+    package_name = '_h3_release_workflow_schema'
+    package = types.ModuleType(package_name)
+    package.__path__ = [str(ROOT)]
+    sys.modules[package_name] = package
+    folder_paths = types.ModuleType('folder_paths')
+    for name in ('get_output_directory', 'get_temp_directory', 'get_input_directory'):
+        setattr(folder_paths, name, lambda: str(ROOT))
+    folder_paths.get_annotated_filepath = lambda value: str(value)
+    sys.modules['folder_paths'] = folder_paths
+    for name in ('comfy', 'comfy.utils', 'comfy.ldm', 'comfy.ldm.minimax',
+                 'comfy.ldm.minimax.model', 'comfy.model_base', 'node_helpers'):
+        sys.modules.setdefault(name, types.ModuleType(name))
+        if '.' in name:
+            parent, child = name.rsplit('.', 1)
+            setattr(sys.modules[parent], child, sys.modules[name])
+    classes = {}
+    for module, mapping in (
+            ('nodes', 'NODE_CLASS_MAPPINGS'),
+            ('chain_nodes', 'CHAIN_NODE_CLASS_MAPPINGS'),
+            ('upscale_nodes', 'UPSCALE_NODE_CLASS_MAPPINGS'),
+            ('masking_nodes', 'NODE_CLASS_MAPPINGS'),
+            ('masked_bridge', 'NODE_CLASS_MAPPINGS'),
+            ('source_av_target', 'NODE_CLASS_MAPPINGS')):
+        imported = importlib.import_module(package_name + '.' + module)
+        classes.update(getattr(imported, mapping))
+    schemas = json.loads((DATA / 'external_schemas.json').read_text())['nodes']
+    for name, cls in classes.items():
+        inputs = cls.INPUT_TYPES()
+        schemas[name] = {
+            'input': inputs, 'output': list(cls.RETURN_TYPES),
+            'output_name': list(getattr(cls, 'RETURN_NAMES', cls.RETURN_TYPES)),
+            'output_is_list': list(getattr(cls, 'OUTPUT_IS_LIST', [False]*len(cls.RETURN_TYPES))),
+        }
+    # Match /object_info serialization, including wildcard str subclasses whose
+    # overloaded comparisons must not be used as schema-type comparisons.
+    return json.loads(json.dumps(schemas))
+
+
+def fields(schema):
+    return {**schema['input'].get('required', {}), **schema['input'].get('optional', {})}
+
+
+def options(spec):
+    return spec[1] if len(spec) > 1 else {}
+
+
+def is_widget(spec):
+    return (isinstance(spec[0], (list, tuple)) or spec[0] in PRIMITIVES
+            or spec[0] == 'COMFY_DYNAMICCOMBO_V3') and not options(spec).get('forceInput')
+
+
+def choices(spec):
+    if isinstance(spec[0], (list, tuple)):
+        return list(spec[0])
+    return options(spec).get('options') if spec[0] == 'COMBO' else None
+
+
+def default(spec):
+    opts = options(spec)
+    if 'default' in opts:
+        return copy.deepcopy(opts['default'])
+    values = choices(spec)
+    if values:
+        return values[0]
+    return {'STRING':'', 'BOOLEAN':False, 'INT':0, 'FLOAT':0.0}.get(spec[0], '')
+
+
+def widget_fields(schema, values):
+    """Include converted widgets, control-after-generate and V3 dynamic children."""
+    for name, spec in fields(schema).items():
+        if not is_widget(spec):
+            continue
+        if spec[0] == 'COMFY_DYNAMICCOMBO_V3':
+            variants = options(spec)['options']
+            yield name, [[v['key'] for v in variants], {}]
+            chosen = values.get(name, variants[0]['key'])
+            variant = next(v for v in variants if v['key'] == chosen)
+            for child, child_spec in widget_fields({'input':variant['inputs']}, values):
+                yield name + '.' + child, child_spec
+        else:
+            yield name, spec
+            if options(spec).get('control_after_generate') or name in ('seed', 'noise_seed'):
+                yield 'control_after_generate', [['fixed', 'increment', 'decrement', 'randomize'], {'default':'fixed'}]
+
+
+def validate_value(value, spec, label):
+    kind, opts = spec[0], options(spec)
+    values = choices(spec)
+    if values is not None:
+        assert value in values, (label, value, 'not in allowed choices', values)
+    elif kind == 'INT':
+        assert isinstance(value, int) and not isinstance(value, bool), (label, value, 'expected integer')
+    elif kind == 'FLOAT':
+        assert isinstance(value, (int, float)) and not isinstance(value, bool), (label, value, 'expected number')
+    elif kind == 'BOOLEAN':
+        assert isinstance(value, bool), (label, value, 'expected boolean')
+    elif kind == 'STRING':
+        assert isinstance(value, str), (label, value, 'expected string')
+    if kind in ('INT', 'FLOAT') and isinstance(value, (int, float)):
+        assert opts.get('min', float('-inf')) <= value <= opts.get('max', float('inf')), (label, value, 'out of range')
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/upscale_nodes.py b/ComfyUI-MiniMaxH3-Context-Loop/upscale_nodes.py
new file mode 100644
index 0000000000000000000000000000000000000000..cb64b261d5006dde7c9ae9217bd5131c1e67d0a6
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/upscale_nodes.py
@@ -0,0 +1,3192 @@
+"""Deferred, checkpoint-backed upscale loops for MiniMax H3 chains.
+
+The source generation remains immutable.  A completed active checkpoint branch
+is adapted into a second recursive graph whose body may contain any upscaler
+(native H3 latent refinement, LTX video-to-video, or a custom image pipeline).
+Each delivered HQ scene is persisted below the source run's ``upscaled``
+folder before the loop advances, and the shared chain assembler reuses the
+original audio contract without requiring the source video segments. A chain-aware
+MAINodes de-rope route may instead supply exact-recovered RAW-clock audio to
+the same scene save contract.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import uuid
+from datetime import datetime, timezone
+from typing import Any
+
+from . import chain_nodes as chain
+
+try:
+    from comfy.nested_tensor import NestedTensor as _ComfyNestedTensor
+except ImportError:
+    _ComfyNestedTensor = None
+
+
+UPSCALE_FLOW_TYPE = "H3_CHAIN_UPSCALE_FLOW"
+UPSCALE_STATE_TYPE = "H3_CHAIN_UPSCALE_STATE"
+UPSCALE_SEGMENT_TYPE = "H3_CHAIN_UPSCALE_SEGMENT"
+# Upscale and source runs deliberately share one public manifest wire.  The
+# document's ``format`` selects the assembly behavior at runtime, which lets
+# the normal H3 Chain Assemble node finish either kind of run.
+UPSCALE_MANIFEST_TYPE = chain.MANIFEST_TYPE
+
+
+class _AnyStateType(str):
+    """Expose a comma union while accepting either state server-side."""
+
+    def __ne__(self, other):  # pragma: no cover - Python protocol shim
+        return False
+
+    def __eq__(self, other):  # pragma: no cover - Python protocol shim
+        return True
+
+    def __hash__(self):  # pragma: no cover - retain string hashability
+        return str.__hash__(self)
+
+
+DEROPE_STATE_TYPE = _AnyStateType(
+    "H3_CHAIN_UPSCALE_STATE,H3_CHAIN_STATE")
+
+UPSCALE_BACKENDS = ("h3_latent", "ltx_2_5", "custom", "pixel")
+CONDITIONING_SYNC_METHODS = (
+    "nearest", "nearest-exact", "bilinear", "bicubic")
+MOTION_REFERENCE_MODES = (
+    "exclude_video_keep_audio", "keep_video_native", "resize_video")
+CONDITIONING_SYNC_MOTION_MODES = (
+    "conditioning_policy",) + MOTION_REFERENCE_MODES
+
+
+def _profile_dir(run_name: str, profile: str, source_manifest=None) -> str:
+    run = chain._safe_name(run_name, "h3_chain")
+    name = chain._safe_name(profile, "upscale")
+    parent = os.path.join(chain._output_root(), "h3_chains", run)
+    if isinstance(source_manifest, dict) and source_manifest.get("chapter"):
+        parent = chain._chapter_delivery_root({**source_manifest, "run_name": run})
+    path = os.path.abspath(os.path.join(parent, "upscaled", name))
+    root = os.path.abspath(chain._output_root())
+    if os.path.commonpath([root, path]) != root:
+        raise ValueError("H3 upscale profile path escapes the output directory.")
+    return path
+
+
+def _profile_paths(run_name: str, profile: str, index: int,
+                   source_manifest=None) -> dict[str, str]:
+    root = _profile_dir(run_name, profile, source_manifest)
+    stem = "clip_%04d" % int(index)
+    return {
+        "root": root,
+        "segment": os.path.join(root, "segments", stem + ".mp4"),
+        "checkpoint": os.path.join(root, "checkpoints", stem + ".safetensors"),
+        "metadata": os.path.join(root, "checkpoints", stem + ".json"),
+        "prompt": os.path.join(root, "prompts", stem + ".txt"),
+        "audio": os.path.join(root, "audio", stem + ".wav"),
+        "manifest": os.path.join(root, "upscale_manifest.json"),
+        "partial": os.path.join(
+            root, "partial", "through_clip_%04d.manifest.json" % int(index)),
+        "final": os.path.join(root, "final"),
+    }
+
+
+def _parse_recipe(value: str) -> dict[str, Any]:
+    text = str(value or "").strip()
+    if not text:
+        return {}
+    try:
+        parsed = json.loads(text)
+    except json.JSONDecodeError as exc:
+        raise ValueError("Upscale recipe_json must contain valid JSON.") from exc
+    if not isinstance(parsed, dict):
+        raise ValueError("Upscale recipe_json must contain a JSON object.")
+    return parsed
+
+
+def _profile_config(backend: str, recipe_json: str, save_latent: bool,
+                    segment_crf: int) -> dict[str, Any]:
+    if backend not in UPSCALE_BACKENDS:
+        raise ValueError("Unknown H3 upscale backend %r." % backend)
+    recipe = _parse_recipe(recipe_json)
+    value = {
+        "backend": backend,
+        "recipe": recipe,
+        "save_latent": bool(save_latent),
+        "segment_crf": int(segment_crf),
+    }
+    value["config_hash"] = chain._fingerprint(value)
+    return value
+
+
+def _verified_source_manifest(value: dict[str, Any]) -> dict[str, Any]:
+    manifest = chain._json_document(value)
+    if not isinstance(manifest, dict):
+        raise ValueError(
+            "Checkpoint Upscale Adapter requires a selected lineage manifest "
+            "from Checkpoint Manager.")
+    from .deferred_checkpoint_source import editorial_source_manifest
+    manifest = editorial_source_manifest(manifest, chain)
+    segments = chain._validate_manifest(manifest)
+    if not manifest.get("processing_source"):
+        chain.common_saved_resolution(segments, "Deferred upscale source")
+    else:
+        for segment in segments:
+            if segment.get("processing_source"):
+                _validate_processed_latent_header(segment)
+    if isinstance(manifest.get("prelude"), dict):
+        raise ValueError(
+            "Deferred upscale does not yet support an existing-video prelude. "
+            "Upscale the prelude separately or use a chain without prepend_original.")
+    return manifest
+
+
+def _source_hash(manifest: dict[str, Any]) -> str:
+    return chain._fingerprint(manifest)
+
+
+def _source_geometry(source, compatibility):
+    if source.get("processing_source"):
+        return {key: int(source[key]) for key in ("width", "height")}
+    return chain.saved_resolution(source) or compatibility
+
+
+def _source_bounds(manifest: dict[str, Any]) -> tuple[int, int]:
+    return chain._manifest_segment_bounds(
+        manifest, manifest.get("segments") or [], "Deferred upscale source")
+
+
+def _source_scene_count(manifest: dict[str, Any]) -> int:
+    # Reference schedules/cache slots use the original Plan's scene numbers,
+    # not a chapter-relative index. Existing full-run behavior stays unchanged.
+    if manifest.get("chapter"):
+        return max(_source_bounds(manifest)[1],
+                   int(manifest.get("source_scene_count") or
+                       manifest["chapter"].get("planned_end_scene") or 0))
+    return len(manifest["segments"])
+
+
+def _state_profile_paths(state: dict[str, Any], index: int) -> dict[str, str]:
+    return _profile_paths(state["run_name"], state["profile"], index,
+                          state["source_manifest"])
+
+
+def _public_upscale_segment(value: dict[str, Any]) -> dict[str, Any]:
+    private = {"_h3_upscale_decision"}
+    return {
+        key: item for key, item in value.items()
+        if not key.startswith("_") and key not in private
+    }
+
+
+def _source_segment(state: dict[str, Any], index: int | None = None
+                    ) -> dict[str, Any]:
+    slot = int(state["index"] if index is None else index)
+    segments = state["source_manifest"].get("segments") or []
+    first, last = _source_bounds(state["source_manifest"])
+    if slot < first or slot > last:
+        raise ValueError("Upscale scene must be between %d and %d." % (first, last))
+    source = segments[slot - first]
+    if int(source.get("index", -1)) != slot:
+        raise ValueError("Source manifest scene indexes are not contiguous.")
+    return source
+
+
+def _derope_state_view(state: Any
+                       ) -> tuple[dict[str, Any], int, int, dict[str, Any], str]:
+    """Normalize live-chain and deferred-upscale scene state."""
+    if not isinstance(state, dict):
+        raise ValueError(
+            "H3 De-Rope nodes require Current Shot state or Checkpoint "
+            "Upscale Loop state; got %s." % type(state).__name__)
+    source_manifest = state.get("source_manifest")
+    if isinstance(source_manifest, dict):
+        index = int(state.get("index", 0))
+        scene_count = _source_bounds(source_manifest)[1]
+        segment = _source_segment(state, index)
+        compatibility = source_manifest.get("compatibility") or {}
+        return segment, index, scene_count, compatibility, "upscale"
+    plan = state.get("plan")
+    if isinstance(plan, dict):
+        shots = plan.get("shots") or []
+        scene_count = len(shots)
+        index = int(state.get("index", 0))
+        if index < 1 or index > scene_count:
+            raise ValueError(
+                "H3 de-rope chain scene must be between 1 and %d." %
+                scene_count)
+        shot = shots[index - 1]
+        if not isinstance(shot, dict):
+            raise ValueError("H3 de-rope chain scene is not a Plan shot.")
+        compatibility = plan.get("compatibility") or {}
+        return shot, index, scene_count, compatibility, "chain"
+    raise ValueError(
+        "H3 De-Rope nodes did not recognize the connected state. Wire "
+        "Current Shot or Checkpoint Upscale Loop.")
+
+
+def _derope_continuation_mode(segment: dict[str, Any],
+                              compatibility: dict[str, Any]) -> str:
+    return str(chain.migrate_continuation_mode(
+        segment.get("continuation_mode") or
+        compatibility.get("continuation_mode") or "guide"))
+
+
+def _derope_prefix_steps_from_view(segment: dict[str, Any],
+                                   compatibility: dict[str, Any],
+                                   scene_number: int) -> int:
+    """Return the exact H3 latent prefix span for a Drift-Control scene."""
+    mode = _derope_continuation_mode(segment, compatibility)
+    if mode not in chain.DRIFT_CONTROL_CONTINUATION_MODES:
+        return 0
+    trim = int(segment.get("raw_frames", 0)) - int(
+        segment.get("delivered_frames", 0))
+    if trim <= 0:
+        return 0
+    expected_frames = int(chain.DRIFT_CONTROL_AV_RECIPE["context_frames"])
+    if trim != expected_frames:
+        raise ValueError(
+            "H3 de-rope Drift-Control scene %d has a %d-frame prefix; "
+            "recipe %s requires %d." % (
+                scene_number, trim,
+                chain.DRIFT_CONTROL_AV_RECIPE["version"], expected_frames))
+    return int(chain.DRIFT_CONTROL_AV_RECIPE["video_steps"])
+
+
+def _derope_future_visual_consumers(state: dict[str, Any],
+                                    scene: int) -> list[int]:
+    """Return later scenes whose saved visual prefix depends on ``scene``."""
+    segment, _index, scene_count, compatibility, kind = _derope_state_view(
+        state)
+    del segment
+    consumers = []
+    if kind == "chain":
+        plan = state["plan"]
+        default_context = int(compatibility.get("context_length", 0))
+        for target in range(int(scene) + 1, scene_count + 1):
+            shot = plan["shots"][target - 1]
+            if chain._shot_context_length(shot, default_context) <= 0:
+                continue
+            if "visual_context_blocks" in shot:
+                sources = {int(block["source"]) for block in
+                           chain._shot_visual_context_blocks(
+                               plan, target,
+                               chain._shot_context_length(
+                                   shot, default_context))}
+            else:
+                sources = {
+                    chain._shot_visual_context_source(plan, target),
+                    chain._shot_visual_context_lead_source(plan, target),
+                }
+            if int(scene) in sources:
+                consumers.append(target)
+        return consumers
+    for target in range(int(scene) + 1, scene_count + 1):
+        candidate = _source_segment(state, target)
+        if not isinstance(candidate, dict):
+            continue
+        trim = int(candidate.get("raw_frames", 0)) - int(
+            candidate.get("delivered_frames", 0))
+        if trim <= 0:
+            continue
+        visual_blocks = candidate.get("visual_context_blocks")
+        explicit = ({block.get("source_scene") for block in visual_blocks
+                     if isinstance(block, dict)}
+                    if isinstance(visual_blocks, list) else {
+                        candidate.get("visual_context_source_scene"),
+                        candidate.get("visual_context_lead_source_scene"),
+                    })
+        sources = set()
+        for value in explicit:
+            try:
+                if value is not None:
+                    sources.add(int(value))
+            except (TypeError, ValueError):
+                continue
+        if not sources:
+            sources.add(target - 1)
+        if int(scene) in sources:
+            consumers.append(target)
+    return consumers
+
+
+def _derope_visual_state(state: dict[str, Any], kind: str,
+                         scene: int, compatibility: dict[str, Any]
+                         ) -> dict[str, Any]:
+    """Resolve the same visual source that Chain Context conditioned on."""
+    if kind != "chain" or int(scene) <= 1:
+        return state
+    shot = state["plan"]["shots"][int(scene) - 1]
+    context_length = chain._shot_context_length(
+        shot, int(compatibility.get("context_length", 0)))
+    if context_length <= 0:
+        return state
+    return chain._visual_context_state(state)
+
+
+def _derope_hold_map(value: Any, expected_frames: int,
+                     label: str) -> tuple[dict[str, Any], list[int]]:
+    """Parse one MAINodes hold map without importing the optional pack."""
+    try:
+        parsed = json.loads(str(value or ""))
+    except json.JSONDecodeError as exc:
+        raise ValueError("%s must contain valid JSON." % label) from exc
+    if not isinstance(parsed, dict) or not isinstance(parsed.get("holds"), list):
+        raise ValueError("%s must contain a JSON object with a holds list." % label)
+    holds = []
+    for index, item in enumerate(parsed["holds"]):
+        if isinstance(item, bool):
+            raise ValueError("%s hold %d is not a positive integer." % (
+                label, index))
+        try:
+            hold = int(item)
+        except (TypeError, ValueError, OverflowError) as exc:
+            raise ValueError("%s hold %d is not a positive integer." % (
+                label, index)) from exc
+        if hold < 1 or float(item) != float(hold):
+            raise ValueError("%s hold %d is not a positive integer." % (
+                label, index))
+        holds.append(hold)
+    expected = int(expected_frames)
+    if len(holds) != expected:
+        raise ValueError(
+            "%s covers %d world frames; source scene requires %d RAW "
+            "frames." % (label, len(holds), expected))
+    if "world_len" in parsed and int(parsed["world_len"]) != expected:
+        raise ValueError(
+            "%s says world_len=%s; source scene requires %d RAW frames." %
+            (label, parsed["world_len"], expected))
+    return dict(parsed), holds
+
+
+def _source_continuation_mode(state: dict[str, Any],
+                              index: int | None = None) -> str:
+    source = _source_segment(state, index)
+    compatibility = state["source_manifest"].get("compatibility") or {}
+    return str(source.get("continuation_mode") or
+               compatibility.get("continuation_mode") or "guide")
+
+
+def _drift_prefix_steps(state: dict[str, Any],
+                        index: int | None = None) -> int:
+    """Return the exact H3 latent prefix span for a Drift-Control scene."""
+    source = _source_segment(state, index)
+    mode = _source_continuation_mode(state, index)
+    if mode not in chain.DRIFT_CONTROL_CONTINUATION_MODES:
+        return 0
+    trim = int(source.get("raw_frames", 0)) - int(
+        source.get("delivered_frames", 0))
+    if trim <= 0:
+        return 0
+    expected_frames = int(chain.DRIFT_CONTROL_AV_RECIPE["context_frames"])
+    if trim != expected_frames:
+        raise ValueError(
+            "H3 upscale Drift-Control scene %d has a %d-frame prefix; "
+            "recipe %s requires %d." % (
+                int(source.get("index", index or 0)), trim,
+                chain.DRIFT_CONTROL_AV_RECIPE["version"], expected_frames))
+    return int(chain.DRIFT_CONTROL_AV_RECIPE["video_steps"])
+
+
+def _video_stream_from_latent(latent: Any, label: str) -> Any:
+    if not isinstance(latent, dict) or "samples" not in latent:
+        raise ValueError("%s must be a LATENT with samples." % label)
+    samples = latent["samples"]
+    streams = ([samples]
+               if chain.torch is not None and chain.torch.is_tensor(samples)
+               else chain._streams_from_latent(latent))
+    for stream in streams:
+        if (getattr(stream, "ndim", 0) == 5
+                and int(stream.shape[1]) == 24):
+            return stream
+    raise ValueError("%s has no [B,24,T,H,W] H3 video stream." % label)
+
+
+def _drift_continuation_video(video: Any, state: Any
+                              ) -> tuple[Any, int, str]:
+    """Splice the prior HQ tail into a Drift-Control pass-2 prefix."""
+    if not isinstance(state, dict):
+        return video, 0, "open video"
+    prefix_steps = _drift_prefix_steps(state)
+    if prefix_steps <= 0:
+        return video, 0, "open video"
+    if int(video.shape[2]) <= prefix_steps:
+        raise ValueError(
+            "H3 upscale Drift-Control prefix uses %d/%d latent steps; no "
+            "future remains to refine." % (prefix_steps, int(video.shape[2])))
+    previous = state.get("previous_latent")
+    if previous is None:
+        return video, prefix_steps, (
+            "source prefix protected (prior HQ context unavailable)")
+    prior = _video_stream_from_latent(previous, "Previous upscaled latent")
+    if int(prior.shape[2]) < prefix_steps:
+        raise ValueError(
+            "Previous upscaled latent has %d video steps; Drift-Control needs "
+            "%d." % (int(prior.shape[2]), prefix_steps))
+    if (int(prior.shape[0]) != int(video.shape[0]) or
+            tuple(prior.shape[-2:]) != tuple(video.shape[-2:])):
+        raise ValueError(
+            "Previous/current HQ video geometry differs: %s vs %s." % (
+                tuple(prior.shape), tuple(video.shape)))
+    output = video.clone()
+    output[:, :, :prefix_steps] = prior[:, :, -prefix_steps:].to(
+        device=video.device, dtype=video.dtype)
+    return output, prefix_steps, "previous HQ latent tail spliced and protected"
+
+
+def _derope_drift_continuation_video(video: Any, state: Any
+                                     ) -> tuple[Any, int, str]:
+    """Splice the resolved prior visual tail for either loop state."""
+    segment, index, _count, compatibility, kind = _derope_state_view(state)
+    prefix_steps = _derope_prefix_steps_from_view(
+        segment, compatibility, index)
+    if prefix_steps <= 0:
+        return video, 0, "open video"
+    if int(video.shape[2]) <= prefix_steps:
+        raise ValueError(
+            "H3 de-rope Drift-Control prefix uses %d/%d latent steps; no "
+            "future remains to refine." % (
+                prefix_steps, int(video.shape[2])))
+    visual_state = _derope_visual_state(
+        state, kind, index, compatibility)
+    previous = visual_state.get("previous_latent")
+    if previous is None:
+        return video, prefix_steps, (
+            "source prefix protected (prior HQ context unavailable)")
+    prior = _video_stream_from_latent(previous, "Resolved prior HQ latent")
+    if int(prior.shape[2]) < prefix_steps:
+        raise ValueError(
+            "Resolved prior HQ latent has %d video steps; Drift-Control "
+            "needs %d." % (int(prior.shape[2]), prefix_steps))
+    if (int(prior.shape[0]) != int(video.shape[0]) or
+            tuple(prior.shape[-2:]) != tuple(video.shape[-2:])):
+        raise ValueError(
+            "Prior/current HQ video geometry differs: %s vs %s." % (
+                tuple(prior.shape), tuple(video.shape)))
+    output = video.clone()
+    output[:, :, :prefix_steps] = prior[:, :, -prefix_steps:].to(
+        device=video.device, dtype=video.dtype)
+    route = ("resolved chain visual context spliced and protected"
+             if kind == "chain" else
+             "previous HQ latent tail spliced and protected")
+    return output, prefix_steps, route
+
+
+def _validate_recovered_audio_shape(shape, batch, raw):
+    if (len(shape) != 4 or list(shape[:3]) != [batch, 32, 2] or shape[3] < 1 or
+            abs(shape[3] - raw / float(chain.FPS) * 40) > 2):
+        # Audio VAE padding can leave a sub-frame tail at its 40 Hz clock.
+        raise ValueError("Recovered DeRoPE audio latent must be [B,32,2,T] on the original RAW clock.")
+
+
+def _validate_processed_latent_header(source):
+    """Validate full recovered RAW latents without allocating their tensors."""
+    from safetensors import safe_open
+    raw = chain._validate_h3_length(source["raw_frames"], "DeRoPE RAW length")
+    expected = [24, (raw - 5) // 17 * 5 + 2,
+                int(source["height"]) // 16, int(source["width"]) // 16]
+    if any(int(source[key]) < 16 or int(source[key]) % 16 for key in ("width", "height")):
+        raise ValueError("DeRoPE source canvas must be aligned to the H3 VAE.")
+    with safe_open(chain._absolute_output_path(source["checkpoint"]),
+                   framework="pt", device="cpu") as saved:
+        keys = set(saved.keys())
+        layout = source.get("latent_layout")
+        video_key = "upscaled_video" if layout == "joint_av" else "upscaled_samples"
+        if (source.get("latent_saved") is not True or layout not in ("joint_av", "single") or
+                video_key not in keys):
+            raise ValueError("DeRoPE scene %s has no supported full recovered latent." % source["index"])
+        shape = saved.get_slice(video_key).get_shape()
+        if layout == "single" and shape == expected:
+            # Older single-stream saves accidentally unbound the batch axis.
+            # A four-dimensional single stream unambiguously represents B=1.
+            shape = [1, *shape]
+        if len(shape) != 5 or shape[0] < 1 or shape[1:] != expected:
+            raise ValueError(
+                "DeRoPE scene %s latent is %s, expected [B,%s] on its original RAW clock. "
+                "Save VAE Encode after Exact Recover, not the stretched pass-2 latent." %
+                (source["index"], shape, ",".join(map(str, expected))))
+        if layout == "joint_av":
+            audio = saved.get_slice("upscaled_audio").get_shape() if "upscaled_audio" in keys else []
+            _validate_recovered_audio_shape(audio, shape[0], raw)
+        elif source.get("audio_route") == "recovered de-rope audio":
+            raise ValueError(
+                "DeRoPE scene %s changed audio but saved video only. Connect recovered "
+                "audio_latent to Recovered AV and save again; original audio is not a substitute."
+                % source["index"])
+
+
+def _load_source_tensors(source: dict[str, Any],
+                         keys: tuple[str, ...] | None = None) -> dict[str, Any]:
+    presentation = source.get("presentation_source")
+    if presentation and not source.get("processing_source"):
+        # Only the ALT's visual stream is used. Read base audio selectively so
+        # a second complete AV checkpoint never coexists just to preserve sound.
+        visual_keys = ("video", "denoised_video")
+        audio_keys = ("audio", "denoised_audio", "delivered_audio")
+        wanted = keys if keys is not None else visual_keys + audio_keys
+        picture = {key: value for key, value in source.items() if key != "presentation_source"}
+        result = _load_source_tensors(picture, tuple(key for key in wanted if key in visual_keys)) \
+            if any(key in visual_keys for key in wanted) else {}
+        if any(key in audio_keys for key in wanted):
+            requested_audio = [key for key in audio_keys if key in wanted]
+            if "audio" in wanted or "denoised_audio" in wanted:
+                requested_audio = list(dict.fromkeys([*requested_audio, "audio", "denoised_audio"]))
+            base = _load_source_tensors(presentation["original"], tuple(requested_audio))
+            clean_audio = base.get("denoised_audio", base.get("audio"))
+            for key in wanted:
+                if key in ("audio", "denoised_audio") and clean_audio is not None:
+                    result[key] = clean_audio
+                elif key == "delivered_audio" and key in base:
+                    result[key] = base[key]
+        return result
+    if chain._st_load is None:
+        raise RuntimeError("safetensors is required for deferred H3 upscaling.")
+    checkpoint = chain._absolute_output_path(source["checkpoint"])
+    expected = str(source.get("checkpoint_sha256") or "")
+    if not os.path.isfile(checkpoint):
+        raise FileNotFoundError("Source H3 checkpoint is missing: %s" % checkpoint)
+    if not expected or chain._file_sha256(checkpoint) != expected:
+        raise ValueError("Source H3 checkpoint failed its SHA-256 integrity check.")
+    processed = source.get("processing_source")
+    if keys is None and not processed:
+        return chain._st_load(checkpoint)
+    from safetensors import safe_open
+    with safe_open(checkpoint, framework="pt", device="cpu") as saved:
+        available = set(saved.keys())
+        if not processed:
+            return {key: saved.get_tensor(key) for key in keys if key in available}
+        mapping = {"video": "upscaled_video" if source["latent_layout"] == "joint_av"
+                   else "upscaled_samples", "audio": "upscaled_audio",
+                   "delivered_audio": "delivered_audio"}
+        wanted = keys if keys is not None else tuple(mapping)
+        result = {key: saved.get_tensor(mapping[key]) for key in wanted
+                  if key in mapping and mapping[key] in available}
+    if source["latent_layout"] == "single" and "video" in result and result["video"].ndim == 4:
+        result["video"] = result["video"].unsqueeze(0)
+    if "audio" in wanted and "audio" not in result:
+        # Video-only recovery preserves the exact original take's audio. Read
+        # only audio tensors, never load a second full video just to join AV.
+        original_audio = _load_source_tensors(processed["original"], ("denoised_audio", "audio"))
+        audio = original_audio.get("denoised_audio", original_audio.get("audio"))
+        if audio is None:
+            raise ValueError("Original DeRoPE source has no reusable audio latent.")
+        result["audio"] = audio
+    return result
+
+
+def _source_latent(tensors: dict[str, Any]) -> tuple[dict[str, Any], str]:
+    if "denoised_video" in tensors:
+        video_key = "denoised_video"
+        audio_key = "denoised_audio" if "denoised_audio" in tensors else "audio"
+        route = "saved denoised x0"
+    else:
+        video_key = "video"
+        audio_key = "audio"
+        route = "terminal sampler output"
+    missing = [key for key in (video_key, audio_key) if key not in tensors]
+    if missing:
+        raise ValueError("Source H3 checkpoint is missing tensors: %s" % missing)
+    return ({"samples": _packed_samples(
+        [tensors[video_key], tensors[audio_key]])}, route)
+
+
+def _packed_samples(streams: list[Any]) -> Any:
+    if len(streams) == 1:
+        return streams[0]
+    if _ComfyNestedTensor is not None:
+        return _ComfyNestedTensor(streams)
+    return streams
+
+
+def _single_latent_tensor(latent: Any, label: str) -> Any:
+    if not isinstance(latent, dict) or "samples" not in latent:
+        raise ValueError("%s must be a LATENT with samples." % label)
+    samples = latent["samples"]
+    if chain.torch is not None and chain.torch.is_tensor(samples):
+        return samples
+    streams = chain._streams_from_latent(latent)
+    if len(streams) != 1:
+        raise ValueError("%s must contain exactly one latent stream." % label)
+    return streams[0]
+
+
+def _target_video_geometry(latent: Any) -> tuple[Any, int, int]:
+    video = _single_latent_tensor(latent, "Pass-2 video latent")
+    if getattr(video, "ndim", 0) != 5 or int(video.shape[1]) != 24:
+        raise ValueError(
+            "Pass-2 video latent must be [B,24,T,H,W], got %s." %
+            (tuple(getattr(video, "shape", ())),))
+    return video, int(video.shape[-1]) * 16, int(video.shape[-2]) * 16
+
+
+def _sync_visual_latent(value: Any, scale_x: float, scale_y: float,
+                        method: str) -> Any:
+    """Resize one H3 visual conditioning latent without changing time."""
+    if chain.torch is None or not chain.torch.is_tensor(value):
+        raise TypeError(
+            "H3 visual conditioning must contain PyTorch tensors, got %r." %
+            type(value))
+    if value.ndim not in (4, 5):
+        raise ValueError(
+            "H3 visual conditioning latent must be 4D or 5D, got %s." %
+            (tuple(value.shape),))
+    source_height, source_width = int(value.shape[-2]), int(value.shape[-1])
+    target_height = max(2, int(round(source_height * float(scale_y))))
+    target_width = max(2, int(round(source_width * float(scale_x))))
+    # H3 patchifies visual conditioning on a 2x2 latent grid without padding.
+    target_height = (target_height + 1) // 2 * 2
+    target_width = (target_width + 1) // 2 * 2
+    if (target_height, target_width) == (source_height, source_width):
+        return value
+
+    dtype = value.dtype
+    work = value
+    if value.device.type == "cpu" and dtype in (
+            chain.torch.float16, chain.torch.bfloat16):
+        work = value.float()
+    if value.ndim == 5:
+        batch, channels, frames = work.shape[:3]
+        work = work.permute(0, 2, 1, 3, 4).reshape(
+            batch * frames, channels, source_height, source_width)
+    options = {}
+    if method in ("bilinear", "bicubic"):
+        options["align_corners"] = False
+    resized = chain.torch.nn.functional.interpolate(
+        work, size=(target_height, target_width), mode=method, **options)
+    if value.ndim == 5:
+        resized = resized.reshape(
+            batch, frames, channels, target_height, target_width
+        ).permute(0, 2, 1, 3, 4).contiguous()
+    return resized.to(dtype=dtype)
+
+
+def _sync_h3_conditioning(conditioning: Any, scale_x: float,
+                          scale_y: float, method: str,
+                          motion_ref_mode: str) -> Any:
+    """Clone CONDITIONING and apply the pass-2 reference policy."""
+    if conditioning is None:
+        return None
+    output = []
+    for entry in conditioning:
+        if not isinstance(entry, (list, tuple)) or len(entry) < 2:
+            output.append(entry)
+            continue
+        embedding, metadata = entry[0], entry[1]
+        if not isinstance(metadata, dict):
+            output.append(entry)
+            continue
+        synced = metadata.copy()
+        effective_motion_mode = motion_ref_mode
+        if motion_ref_mode == "conditioning_policy":
+            effective_motion_mode = str(metadata.get(
+                "_h3_upscale_motion_ref_mode") or
+                "exclude_video_keep_audio")
+        picture_policy = str(metadata.get(
+            "_h3_upscale_ref_image_size") or "")
+        pictures_already_target_sized = bool(metadata.get(
+            "_h3_upscale_picture_refs_target_sized", False))
+        refs = metadata.get("minimax_refs")
+        if refs is not None:
+            _unused, policy_refs = chain._h3_motion_reference_policy(
+                [], refs, effective_motion_mode)
+            synced_refs = []
+            for block in policy_refs:
+                copied = dict(block)
+                kind = copied.get("kind")
+                if kind in ("video", "video_audio"):
+                    if effective_motion_mode == "keep_video_native":
+                        synced_refs.append(copied)
+                        continue
+                # Core H3's ``max`` picture policy is deliberately independent
+                # of the generation canvas: the same source picture must keep
+                # the same capped reference latent at 1 MP, 2 MP, and pass 2.
+                # Likewise, a ``match`` picture rebuilt from its cache-v2 RGB
+                # master at the target canvas must not be scaled a second time.
+                if kind == "image" and (
+                        picture_policy == "max" or
+                        pictures_already_target_sized):
+                    synced_refs.append(copied)
+                    continue
+                if kind != "audio" and copied.get("latent") is not None:
+                    latent = _sync_visual_latent(
+                        copied["latent"], scale_x, scale_y, method)
+                    copied["latent"] = latent
+                    copied["latent_h"] = int(latent.shape[-2])
+                    copied["latent_w"] = int(latent.shape[-1])
+                    if latent.ndim == 5 and "latent_t" in copied:
+                        copied["latent_t"] = int(latent.shape[2])
+                synced_refs.append(copied)
+            synced["minimax_refs"] = synced_refs
+        keyframes = metadata.get("minimax_keyframes")
+        if keyframes is not None:
+            synced_keyframes = []
+            for keyframe in keyframes:
+                copied = dict(keyframe)
+                if copied.get("latent") is not None:
+                    copied["latent"] = _sync_visual_latent(
+                        copied["latent"], scale_x, scale_y, method)
+                synced_keyframes.append(copied)
+            synced["minimax_keyframes"] = synced_keyframes
+        output.append([embedding, synced])
+    return output
+
+
+def _mark_h3_upscale_motion_policy(
+        conditioning: Any, mode: str, ref_image_size: str | None = None,
+        picture_refs_target_sized: bool = False) -> Any:
+    """Attach cache policies needed by the later conditioning-sync node."""
+    output = []
+    for entry in conditioning:
+        if (not isinstance(entry, (list, tuple)) or len(entry) < 2
+                or not isinstance(entry[1], dict)):
+            output.append(entry)
+            continue
+        metadata = entry[1].copy()
+        metadata["_h3_upscale_motion_ref_mode"] = str(mode)
+        if ref_image_size in ("match", "max"):
+            metadata["_h3_upscale_ref_image_size"] = str(ref_image_size)
+            metadata["_h3_upscale_picture_refs_target_sized"] = bool(
+                picture_refs_target_sized)
+        output.append([entry[0], metadata])
+    return output
+
+
+def _conditioning_from_tagged_upscale_override(
+        state: dict[str, Any], clip: Any, video_vae: Any, audio_vae: Any,
+        references: Any, prompt: str, ref_image_size: str,
+        motion_ref_mode: str, reference_policy: str,
+        target_video_latent: Any = None,
+        target_size: tuple[int, int] | None = None,
+        semantic_anchor_size: str = "512",
+        semantic_anchor_mode: str = "timestamped_video") -> tuple[Any, str, str]:
+    """Build one coherent live Ref2VA payload for a deferred upscale scene."""
+    source = _source_segment(state)
+    manifest = state["source_manifest"]
+    compatibility = manifest.get("compatibility") or {}
+    scene = int(state["index"])
+    scene_count = _source_scene_count(manifest)
+    length = int(source.get("raw_frames", 0))
+    geometry = _source_geometry(source, compatibility)
+    width = int(geometry.get("width", 0))
+    height = int(geometry.get("height", 0))
+    if target_video_latent is not None:
+        _video, width, height = _target_video_geometry(target_video_latent)
+    elif target_size is not None:
+        width, height = target_size
+
+    anchor_bundle = chain._reference_semantic_anchor_bundle(references)
+    if anchor_bundle is not None:
+        anchor_bundle = chain._make_semantic_anchor_bundle(
+            anchor_bundle["entries"], semantic_anchor_size, semantic_anchor_mode)
+    compiled, summary, bindings = chain._compile_tagged_reference_prompt(
+        references, scene, scene_count, prompt, reference_policy,
+        semantic_anchor_mode, anchor_bundle)
+    resolved_videos = []
+    slice_details = []
+    for entry in bindings["videos"]:
+        video, paired_audio, detail = chain._scheduled_video_reference_slice(
+            entry, None, scene, scene_count, length)
+        resolved_videos.append({"video": video, "audio": paired_audio})
+        if detail:
+            slice_details.append(detail)
+    resolved_audios = []
+    for entry in bindings["audios"]:
+        audio, detail = chain._tagged_audio_reference_value(
+            entry, None, scene, scene_count, length)
+        resolved_audios.append(audio)
+        if detail:
+            slice_details.append(detail)
+
+    pictures = [entry["value"] for entry in bindings["pictures"]]
+    has_visual_refs = bool(pictures or resolved_videos)
+    has_audio_refs = bool(
+        resolved_audios or any(
+            item.get("audio") is not None for item in resolved_videos))
+    if has_visual_refs and not callable(getattr(video_vae, "encode", None)):
+        raise ValueError(
+            "Connected upscale Tagged Picture/Video refs require the "
+            "original MiniMax H3 video VAE on video_vae.")
+    if has_audio_refs and not callable(getattr(audio_vae, "encode", None)):
+        raise ValueError(
+            "Connected upscale Tagged Audio or paired-video audio refs "
+            "require the MiniMax H3 audio VAE on audio_vae.")
+
+    semantic_anchors = bindings.get("semantic_anchors") or []
+    semantic_presentation = None
+    if semantic_anchors:
+        semantic_presentation = {
+            "version": chain.SEMANTIC_PRESENTATION_VERSION,
+            "width": width,
+            "height": height,
+            "length": length,
+            "ref_image_size": ref_image_size,
+            "semantic_anchor_size": semantic_anchor_size,
+            "semantic_anchor_mode": semantic_anchor_mode,
+            "pictures": pictures,
+            "videos": [{
+                "video": item["video"],
+                "paired_audio": item.get("audio") is not None,
+            } for item in resolved_videos],
+            "standalone_audio_count": len(resolved_audios),
+            "anchors": [{
+                "tag": anchor["tag"],
+                "image": anchor["entry"]["value"],
+                "timestamps": tuple(anchor["timestamps"]),
+                "untimed": bool(anchor.get("untimed")),
+            } for anchor in semantic_anchors],
+        }
+
+    presentation, blocks, _source_images = (
+        chain._h3_reference_cache_payload(
+            video_vae, audio_vae, pictures, resolved_videos,
+            resolved_audios, width, height, length, ref_image_size,
+            semantic_presentation))
+    presentation, blocks = chain._h3_motion_reference_policy(
+        presentation, blocks, motion_ref_mode)
+    clip_items = []
+    for item in presentation:
+        public = {"type": item["type"]}
+        if "timestamps" in item:
+            public["timestamps"] = item["timestamps"]
+        if "data" in item:
+            public["data"] = item["data"]
+        clip_items.append(public)
+    tokens = clip.tokenize(compiled, minimax_ref_items=clip_items)
+    conditioning = clip.encode_from_tokens_scheduled(tokens)
+    if blocks:
+        try:
+            import node_helpers
+        except ImportError as exc:
+            raise RuntimeError(
+                "Live upscale reference conditioning requires ComfyUI "
+                "node_helpers.") from exc
+        conditioning = node_helpers.conditioning_set_values(
+            conditioning, {"minimax_refs": blocks})
+    conditioning = _mark_h3_upscale_motion_policy(
+        conditioning, motion_ref_mode, ref_image_size,
+        picture_refs_target_sized=bool(
+            (target_video_latent is not None or target_size is not None)
+            and ref_image_size == "match"))
+    if slice_details:
+        summary += "; " + "; ".join(slice_details)
+    status = (
+        "%s; connected Tagged refs replace cached refs; canvas=%dx%d; "
+        "picture policy=%s; motion refs=%s" % (
+            summary, width, height, ref_image_size, motion_ref_mode))
+    if semantic_anchors:
+        status += "; semantic_anchor_size=%s; semantic_anchor_mode=%s" % (
+            semantic_anchor_size, semantic_anchor_mode)
+    return conditioning, compiled, status
+
+
+def _sample_members(samples: Any) -> tuple[list[Any], bool]:
+    if chain.torch is not None and chain.torch.is_tensor(samples):
+        return [samples], False
+    if hasattr(samples, "unbind"):
+        members = list(samples.unbind())
+        if members:
+            return members, True
+    if isinstance(samples, (list, tuple)):
+        return list(samples), len(samples) > 1
+    raise TypeError("Unsupported MiniMax H3 latent container %r." % type(samples))
+
+
+def _cpu_latent(latent: dict[str, Any] | None) -> dict[str, Any] | None:
+    if latent is None:
+        return None
+    samples = latent.get("samples") if isinstance(latent, dict) else None
+    if samples is None:
+        raise ValueError("Upscale latent has no samples value.")
+    streams = ([samples] if chain.torch.is_tensor(samples)
+               else chain._streams_from_latent(latent))
+    copied = [chain._tensor_cpu_clone(item) for item in streams]
+    return {"samples": _packed_samples(copied)}
+
+
+def _latent_checkpoint_tensors(latent: dict[str, Any]) -> tuple[dict[str, Any], str]:
+    samples = latent.get("samples") if isinstance(latent, dict) else None
+    streams = ([samples] if chain.torch.is_tensor(samples)
+               else chain._streams_from_latent(latent))
+    if not streams:
+        raise ValueError("Upscale latent contains no tensor streams.")
+    if len(streams) == 2:
+        return ({
+            "upscaled_video": chain._tensor_cpu_clone(streams[0]),
+            "upscaled_audio": chain._tensor_cpu_clone(streams[1]),
+        }, "joint_av")
+    if len(streams) == 1:
+        return ({"upscaled_samples": chain._tensor_cpu_clone(streams[0])},
+                "single")
+    return ({"upscaled_stream_%d" % index: chain._tensor_cpu_clone(value)
+             for index, value in enumerate(streams)}, "multi")
+
+
+def _next_drift_context_steps(state: dict[str, Any], index: int) -> int:
+    # Pixel refinement keeps the RAW image clock but does not splice latent
+    # prefixes. Do not demand an unused HQ latent just because the parent used
+    # Drift-Control. All pre-existing backends retain their safety contract.
+    if state.get("profile_config", {}).get("backend") == "pixel":
+        return 0
+    total = _source_bounds(state["source_manifest"])[1]
+    if int(index) >= total:
+        return 0
+    return _drift_prefix_steps(state, int(index) + 1)
+
+
+def _upscaled_context_tensor(latent: Any, steps: int) -> Any:
+    video = _video_stream_from_latent(latent, "Final upscaled latent")
+    count = int(steps)
+    if count < 1 or int(video.shape[2]) < count:
+        raise ValueError(
+            "Final upscaled video has %d steps; cannot retain %d-step "
+            "continuation context." % (int(video.shape[2]), count))
+    return chain._tensor_cpu_clone(video[:, :, -count:])
+
+
+def _load_previous_upscaled_context(
+        state: dict[str, Any], start_clip: int) -> tuple[dict[str, Any] | None,
+                                                        str]:
+    """Restore the prior HQ video tail for a resumed Drift-Control scene."""
+    if state.get("profile_config", {}).get("backend") == "pixel":
+        return None, "pixel refinement; no HQ latent continuity required"
+    steps = _drift_prefix_steps(state, int(start_clip))
+    if steps <= 0 or int(start_clip) <= _source_bounds(state["source_manifest"])[0]:
+        return None, "no resumed Drift-Control context required"
+    segments = state.get("segments") or []
+    if not segments:
+        return None, "prior HQ context unavailable"
+    prior_segment = segments[-1]
+    checkpoint = chain._absolute_output_path(prior_segment["checkpoint"])
+    tensors = chain._st_load(checkpoint)
+    video = tensors.get("upscaled_video_context")
+    route = "compact saved HQ context"
+    if video is None:
+        video = tensors.get("upscaled_video")
+        route = "saved full HQ video latent fallback"
+    if video is None:
+        candidate = tensors.get("upscaled_samples")
+        if (getattr(candidate, "ndim", 0) == 5
+                and int(candidate.shape[1]) == 24):
+            video = candidate
+            route = "saved single HQ video latent fallback"
+    if video is None:
+        return None, (
+            "prior checkpoint predates compact HQ context; source prefix "
+            "will be protected")
+    if int(video.shape[2]) < steps:
+        raise ValueError(
+            "Upscale scene %d checkpoint contains %d context steps; scene %d "
+            "requires %d." % (int(start_clip) - 1, int(video.shape[2]),
+                               int(start_clip), steps))
+    context = chain._tensor_cpu_clone(video[:, :, -steps:])
+    return {"samples": context}, route
+
+
+def _upscale_source_contract(source: dict[str, Any]) -> str:
+    """Per-scene inputs; selection endpoints/editorial bookkeeping aren't inputs."""
+    return chain._fingerprint({key: source.get(key) for key in (
+        "index", "id", "revision", "checkpoint_sha256", "segment_sha256",
+        "raw_frames", "delivered_frames", "sample_rate", "prompt", "prompt_hash",
+        "seed", "steps", "width", "height", "resolution", "audio_mode",
+        "continuation_mode", "context_length", "audio_context_length",
+        "visual_context_blocks", "source_audio", "source_audio_timing",
+        "reference_cache", "generation_fingerprint",
+        *(["presentation_source"] if source.get("presentation_source") else []),
+        *(["processing_source"] if source.get("processing_source") else []),
+    )})
+
+
+def _verify_upscale_source(metadata: dict[str, Any], source: dict[str, Any],
+                           index: int) -> None:
+    segment = metadata["segment"]
+    for saved_key, source_key in (
+            ("source_revision", "revision"),
+            ("source_checkpoint_sha256", "checkpoint_sha256"),
+            ("source_segment_sha256", "segment_sha256")):
+        if not source.get(source_key) or segment.get(saved_key) != source[source_key]:
+            raise ValueError("Upscale scene %d points to a different source revision or media "
+                             "(including the selected ALT). Restart at that scene or use a new profile." % index)
+    # These fields were persisted before per-scene contracts existed, so old
+    # HQ saves can resume an extended branch without rewriting their metadata.
+    for key in ("raw_frames", "delivered_frames", "prompt", "prompt_hash", "seed", "steps"):
+        expected = str(source.get(key) or "") if key in ("prompt", "prompt_hash") else source.get(key)
+        if segment.get(key) != expected:
+            raise ValueError("Upscale scene %d used different source timing or settings (%s)." % (index, key))
+    saved_contract = metadata.get("source_scene_contract")
+    if saved_contract and saved_contract != _upscale_source_contract(source):
+        raise ValueError("Upscale scene %d used different source scene settings." % index)
+
+
+def _load_upscale_prefix(state: dict[str, Any], start_clip: int
+                         ) -> list[dict[str, Any]]:
+    values = []
+    for index in range(_source_bounds(state["source_manifest"])[0], int(start_clip)):
+        paths = _state_profile_paths(state, index)
+        if not os.path.isfile(paths["metadata"]):
+            raise FileNotFoundError(
+                "Cannot resume upscale scene %d: scene %d metadata is missing: %s"
+                % (start_clip, index, paths["metadata"]))
+        metadata = chain._read_json(paths["metadata"])
+        if metadata.get("format") != "h3_chain_upscale_segment_v1":
+            raise ValueError("Upscale scene %d metadata has an unknown format." % index)
+        if (metadata.get("run_name") != state["run_name"] or
+                metadata.get("profile") != state["profile"]):
+            raise ValueError("Upscale scene %d belongs to a different run or profile." % index)
+        if metadata.get("profile_config_hash") != state["profile_config"]["config_hash"]:
+            raise ValueError("Upscale scene %d used different profile settings." % index)
+        segment = metadata.get("segment")
+        if not isinstance(segment, dict):
+            raise ValueError("Upscale scene %d metadata has no segment." % index)
+        _verify_upscale_segment(segment, index)
+        source = _source_segment(state, index)
+        _verify_upscale_source(metadata, source, index)
+        values.append(_public_upscale_segment(segment))
+    return values
+
+
+def _verify_upscale_segment(segment: dict[str, Any], index: int) -> None:
+    if int(segment.get("index", -1)) != int(index):
+        raise ValueError("Upscale segment slot %d has the wrong scene index." % index)
+    for key, hash_key in (("segment", "segment_sha256"),
+                          ("checkpoint", "checkpoint_sha256")):
+        value = segment.get(key)
+        expected = str(segment.get(hash_key) or "")
+        if not isinstance(value, str) or not expected:
+            raise ValueError("Upscale scene %d has no verified %s." % (index, key))
+        path = chain._absolute_output_path(value)
+        if not os.path.isfile(path):
+            raise FileNotFoundError("Upscale scene %d %s is missing: %s" %
+                                    (index, key, path))
+        if chain._file_sha256(path) != expected:
+            raise ValueError("Upscale scene %d %s failed SHA-256 verification." %
+                             (index, key))
+    audio = segment.get("generated_audio")
+    if audio is not None:
+        expected = str(segment.get("generated_audio_sha256") or "")
+        path = chain._absolute_output_path(audio)
+        if not expected or not os.path.isfile(path) or chain._file_sha256(path) != expected:
+            raise ValueError("Upscale scene %d generated audio is invalid." % index)
+
+
+def _upscale_manifest(state: dict[str, Any], segments: list[dict[str, Any]],
+                      complete: bool) -> dict[str, Any]:
+    source = state["source_manifest"]
+    total = len(source["segments"])
+    first, _last = _source_bounds(source)
+    indexes = [int(item.get("index", -1)) for item in segments]
+    if len(segments) > total or indexes != list(range(first, first + len(segments))):
+        raise ValueError("Upscale manifest segments must be contiguous from scene %d." % first)
+    manifest = {
+        "format": ("h3_chain_upscale_manifest_v1" if complete else
+                   "h3_chain_upscale_partial_manifest_v1"),
+        "run_name": state["run_name"],
+        "profile": state["profile"],
+        "profile_config": state["profile_config"],
+        "source_manifest_hash": state["source_manifest_hash"],
+        "source_plan_hash": source.get("plan_hash"),
+        "source_manifest": source,
+        "clip_count": total,
+        "completed_clip_count": len(segments),
+        "total_delivered_frames": sum(
+            int(item.get("delivered_frames", 0)) for item in segments),
+        "duration_seconds": sum(
+            int(item.get("delivered_frames", 0)) for item in segments) /
+            float(chain.FPS),
+        "segments": [_public_upscale_segment(item) for item in segments],
+        "latent_saving": bool(state["profile_config"]["save_latent"]),
+    }
+    if complete and len(segments) != total:
+        raise ValueError("A complete upscale manifest requires %d scenes." % total)
+    if source.get("chapter"):
+        manifest["scene_start"] = first
+        manifest["scene_end"] = indexes[-1] if indexes else first - 1
+    if not complete:
+        manifest["planned_clip_count"] = total
+        manifest["last_completed_clip"] = indexes[-1] if indexes else first - 1
+    return manifest
+
+
+class MiniMaxH3ChainUpscaleAdapter:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "source_manifest": (chain.MANIFEST_TYPE, {
+                    "tooltip": "Verified lineage emitted by Checkpoint Manager. "
+                               "Selected final-cut ALTs supply picture and conditioning; "
+                               "original audio and generation ancestry are preserved. It may stop before "
+                               "later ungenerated Plan scenes; no source Plan "
+                               "is needed."}),
+                "profile": ("STRING", {
+                    "default": "h3_2x",
+                    "tooltip": "Child output folder under this run's upscaled directory."}),
+                "backend": (list(UPSCALE_BACKENDS), {
+                    "default": "h3_latent",
+                    "tooltip": "Backend label for this child recipe. pixel is "
+                               "an experimental IMAGE-only pass: it does not "
+                               "require or splice Drift-Control HQ latents. "
+                               "Other backends retain latent continuity checks."}),
+                "recipe_json": ("STRING", {
+                    "default": "{}", "multiline": True,
+                    "tooltip": "Advanced, provenance-only backend/model/sigma "
+                               "settings, hidden by default. The visible graph "
+                               "remains authoritative."}),
+                "start_clip": ("INT", {
+                    "default": 1, "min": 1, "max": chain.MAX_SHOTS,
+                    "tooltip": "Original scene number to resume. 1 starts at "
+                               "the first selected scene (also for chapter-only "
+                               "input). Later scenes verify and reuse this "
+                               "chapter/profile's saved HQ prefix."}),
+                "end_clip": ("INT", {
+                    "default": 0, "min": 0, "max": chain.MAX_SHOTS,
+                    "tooltip": "Last scene to upscale; 0 means the final source scene."}),
+                "save_latent": ("BOOLEAN", {
+                    "default": False,
+                    "tooltip": "Persist the HQ sampler latent in each child "
+                               "checkpoint. Off still saves assembly/audio and "
+                               "any compact Drift-Control context needed for "
+                               "standalone merge and resume."}),
+                "segment_crf": ("INT", {
+                    "default": 18, "min": 0, "max": 51,
+                    "tooltip": "H.264 quality for persisted HQ scene segments."}),
+            },
+            "hidden": {"initial_state": (UPSCALE_STATE_TYPE,)},
+        }
+
+    RETURN_TYPES = (UPSCALE_FLOW_TYPE, UPSCALE_STATE_TYPE,
+                    chain.MANIFEST_TYPE, "STRING")
+    RETURN_NAMES = ("flow", "state", "source_manifest", "status")
+    OUTPUT_TOOLTIPS = (
+        "Raw recursive-loop link; connect it directly to Upscale Loop End.",
+        "Current child-run state for Upscale Current Scene.",
+        "Verified manifest of the selected generated checkpoint lineage.",
+        "Selected profile, scene range, backend label, and latent-save policy.",
+    )
+    FUNCTION = "adapt"
+    CATEGORY = "conditioning/minimax/context_loop/upscale"
+    DESCRIPTION = ("Turn Checkpoint Manager's selected generated lineage into a "
+                   "resumable child upscale loop without a source Plan or "
+                   "changes to the source run.")
+
+    @classmethod
+    def IS_CHANGED(cls, *args, **kwargs):
+        return float("NaN")
+
+    def adapt(self, source_manifest, profile, backend, recipe_json,
+              start_clip, end_clip, save_latent, segment_crf,
+              initial_state=None):
+        if initial_state is None:
+            manifest = _verified_source_manifest(source_manifest)
+            if any(item.get("processing_source", {}).get("profile_path") ==
+                   chain._relative_output_path(_profile_dir(
+                       manifest["run_name"], chain._safe_name(profile, "upscale"), manifest))
+                   for item in manifest["segments"]):
+                raise ValueError("Choose a new output profile; do not overwrite the selected DeRoPE source profile.")
+            first, last = _source_bounds(manifest)
+            start = first if int(start_clip) == 1 else int(start_clip)
+            stop = last if int(end_clip) == 0 else int(end_clip)
+            if start < first or start > last:
+                raise ValueError(
+                    "start_clip must be 1 (first selected scene) or between %d and %d. "
+                    "Use original scene numbers, not chapter-relative positions. "
+                    "Checkpoint Manager supplied scenes %d–%d; choose the whole branch "
+                    "there if later scenes are missing." % (first, last, first, last))
+            if stop < start or stop > last:
+                raise ValueError("end_clip must be between start_clip and %d." % last)
+            state = {
+                "run_name": str(manifest["run_name"]),
+                "profile": chain._safe_name(profile, "upscale"),
+                "profile_config": _profile_config(
+                    backend, recipe_json, save_latent, segment_crf),
+                "source_manifest": manifest,
+                "source_manifest_hash": _source_hash(manifest),
+                "index": start,
+                "range_start": start,
+                "end_clip": stop,
+                "segments": [],
+                "previous_frames": None,
+                "previous_latent": None,
+            }
+            state["segments"] = _load_upscale_prefix(state, start)
+            previous_latent, context_status = _load_previous_upscaled_context(
+                state, start)
+            state["previous_latent"] = previous_latent
+            state["previous_context_status"] = context_status
+        else:
+            state = dict(initial_state)
+            manifest = state["source_manifest"]
+            if _source_hash(_verified_source_manifest(source_manifest)) != str(
+                    state["source_manifest_hash"]):
+                raise ValueError(
+                    "Selected checkpoint branch changed during upscale recursion.")
+        status = ("upscale %s scene %d/%d; range %d:%d; backend=%s; HQ latent %s" %
+                  (state["profile"], int(state["index"]),
+                   _source_bounds(state["source_manifest"])[1],
+                   int(state["range_start"]), int(state["end_clip"]),
+                   state["profile_config"]["backend"],
+                   "saved" if state["profile_config"]["save_latent"]
+                   else "not saved"))
+        context_status = str(state.get("previous_context_status") or "")
+        if context_status:
+            status += "; %s" % context_status
+        alternates = (manifest.get("presentation_source") or {}).get("scenes") or []
+        if alternates:
+            status += "; final-cut ALT pictures: " + ", ".join(
+                "%s/%s" % (item["scene"], item["alternate_revision"][:8]) for item in alternates)
+        return ("h3_upscale", state, manifest, status)
+
+
+class MiniMaxH3ChainUpscaleCurrent:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {"state": (UPSCALE_STATE_TYPE, {
+            "tooltip": "Current child-run state from Upscale Adapter."})}}
+
+    RETURN_TYPES = (UPSCALE_STATE_TYPE, "LATENT", "LATENT", "LATENT", "INT",
+                    "INT", "STRING", "INT", "INT", "INT", "INT", "INT",
+                    "INT", "AUDIO", "IMAGE", "LATENT", "STRING")
+    RETURN_NAMES = ("state", "source_latent", "source_video_latent",
+                    "source_audio_latent", "clip_index", "clip_count", "prompt",
+                    "width", "height", "seed", "trim_frames", "raw_frames",
+                    "delivered_frames", "source_audio",
+                    "previous_upscaled_frames", "previous_upscaled_latent",
+                    "status")
+    OUTPUT_TOOLTIPS = (
+        "Unchanged current child-run state for Segment Save and Loop End.",
+        "Verified joint H3 video/audio x0 for combined learned upscalers.",
+        "Verified 24-channel H3 video x0 for video-only upscalers.",
+        "Original H3 audio latent to preserve when recombining a refined video.",
+        "One-based source scene index.",
+        "Scene count for reference schedules: selected parent branch count, "
+        "or original Plan count for chapter-only input (not chapter length).",
+        "Exact saved prompt for this source scene.",
+        "Parent generation width used to rebuild H3 pass-2 conditioning.",
+        "Parent generation height used to rebuild H3 pass-2 conditioning.",
+        "Saved parent scene seed, suitable for deterministic pass-2 noise.",
+        "Repeated raw head frames that Segment Save removes after refinement.",
+        "Expected raw frame count before the repeated head is removed.",
+        "Expected delivered frame count after trimming.",
+        "Decoded delivered parent audio, when the checkpoint contains it.",
+        "Prior scene's delivered HQ context frames for backend continuity.",
+        "Prior scene's transient HQ latent, when Loop End received one.",
+        "Source scene, selected x0 route, and exact frame contract.",
+    )
+    FUNCTION = "current"
+    CATEGORY = "conditioning/minimax/context_loop/upscale"
+    DESCRIPTION = ("Verify and load one source scene checkpoint lazily for an "
+                   "H3, LTX, or custom upscale body.")
+
+    def current(self, state):
+        index = int(state["index"])
+        source = _source_segment(state)
+        tensors = _load_source_tensors(source)
+        latent, route = _source_latent(tensors)
+        if source.get("processing_source"):
+            route = "saved recovered DeRoPE %s; %s audio latent" % (
+                source["revision"][:8], "recovered" if source["latent_layout"] == "joint_av" else "original")
+        elif source.get("presentation_source"):
+            route += "; ALT %s picture; original %s audio" % (
+                source["revision"][:8], source["presentation_source"]["original"]["revision"][:8])
+        video_stream, audio_stream = chain._streams_from_latent(latent)
+        video_latent = {"samples": video_stream}
+        audio_latent = {"samples": audio_stream}
+        audio = None
+        if "delivered_audio" in tensors:
+            sample_rate = int(source.get("sample_rate", 0))
+            if sample_rate < 1:
+                raise ValueError("Source scene %d has audio but no sample rate." % index)
+            audio = {"waveform": tensors["delivered_audio"],
+                     "sample_rate": sample_rate}
+        raw = int(source["raw_frames"])
+        delivered = int(source["delivered_frames"])
+        trim = raw - delivered
+        compatibility = state["source_manifest"].get("compatibility") or {}
+        geometry = _source_geometry(source, compatibility)
+        width = int(geometry.get("width", 0))
+        height = int(geometry.get("height", 0))
+        if width < 1 or height < 1:
+            raise ValueError("Source H3 manifest has no valid canvas dimensions.")
+        seed = int(source.get("seed", 0))
+        status = ("upscale source scene %d/%d: %s; raw=%df delivered=%df trim=%df" %
+                  (index, _source_bounds(state["source_manifest"])[1], route,
+                   raw, delivered, trim))
+        return (state, latent, video_latent, audio_latent, index,
+                _source_scene_count(state["source_manifest"]),
+                str(source.get("prompt") or ""), width, height, seed, trim,
+                raw, delivered, audio, state.get("previous_frames"),
+                state.get("previous_latent"), status)
+
+
+class MiniMaxH3ChainUpscalePixelCurrent:
+    """Decode one verified RAW scene, without a joint-AV decode wire."""
+
+    EXPERIMENTAL = True
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {
+            "state": (UPSCALE_STATE_TYPE, {
+                "tooltip": "Upscale Adapter state with backend=pixel. Source "
+                           "checkpoints and scene clocks remain unchanged."}),
+            "video_vae": ("VAE", {
+                "tooltip": "MiniMax H3 video VAE to decode one saved clean "
+                           "video latent, including its repeated RAW prefix."}),
+        }}
+
+    RETURN_TYPES = (UPSCALE_STATE_TYPE, "IMAGE", "AUDIO", "STRING", "INT",
+                    "INT", "INT", "INT", "STRING")
+    RETURN_NAMES = ("state", "images", "source_audio", "prompt", "seed",
+                    "clip_index", "raw_frames", "trim_frames", "status")
+    OUTPUT_TOOLTIPS = (
+        "Verified current state for conditioning, Segment Save and Loop End.",
+        "One complete RAW scene. Upscale/refine these frames without changing "
+        "their count; Segment Save removes the repeated head exactly once.",
+        "Delivered saved scene audio, or None for a silent source. For preview "
+        "only: Segment Save preserves this audio automatically. Do not wire "
+        "it to recovered_audio (RAW) or Assemble source_audio (whole run).",
+        "Original saved scene prompt.", "Original saved scene seed.",
+        "One-based scene index.", "Expected RAW frame count.",
+        "Repeated head frame count removed by Segment Save.",
+        "Decode route and exact RAW/delivered clock.",
+    )
+    FUNCTION = "current"
+    CATEGORY = "conditioning/minimax/context_loop/upscale"
+    DESCRIPTION = (
+        "Experimental pixel-upscale scene reader. Decodes the saved clean "
+        "VIDEO stream and recovers the original delivered audio separately. "
+        "Use any IMAGE upscaler, then pixel conditioning and image refinement. "
+        "No full-chain video allocation or upscaled latent is needed.")
+
+    def current(self, state, video_vae):
+        if state.get("profile_config", {}).get("backend") != "pixel":
+            raise ValueError("Pixel Current Scene requires Upscale Adapter backend=pixel.")
+        current = MiniMaxH3ChainUpscaleCurrent().current(state)
+        images, _buffer, route = chain._decode_checkpoint_video_for_streaming(
+            video_vae, current[2]["samples"], "memory", "")
+        if tuple(images.shape) != (current[11], current[8], current[7], 3):
+            raise ValueError(
+                "Pixel Current Scene decoded %s; expected %d RAW RGB frames "
+                "at %dx%d. Use the matching H3 video VAE; do not trim here." %
+                (tuple(images.shape), current[11], current[7], current[8]))
+        status = "%s; pixel decode: %s; original audio preserved" % (current[-1], route)
+        chain._LOG.info("H3 %s", status)
+        return (state, images, current[13], current[6], current[9], current[4],
+                current[11], current[10], status)
+
+
+class MiniMaxH3ChainDeropeGuard:
+    """Make a MAINodes hold map safe at recursive H3 chain boundaries."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "state": (DEROPE_STATE_TYPE, {
+                    "tooltip": "Current Shot or Checkpoint Upscale Loop "
+                               "state. Its RAW/delivered contract identifies "
+                               "the disposable prefix and saved visual "
+                               "context consumers."}),
+                "hold_map": ("STRING", {
+                    "forceInput": True,
+                    "tooltip": "Adaptive world-frame hold map from MAINodes "
+                               "H3 Jerk Oracle, before H3 Time Smear."}),
+            },
+        }
+
+    RETURN_TYPES = ("STRING", "BOOLEAN", "INT", "INT", "STRING")
+    RETURN_NAMES = (
+        "hold_map", "expand_to_end", "protected_prefix",
+        "protected_suffix", "status")
+    OUTPUT_TOOLTIPS = (
+        "Hold map with the chain's disposable prefix and continuation-side "
+        "suffix forced to rate 1.",
+        "Connect to H3 Time Smear expand_to_end. It is enabled only for the "
+        "last scene in the selected branch.",
+        "Number of RAW prefix frames protected from temporal dilation.",
+        "Number of closing frames protected because another scene follows.",
+        "Verified scene-clock and boundary-protection summary.",
+    )
+    FUNCTION = "guard"
+    CATEGORY = "conditioning/minimax/context_loop/upscale"
+    DESCRIPTION = (
+        "Adapt a MAINodes de-rope hold map to a live or deferred H3 chain "
+        "scene. The repeated continuation prefix is never retimed; the last "
+        "17 frames are protected only when a later scene consumes this "
+        "scene as visual context. H3 Time Smear's end expansion is enabled "
+        "when no later visual-context consumer exists.")
+
+    def guard(self, state, hold_map):
+        segment, scene, scene_count, _compat, kind = _derope_state_view(state)
+        raw = int(segment.get("raw_frames", 0))
+        delivered = int(segment.get("delivered_frames", 0))
+        if raw < 1 or delivered < 1 or delivered > raw:
+            raise ValueError(
+                "H3 de-rope scene has invalid RAW/delivered frames %d/%d." %
+                (raw, delivered))
+        parsed, holds = _derope_hold_map(
+            hold_map, raw, "H3 de-rope oracle hold map")
+        prefix = raw - delivered
+        consumers = _derope_future_visual_consumers(state, scene)
+        suffix = min(17, raw) if consumers else 0
+        removed_prefix = sum(holds[:prefix]) - min(prefix, len(holds))
+        removed_suffix = (
+            sum(holds[len(holds) - suffix:]) - suffix if suffix else 0)
+        for index in range(min(prefix, len(holds))):
+            holds[index] = 1
+        for index in range(max(0, len(holds) - suffix), len(holds)):
+            holds[index] = 1
+        parsed.update({
+            "holds": holds,
+            "world_len": raw,
+            "h3_chain_scene": scene,
+            "h3_chain_protected_prefix": prefix,
+            "h3_chain_protected_suffix": suffix,
+            "h3_chain_visual_consumers": consumers,
+        })
+        expand_to_end = not consumers
+        status = (
+            "de-rope %s scene %d/%d: %d RAW frames; prefix %d held at 1 "
+            "(%d dilated frames removed); suffix %d held at 1 "
+            "(%d removed); visual consumers=%s; expand_to_end=%s; "
+            "protected map currently %d "
+            "frames before H3 legal-grid padding" % (
+                kind, scene, scene_count, raw, prefix, removed_prefix, suffix,
+                removed_suffix,
+                ",".join(str(value) for value in consumers) or "none",
+                "on" if expand_to_end else "off",
+                sum(holds)))
+        return (json.dumps(parsed, separators=(",", ":")), expand_to_end,
+                prefix, suffix, status)
+
+
+class MiniMaxH3ChainDeropeFreezeMask:
+    """Freeze a protected chain prefix in MAINodes H3 V2V Init."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "state": (DEROPE_STATE_TYPE, {
+                    "tooltip": "Current Shot or Checkpoint Upscale Loop "
+                               "state carrying the exact RAW/delivered "
+                               "prefix contract."}),
+                "hold_map_used": ("STRING", {
+                    "forceInput": True,
+                    "tooltip": "Final hold_map_used emitted by H3 Time Smear. "
+                               "It includes end expansion and legal padding."}),
+            },
+        }
+
+    RETURN_TYPES = ("MASK", "INT", "STRING")
+    RETURN_NAMES = ("mask", "dilated_length", "status")
+    OUTPUT_TOOLTIPS = (
+        "Time-varying regenerate mask for H3 V2V Init: zero over the "
+        "continuation prefix and one over material pass 2 may refine.",
+        "Exact dilated frame length encoded by hold_map_used.",
+        "Prefix-freeze and dilated-clock summary.",
+    )
+    FUNCTION = "mask"
+    CATEGORY = "conditioning/minimax/context_loop/upscale"
+    DESCRIPTION = (
+        "Build the time-varying mask paired with De-Rope Guard. Connect it "
+        "to MAINodes H3 V2V Init and enable time_varying. This prevents pass "
+        "2 from re-texturing a Drift-Control continuation prefix after the "
+        "same prefix has been protected from retiming.")
+
+    def mask(self, state, hold_map_used):
+        if chain.torch is None:
+            raise RuntimeError("PyTorch is required for an H3 de-rope mask.")
+        segment, _scene, _count, _compat, _kind = _derope_state_view(state)
+        raw = int(segment.get("raw_frames", 0))
+        delivered = int(segment.get("delivered_frames", 0))
+        prefix = raw - delivered
+        _parsed, holds = _derope_hold_map(
+            hold_map_used, raw, "H3 Time Smear hold_map_used")
+        if any(hold != 1 for hold in holds[:prefix]):
+            raise ValueError(
+                "H3 Time Smear hold_map_used retimes the %d-frame chain "
+                "prefix. Route H3 Jerk Oracle through MiniMax H3 Chain "
+                "De-Rope Guard before Time Smear." % prefix)
+        length = sum(holds)
+        mask = chain.torch.ones((length, 8, 8), dtype=chain.torch.float32)
+        if prefix:
+            mask[:prefix] = 0.0
+        status = (
+            "de-rope freeze mask: frames [0,%d) frozen, [%d,%d) open; "
+            "connect to H3 V2V Init mask with time_varying enabled" %
+            (prefix, prefix, length))
+        return mask, length, status
+
+
+class MiniMaxH3ChainDeropeContinuity:
+    """Splice a saved HQ Drift-Control tail into the dilated pass-2 init."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "state": (DEROPE_STATE_TYPE, {
+                    "tooltip": "Current Shot or Checkpoint Upscale Loop "
+                               "state. Live-chain state resolves the same "
+                               "linear, non-linear, or composed visual "
+                               "context used by Chain Context."}),
+                "video_latent": ("LATENT", {
+                    "tooltip": "Target-resolution 24-channel clean video "
+                               "latent after Time Smear, VAE encode, and the "
+                               "spatial latent upscaler."}),
+            },
+        }
+
+    RETURN_TYPES = ("LATENT", "STRING")
+    RETURN_NAMES = ("video_latent", "status")
+    OUTPUT_TOOLTIPS = (
+        "Target-resolution de-rope video init with the prior HQ tail spliced "
+        "into a Drift-Control prefix when required.",
+        "Whether prior HQ context was spliced, source context was protected, "
+        "or the scene has no latent continuation prefix.",
+    )
+    FUNCTION = "splice"
+    CATEGORY = "conditioning/minimax/context_loop/upscale"
+    DESCRIPTION = (
+        "Restore live or deferred continuity before MAINodes H3 V2V Init. "
+        "For Drift-Control scenes it replaces the protected target-resolution "
+        "prefix with the resolved saved visual-context latent; other scenes "
+        "pass through unchanged.")
+
+    def splice(self, state, video_latent):
+        video, _width, _height = _target_video_geometry(video_latent)
+        output, steps, route = _derope_drift_continuation_video(video, state)
+        result = dict(video_latent)
+        result["samples"] = output
+        status = "de-rope continuity: %s" % route
+        if steps:
+            status += " (%d latent steps)" % steps
+        return result, status
+
+
+class MiniMaxH3ChainRecoveredAV:
+    """Repack exact-recovered de-rope latents for chain save and resume."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "state": (DEROPE_STATE_TYPE, {
+                    "tooltip": "Current Shot or Checkpoint Upscale Loop "
+                               "state whose RAW clock the recovered latent "
+                               "must match."}),
+                "video_latent": ("LATENT", {
+                    "tooltip": "H3 video VAE encode of frames after H3 Exact "
+                               "Recover, back on the original RAW clock."}),
+            },
+            "optional": {
+                "audio_latent": ("LATENT", {
+                    "tooltip": "H3 audio VAE encode of H3 Audio Recover. It "
+                               "is optional for a deferred video-only result "
+                               "and required when saving into the live H3 "
+                               "chain, whose checkpoints are always joint AV."}),
+            },
+        }
+
+    RETURN_TYPES = ("LATENT", "STRING")
+    RETURN_NAMES = ("latent", "status")
+    OUTPUT_TOOLTIPS = (
+        "Recovered single-video or joint AV latent suitable for Upscale "
+        "Segment Save and Loop End.",
+        "Verified recovered RAW clock and packed stream layout.",
+    )
+    FUNCTION = "pack"
+    CATEGORY = "conditioning/minimax/context_loop/upscale"
+    DESCRIPTION = (
+        "Return the de-roped result to the source scene's world clock. This "
+        "node rejects a still-dilated video latent, optionally rejoins the "
+        "recovered audio latent, and provides the exact HQ context that a "
+        "following Drift-Control scene or interrupted child run needs.")
+
+    def pack(self, state, video_latent, audio_latent=None):
+        video, width, height = _target_video_geometry(video_latent)
+        segment, _scene, _count, _compat, kind = _derope_state_view(state)
+        raw = chain._validate_h3_length(
+            segment.get("raw_frames", 0), "Recovered H3 scene length")
+        expected_steps = (raw - 5) // 17 * 5 + 2
+        if int(video.shape[2]) != expected_steps:
+            raise ValueError(
+                "Recovered de-rope video still has %d latent steps; the "
+                "%d-frame RAW world clock requires %d. Decode pass 2, run "
+                "H3 Exact Recover, then VAE Encode before this node." %
+                (int(video.shape[2]), raw, expected_steps))
+        streams = [video]
+        layout = "video"
+        if kind == "chain" and audio_latent is None:
+            raise ValueError(
+                "Live-chain de-rope requires recovered audio_latent so "
+                "Segment Save and Loop End can persist a complete H3 AV "
+                "checkpoint.")
+        if audio_latent is not None:
+            audio = _single_latent_tensor(
+                audio_latent, "Recovered de-rope audio latent")
+            if getattr(audio, "ndim", 0) != 4 or int(audio.shape[1]) != 32:
+                raise ValueError(
+                    "Recovered de-rope audio latent must be [B,32,2,T], "
+                    "got %s." % (tuple(getattr(audio, "shape", ())),))
+            if int(audio.shape[0]) != int(video.shape[0]):
+                raise ValueError(
+                    "Recovered de-rope video/audio batches differ: %d vs %d." %
+                    (int(video.shape[0]), int(audio.shape[0])))
+            streams.append(audio)
+            layout = "joint AV"
+        result = dict(video_latent)
+        result["samples"] = _packed_samples(streams)
+        return result, (
+            "recovered de-rope %s at %dx%d on %d-frame RAW clock (%d video "
+            "latent steps)" % (layout, width, height, raw, expected_steps))
+
+
+class MiniMaxH3UpscaleReferencePromptOverride:
+    """Inline editor that remains on the normal Tagged Reference chain."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "prompt_override": ("STRING", {
+                    "default": "", "multiline": True,
+                    "dynamicPrompts": True,
+                    "tooltip": "Optional pass-2 prompt. Blank tells Upscale "
+                               "Reference Conditioning to reuse the source "
+                               "scene prompt."}),
+                "disabled_tags": ("STRING", {
+                    "default": "",
+                    "tooltip": "Optional comma-separated @tags to remove "
+                               "from the connected pass-2 registry. Leave "
+                               "blank to preserve the reference line exactly."}),
+            },
+            "optional": {
+                "references": (chain.TAGGED_REFERENCE_TYPE, {
+                    "tooltip": "Normal Tagged Picture/Video/Audio Ref line. "
+                               "When connected downstream, this explicit "
+                               "registry replaces the automatic cached refs."}),
+            },
+        }
+
+    RETURN_TYPES = (chain.TAGGED_REFERENCE_TYPE, "STRING", "STRING", "STRING")
+    RETURN_NAMES = (
+        "references", "prompt_override", "reference_fingerprint", "status")
+    OUTPUT_TOOLTIPS = (
+        "The same Tagged Ref line, optionally filtered by disabled_tags.",
+        "Pass-2 prompt override; blank preserves the source scene prompt.",
+        "Fingerprint of the effective connected registry, or blank.",
+        "Whether the node passed, filtered, or omitted connected refs.",
+    )
+    FUNCTION = "override"
+    CATEGORY = "conditioning/minimax/context_loop/upscale"
+    DESCRIPTION = (
+        "Stay inline on the standard H3 Tagged Reference chain while selecting "
+        "the explicit refs and text used only by deferred upscale. Connected "
+        "refs replace the automatic cached payload; an unconnected reference "
+        "socket leaves automatic cache restore active.")
+
+    def override(self, prompt_override="", disabled_tags="", references=None):
+        prompt = str(prompt_override or "").replace(
+            "\r\n", "\n").replace("\r", "\n").strip()
+        if references is None:
+            status = (
+                "no connected Tagged refs; automatic cache remains active"
+                + ("; prompt overridden" if prompt else
+                   "; source prompt preserved"))
+            return None, prompt, "", status
+
+        entries = chain._tagged_reference_entries(references)
+        disabled = {
+            value.strip().lstrip("@")
+            for value in str(disabled_tags or "").split(",")
+            if value.strip().lstrip("@")
+        }
+        unknown = disabled.difference({
+            alias for entry in entries
+            for alias in chain._reference_entry_tags(entry)
+        })
+        if unknown:
+            raise ValueError(
+                "Upscale reference override cannot disable unknown tag @%s." %
+                sorted(unknown)[0])
+        if disabled:
+            effective_entries = [
+                entry for entry in entries
+                if not disabled.intersection(
+                    chain._reference_entry_tags(entry))]
+            effective = chain._make_tagged_references(effective_entries)
+        else:
+            effective_entries = entries
+            effective = references
+        fingerprint = str(effective.get("fingerprint") or "")
+        status = "%d connected Tagged ref(s) replace cache" % len(
+            effective_entries)
+        if disabled:
+            status += "; disabled %s" % ", ".join(
+                "@" + tag for tag in sorted(disabled))
+        status += "; " + (
+            "prompt overridden" if prompt else "source prompt preserved")
+        return effective, prompt, fingerprint, status
+
+
+class MiniMaxH3ChainUpscaleReferenceConditioning:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "state": (UPSCALE_STATE_TYPE, {
+                    "tooltip": "Current Upscale state. The node uses only the "
+                               "selected source branch, scene, prompt, and "
+                               "generation fingerprint to discover refs."}),
+                "clip": ("CLIP", {
+                    "tooltip": "MiniMax H3 text encoder used to rebuild the "
+                               "cached Ref2VA presentation at pass 2."}),
+                "missing_cache": (("text_only", "error"), {
+                    "default": "text_only",
+                    "tooltip": "Missing caches are first rebuilt from saved "
+                               "reference identities and archived media, using "
+                               "the connected VAEs. If recovery is unavailable, "
+                               "text_only falls back to text; error reports the "
+                               "missing source or VAE without dropping refs."}),
+                "motion_ref_mode": (MOTION_REFERENCE_MODES, {
+                    "default": "exclude_video_keep_audio",
+                    "tooltip": "Pass-2 motion-reference policy. The default "
+                               "removes both native video-ref latents and their "
+                               "Qwen presentation, while keeping paired audio."}),
+            },
+            "optional": {
+                "target_video_latent": ("LATENT", {
+                    "tooltip": "Actual 24-channel pass-2 video latent. When "
+                               "connected with video_vae, match-sized picture "
+                               "refs and their Qwen presentation are rebuilt "
+                               "for its exact H3 canvas."}),
+                "video_vae": ("VAE", {
+                    "tooltip": "Original MiniMax H3 video VAE used to "
+                               "re-encode match-sized picture references at "
+                               "the pass-2 canvas. Never use the audio VAE."}),
+                "prompt_override": ("STRING", {
+                    "default": "", "multiline": True,
+                    "tooltip": "Optional pass-2 text prompt. Blank reuses the "
+                               "exact compiled generation prompt. Use a concise "
+                               "appearance/detail prompt to avoid repeating "
+                               "source motion or camera instructions."}),
+                "tagged_references": (chain.TAGGED_REFERENCE_TYPE, {
+                    "tooltip": "Optional pass-2 Tagged Ref line from Upscale "
+                               "Reference + Prompt Override. When connected, "
+                               "it replaces the cached reference payload and "
+                               "is compiled with prompt_override."}),
+                "audio_vae": ("VAE", {
+                    "tooltip": "MiniMax H3 audio VAE. It is needed only when "
+                               "the connected override registry activates "
+                               "standalone or paired reference audio."}),
+                "override_ref_image_size": (("inherit", "match", "max"), {
+                    "default": "inherit",
+                    "tooltip": "Picture sizing for cached, rebuilt, or connected "
+                               "refs. inherit preserves the saved match/max "
+                               "policy; match/max explicitly overrides it. "
+                               "Changing cached sizing requires video_vae."}),
+                "override_reference_policy": (
+                    list(chain.REFERENCE_COMPLIANCE_MODES), {
+                        "default": "strict",
+                        "tooltip": "Prompt/tag validation for connected "
+                                   "pass-2 Tagged refs."}),
+                "override_semantic_anchor_size": (
+                    ["inherit", *chain.SEMANTIC_ANCHOR_SIZES], {
+                        "default": "inherit",
+                        "tooltip": "Qwen semantic-anchor size, separate from "
+                                   "native picture sizing. inherit keeps saved "
+                                   "settings (or a connected anchor bundle). An "
+                                   "explicit size rebuilds cached anchors from "
+                                   "verified source media; source keeps their "
+                                   "original size. Use a new upscale profile "
+                                   "when changing this setting."}),
+                "override_semantic_anchor_mode": (
+                    ["inherit", *chain.SEMANTIC_ANCHOR_MODES], {
+                        "default": "inherit",
+                        "tooltip": "Semantic-anchor presentation: timestamped "
+                                   "video or picture storyboard, as in Tagged "
+                                   "Scene Options. Explicit changes rebuild "
+                                   "both presentation and prompt labels. Use a "
+                                   "new upscale profile when changing this setting."}),
+            },
+        }
+
+    RETURN_TYPES = ("CONDITIONING", "STRING", "BOOLEAN", "STRING")
+    RETURN_NAMES = (
+        "positive", "compiled_prompt", "reference_cache_used", "status")
+    OUTPUT_TOOLTIPS = (
+        "Pass-2 H3 conditioning rebuilt from cached or explicitly connected "
+        "Ref2VA media. Match pictures remain canvas-aware and motion video "
+        "follows motion_ref_mode.",
+        "Prompt actually encoded for pass 2: custom override, exact cached "
+        "compiled prompt, or saved source prompt.",
+        "True only when the automatic cache was used; connected live refs "
+        "report False even though their conditioning is active.",
+        "Scene-local cache lookup result and fingerprint summary.",
+    )
+    FUNCTION = "condition"
+    CATEGORY = "conditioning/minimax/context_loop/upscale"
+    DESCRIPTION = (
+        "Automatically restore a scene-local H3 reference payload or replace "
+        "it with a connected pass-2 Tagged Ref line and, when "
+        "given the upscaled video latent plus H3 video VAE, rebuild all "
+        "resolution-dependent pass-2 picture conditioning. The motion policy "
+        "filters both Qwen presentation and native H3 reference blocks. No "
+        "Plan or Source Timeline wiring is required.")
+
+    def condition(self, state, clip, missing_cache="text_only",
+                  target_video_latent=None, video_vae=None,
+                  prompt_override="",
+                  motion_ref_mode="exclude_video_keep_audio",
+                  tagged_references=None, audio_vae=None,
+                  override_ref_image_size="inherit",
+                  override_reference_policy="strict", _target_size=None,
+                  override_semantic_anchor_size="inherit",
+                  override_semantic_anchor_mode="inherit"):
+        if override_ref_image_size not in ("inherit", "match", "max"):
+            raise ValueError(
+                "Override ref_image_size must be inherit, match, or max.")
+        anchor_overrides = {
+            "semantic_anchor_size": override_semantic_anchor_size,
+            "semantic_anchor_mode": override_semantic_anchor_mode,
+        }
+        for key, choices in (("semantic_anchor_size", chain.SEMANTIC_ANCHOR_SIZES),
+                             ("semantic_anchor_mode", chain.SEMANTIC_ANCHOR_MODES)):
+            if anchor_overrides[key] not in ("inherit", *choices):
+                raise ValueError("Override %s must be one of %s." % (key, ("inherit", *choices)))
+        explicit_anchors = {key: value for key, value in anchor_overrides.items() if value != "inherit"}
+        anchor_status = ("; explicit anchor overrides: " + ", ".join(
+            "%s=%s" % item for item in explicit_anchors.items())) if explicit_anchors else ""
+        from .reference_cache_recovery import (
+            ReferenceRecoveryUnavailable, cache_payload_missing,
+            recover_reference_cache, saved_reference_settings,
+        )
+        if target_video_latent is not None and video_vae is None:
+            raise ValueError(
+                "Target-resolution H3 conditioning needs both "
+                "target_video_latent and video_vae.")
+        target_size = _target_size
+        if target_video_latent is not None:
+            _video, target_width, target_height = _target_video_geometry(
+                target_video_latent)
+            target_size = (target_width, target_height)
+        source = _source_segment(state)
+        manifest = state["source_manifest"]
+        compatibility = manifest.get("compatibility") or {}
+        fingerprint = str(
+            source.get("generation_fingerprint",
+                       compatibility.get("generation_fingerprint")) or "")
+        scene = int(state["index"])
+        scene_count = _source_scene_count(manifest)
+        prompt = str(source.get("prompt") or "")
+        custom_prompt = str(prompt_override or "").strip()
+        if motion_ref_mode not in MOTION_REFERENCE_MODES:
+            raise ValueError(
+                "Unknown H3 motion reference mode %r." % motion_ref_mode)
+        geometry = _source_geometry(source, compatibility)
+        width = int(geometry.get("width", 0))
+        height = int(geometry.get("height", 0))
+        length = int(source.get("raw_frames", 0))
+        descriptor = source.get("reference_cache")
+        if source.get("processing_source"):
+            # Cache lookup belongs to generation, not the later canvas. Adapt
+            # the found references to the processing canvas separately.
+            target_size = target_size or (width, height)
+            original = source["processing_source"]["original"]
+            original_geometry = chain.saved_resolution(original) or compatibility
+            width, height = int(original_geometry["width"]), int(original_geometry["height"])
+        if tagged_references is not None:
+            ref_image_size = str(override_ref_image_size)
+            inherited_settings = {}
+            if ref_image_size == "inherit" or any(value == "inherit" for value in anchor_overrides.values()):
+                inherited_cache = None
+                try:
+                    inherited_cache = (
+                        chain._load_run_reference_cache_descriptor(
+                            manifest.get("run_name"), scene, descriptor)
+                        if isinstance(descriptor, dict) else
+                        chain._find_reference_cache(
+                            fingerprint, scene, scene_count, prompt, width,
+                            height, length))
+                except (OSError, TypeError, ValueError, json.JSONDecodeError):
+                    # The explicit live registry is self-contained. A stale
+                    # source cache must not block it merely because inherit
+                    # was selected. Try the immutable recipe before defaults.
+                    inherited_cache = None
+                if inherited_cache is None:
+                    try:
+                        inherited_cache, _defaults = saved_reference_settings(
+                            chain, source, manifest)
+                    except (OSError, TypeError, ValueError, KeyError):
+                        inherited_cache = None
+                inherited_settings = {**(inherited_cache or {}),
+                                      **((inherited_cache or {}).get("presentation_contract") or {})}
+            if ref_image_size == "inherit":
+                ref_image_size = str(inherited_settings.get("ref_image_size") or "match")
+            bundle = chain._reference_semantic_anchor_bundle(tagged_references) or {}
+            anchor_settings = {}
+            for key, default in (("semantic_anchor_size", "512"),
+                                 ("semantic_anchor_mode", "timestamped_video")):
+                inherited = bundle.get(key)
+                if inherited in (None, "inherit"):
+                    inherited = inherited_settings.get(key) or default
+                anchor_settings[key] = explicit_anchors.get(key, inherited)
+            conditioning, compiled, status = (
+                _conditioning_from_tagged_upscale_override(
+                    state, clip, video_vae, audio_vae, tagged_references,
+                    custom_prompt or prompt, ref_image_size,
+                    motion_ref_mode, override_reference_policy,
+                    target_video_latent, target_size, **anchor_settings))
+            status += anchor_status
+            if custom_prompt:
+                status += "; custom pass-2 prompt override"
+            return conditioning, compiled, False, status
+        recovery_status = ""
+        recovery_error = ""
+        try:
+            cached = (chain._load_run_reference_cache_descriptor(
+                          manifest.get("run_name"), scene, descriptor)
+                      if isinstance(descriptor, dict) else
+                      chain._find_reference_cache(
+                          fingerprint, scene, scene_count, prompt, width, height,
+                          length))
+        except FileNotFoundError:
+            cached = None
+        except ValueError:
+            # The legacy loader reports a missing tensor as an integrity
+            # error. Recover only if the pinned descriptor still matches its
+            # metadata and a payload file is actually absent, not corrupted.
+            pinned = (chain._read_json(chain._absolute_output_path(descriptor["metadata"]))
+                      if isinstance(descriptor, dict) else None)
+            if (pinned is None or chain._reference_cache_descriptor(pinned) != descriptor
+                    or not cache_payload_missing(chain, pinned)):
+                raise
+            cached = None
+        if cached is not None and cache_payload_missing(chain, cached):
+            cached = None
+        if cached is None:
+            try:
+                cached, recovery_status = recover_reference_cache(
+                    chain, source, manifest, scene_count, video_vae, audio_vae,
+                    ref_image_size=override_ref_image_size, **anchor_overrides)
+            except ReferenceRecoveryUnavailable as exc:
+                recovery_error = str(exc)
+        if cached is not None:
+            # V1 match caches may have lost their full-size masters. Recover
+            # those from verified archived media before changing to max;
+            # relabelling their already downsized tensors would ignore Max.
+            contract = cached.get("presentation_contract") or {}
+            change_anchors = bool(contract or chain._SEMANTIC_ANCHOR_RE.search(prompt)) and any(
+                contract.get(key) != value for key, value in explicit_anchors.items())
+            recover_max_masters = (override_ref_image_size == "max"
+                    and cached.get("ref_image_size", "match") != "max"
+                    and len(cached.get("source_images") or []) < sum(
+                        block.get("kind") == "image"
+                        for block in cached.get("reference_blocks") or []))
+            if change_anchors or recover_max_masters:
+                # Preserve every unspecified cache setting, not legacy defaults.
+                # Changed settings participate in the derived cache identity;
+                # the immutable source descriptor is never replaced.
+                settings = {key: explicit_anchors.get(key, contract.get(key) or "inherit")
+                            for key in anchor_overrides}
+                try:
+                    cached, recovery_status = recover_reference_cache(
+                        chain, source, manifest, scene_count, video_vae, audio_vae,
+                        ref_image_size=(cached.get("ref_image_size") or "match")
+                        if override_ref_image_size == "inherit" else override_ref_image_size,
+                        **settings)
+                except ReferenceRecoveryUnavailable as exc:
+                    if change_anchors:
+                        raise ValueError(
+                            "Cannot apply semantic-anchor overrides from saved media: %s "
+                            "Connect explicit Tagged references with the original anchors." % exc) from exc
+                    raise ValueError(
+                        "Cannot change cached match references to max without "
+                        "original picture masters: %s" % exc) from exc
+            cached_policy = str(cached.get("ref_image_size") or "match")
+            ref_image_size = (cached_policy if override_ref_image_size == "inherit"
+                              else override_ref_image_size)
+            target_detail = None
+            if target_size is not None or ref_image_size != cached_policy:
+                target_width, target_height = target_size or (width, height)
+                conditioning, target_detail = (
+                    chain._conditioning_from_reference_cache_target(
+                        clip, video_vae, cached, target_width, target_height,
+                        custom_prompt or None, motion_ref_mode,
+                        ref_image_size=ref_image_size))
+            else:
+                conditioning = chain._conditioning_from_reference_cache(
+                    clip, cached, custom_prompt or None, motion_ref_mode)
+            conditioning = _mark_h3_upscale_motion_policy(
+                conditioning, motion_ref_mode, ref_image_size,
+                picture_refs_target_sized=bool(
+                    target_size is not None and target_detail is not None and
+                    target_detail.get("policy") == "match"))
+            compiled = (custom_prompt or
+                        str(cached.get("compiled_prompt") or prompt))
+            status = (
+                "scene %d/%d restored Ref2VA cache %s (%d blocks, %d "
+                "presentation items)" % (
+                    scene, scene_count, str(cached.get("signature") or "")[:12],
+                    len(cached.get("reference_blocks") or ()),
+                    len(cached.get("presentation") or ())))
+            if target_detail is not None:
+                status += (
+                    "; pass-2 %dx%d policy=%s: rebuilt %d %s pictures "
+                    "(%d source masters, %d V1 fallbacks), preserved %d "
+                    "native blocks" % (
+                        target_detail["target_width"],
+                        target_detail["target_height"],
+                        target_detail["policy"],
+                        target_detail["rebuilt_images"],
+                        target_detail["policy"],
+                        target_detail["master_rebuilds"],
+                        target_detail["fallback_rebuilds"],
+                        target_detail["preserved_blocks"]))
+            if override_ref_image_size != "inherit":
+                status += "; explicit picture sizing override=%s" % ref_image_size
+            if ref_image_size == "max" and not (target_detail or {}).get("rebuilt_images"):
+                status += "; max pictures keep cached geometry"
+            if custom_prompt:
+                status += "; custom pass-2 prompt override"
+            status += "; motion refs=%s" % motion_ref_mode
+            if recovery_status:
+                status += "; " + recovery_status
+            status += anchor_status
+            return conditioning, compiled, True, status
+        if str(missing_cache) == "error":
+            raise FileNotFoundError(
+                "No automatic H3 reference cache matches source scene %d. "
+                "Saved-reference recovery could not complete: %s "
+                "Restore the named source media/connect Tagged references, "
+                "or explicitly choose text_only." % (scene, recovery_error))
+        compiled = custom_prompt or prompt
+        tokens = clip.tokenize(compiled)
+        conditioning = clip.encode_from_tokens_scheduled(tokens)
+        conditioning = _mark_h3_upscale_motion_policy(
+            conditioning, motion_ref_mode)
+        status = (
+            "scene %d/%d has no matching Ref2VA cache; rebuilt text-only "
+            "conditioning%s" % (
+                scene, scene_count,
+                " (generation fingerprint %s)" % fingerprint[:12]
+                if fingerprint else ""))
+        if custom_prompt:
+            status += "; custom pass-2 prompt override"
+        status += "; motion refs=%s" % motion_ref_mode
+        if recovery_error:
+            status += "; saved-reference recovery unavailable: " + recovery_error
+        return conditioning, compiled, False, status
+
+
+class MiniMaxH3ChainUpscalePixelConditioning:
+    """Rebuild references with optional sizing; sync spatial inputs to IMAGE."""
+
+    EXPERIMENTAL = True
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        schema = MiniMaxH3ChainUpscaleReferenceConditioning.INPUT_TYPES()
+        schema["optional"].pop("target_video_latent")
+        # Append new widgets after the existing pixel canvas controls so old
+        # positional widgets_values keep their conditioning width and height.
+        anchors = {key: schema["optional"].pop(key) for key in (
+            "override_semantic_anchor_size", "override_semantic_anchor_mode")}
+        schema["required"]["video_vae"] = schema["optional"].pop("video_vae")
+        schema["required"]["images"] = ("IMAGE", {
+            "tooltip": "Actual upscaled RAW images BEFORE USDU/refinement. "
+                       "Their width/height drive automatic reference sizing. Connect "
+                       "the same images to the image refiner; no latent encode "
+                       "or guessed scale multiplier is needed."})
+        schema["required"]["method"] = (CONDITIONING_SYNC_METHODS, {
+            "default": "bilinear",
+            "tooltip": "Interpolation for eligible cached video/keyframe "
+                       "latents. Match picture refs are rebuilt from RGB "
+                       "masters; max pictures and audio remain unchanged."})
+        for axis in ("width", "height"):
+            schema["optional"][f"conditioning_{axis}"] = ("INT", {
+                "default": 0, "min": 0, "max": 16384, "step": 32,
+                "tooltip": f"Reference-conditioning canvas {axis}. 0 uses the "
+                           f"actual image {axis}; a positive multiple of 32 "
+                           "overrides only this axis. Sizes cached or connected "
+                           "match picture refs, not output images or keyframes. "
+                           "Max picture policy remains unchanged. Use a new "
+                           "upscale profile when changing this setting."})
+        schema["optional"].update(anchors)
+        return schema
+
+    RETURN_TYPES = ("CONDITIONING", "IMAGE", "INT", "INT", "STRING", "BOOLEAN", "STRING")
+    RETURN_NAMES = ("positive", "images", "width", "height", "compiled_prompt",
+                    "reference_cache_used", "status")
+    OUTPUT_TOOLTIPS = (
+        "Positive conditioning with automatic or custom reference sizing. "
+        "Connect to a fresh Basic Guider.",
+        "Unchanged upscaled RAW images for the pixel refiner.",
+        "Measured target width.", "Measured target height.",
+        "Actual encoded pass-2 prompt.", "Whether an automatic cache was restored.",
+        "Actual image size, reference size, scale, cache and motion-reference policy.",
+    )
+    FUNCTION = "condition"
+    CATEGORY = "conditioning/minimax/context_loop/upscale"
+    DESCRIPTION = (
+        "Experimental IMAGE-driven pass-2 conditioning. Combines reference "
+        "restore and spatial synchronization without an upscaled latent. "
+        "conditioning_width/height=0 follow the images; positive values "
+        "override only the reference-conditioning canvas. Output images and "
+        "keyframes stay aligned to the actual canvas. "
+        "The actual image canvas must be H3-aligned (multiples of 32); no "
+        "silent resize, video encoding, audio sampling or prefix masking occurs.")
+
+    def condition(self, state, clip, images, video_vae, method="bilinear",
+                  missing_cache="text_only", motion_ref_mode="exclude_video_keep_audio",
+                  prompt_override="", tagged_references=None, audio_vae=None,
+                  override_ref_image_size="inherit", override_reference_policy="strict",
+                  conditioning_width=0, conditioning_height=0,
+                  override_semantic_anchor_size="inherit",
+                  override_semantic_anchor_mode="inherit"):
+        if method not in CONDITIONING_SYNC_METHODS:
+            raise ValueError("Unknown H3 conditioning sync method %r." % method)
+        source = _source_segment(state)
+        if (not chain.torch.is_tensor(images) or images.ndim != 4
+                or int(images.shape[-1]) != 3
+                or int(images.shape[0]) != int(source["raw_frames"])):
+            raise ValueError("Pixel conditioning needs the complete RAW RGB scene, "
+                             "without frame trimming, interpolation or duplication.")
+        height, width = map(int, images.shape[1:3])
+        if width < 32 or height < 32 or width % 32 or height % 32:
+            raise ValueError("Pixel target %dx%d is not H3-aligned. Resize the images "
+                             "to multiples of 32 before conditioning and refinement." %
+                             (width, height))
+        reference_size = []
+        for axis, value, automatic in (
+                ("width", conditioning_width, width),
+                ("height", conditioning_height, height)):
+            if (not isinstance(value, int) or value < 0 or value > 16384
+                    or value % 32):
+                raise ValueError(
+                    "conditioning_%s must be 0 (auto) or a positive "
+                    "multiple of 32 up to 16384." % axis)
+            reference_size.append(value or automatic)
+        compatibility = state["source_manifest"].get("compatibility") or {}
+        source_width, source_height = (int(compatibility.get(key, 0))
+                                       for key in ("width", "height"))
+        if source_width < 1 or source_height < 1:
+            raise ValueError("Source H3 manifest has no valid canvas dimensions.")
+        positive, compiled, used, status = (
+            MiniMaxH3ChainUpscaleReferenceConditioning().condition(
+                state, clip, missing_cache, video_vae=video_vae,
+                prompt_override=prompt_override, motion_ref_mode=motion_ref_mode,
+                tagged_references=tagged_references, audio_vae=audio_vae,
+                override_ref_image_size=override_ref_image_size,
+                override_reference_policy=override_reference_policy,
+                override_semantic_anchor_size=override_semantic_anchor_size,
+                override_semantic_anchor_mode=override_semantic_anchor_mode,
+                _target_size=tuple(reference_size)))
+        # Reference pictures have already been rebuilt for the chosen canvas
+        # and are marked to avoid double scaling. Keyframes and eligible
+        # video latents still follow the real images, never the override.
+        scale_x, scale_y = width / source_width, height / source_height
+        positive = _sync_h3_conditioning(
+            positive, scale_x, scale_y, method, "conditioning_policy")
+        status += "; pixel target %dx%d (x%.4g/y%.4g); no target latent" % (
+            width, height, scale_x, scale_y)
+        if conditioning_width or conditioning_height:
+            status += "; conditioning canvas %dx%d (width=%s, height=%s)" % (
+                *reference_size,
+                "manual" if conditioning_width else "auto",
+                "manual" if conditioning_height else "auto")
+        chain._LOG.info("H3 %s", status)
+        return positive, images, width, height, compiled, used, status
+
+
+class H3ConditioningSyncFromLatents:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "original_latent": ("LATENT", {
+                    "tooltip": "Original-resolution 24-channel H3 video latent "
+                               "whose conditioning will be synchronized. Its "
+                               "time may differ from a de-rope target."}),
+                "upscaled_latent": ("LATENT", {
+                    "tooltip": "Upscaled 24-channel H3 video latent. Its exact "
+                               "X/Y scale drives the conditioning resize; a "
+                               "dilated de-rope time axis is supported."}),
+                "positive": ("CONDITIONING", {
+                    "tooltip": "Original H3 conditioning containing minimax_refs "
+                               "and/or minimax_keyframes. Cached max pictures "
+                               "remain at their core-defined geometry."}),
+                "method": (CONDITIONING_SYNC_METHODS, {
+                    "default": "bilinear",
+                    "tooltip": "Spatial interpolation used for match-sized "
+                               "picture refs, eligible video refs, and keyframe "
+                               "latents. Max pictures, time, and audio are unchanged."}),
+                "motion_ref_mode": (CONDITIONING_SYNC_MOTION_MODES, {
+                    "default": "conditioning_policy",
+                    "tooltip": "conditioning_policy automatically follows "
+                               "Upscale Reference Conditioning. Explicit modes "
+                               "are available for standalone/A-B use."}),
+            },
+            "optional": {
+                "negative": ("CONDITIONING", {
+                    "tooltip": "Optional negative conditioning. Use the returned "
+                               "negative when rebuilding a CFG Guider."}),
+            },
+        }
+
+    RETURN_TYPES = (
+        "CONDITIONING", "CONDITIONING", "INT", "INT", "FLOAT", "FLOAT")
+    RETURN_NAMES = (
+        "positive", "negative", "width", "height", "scale_x", "scale_y")
+    OUTPUT_TOOLTIPS = (
+        "Positive conditioning with visual refs/keyframes synchronized to the "
+        "upscaled latent.",
+        "Negative conditioning synchronized by the same scale, when connected.",
+        "Upscaled video width in pixels.",
+        "Upscaled video height in pixels.",
+        "Exact horizontal latent scale.",
+        "Exact vertical latent scale.",
+    )
+    FUNCTION = "sync"
+    CATEGORY = "conditioning/minimax/context_loop/upscale"
+    DESCRIPTION = (
+        "Synchronize H3 pass-2 conditioning from the original and upscaled "
+        "latents. Resizes match-sized picture refs and keyframes while keeping "
+        "Core H3 max-sized pictures invariant, filters or retains motion refs "
+        "according to the conditioner policy (or an explicit override), "
+        "updates changed H/W metadata, and leaves reference time and audio "
+        "conditioning untouched. The target may use a longer de-rope clock; "
+        "only batch and video channels must match. Build a new Guider from "
+        "the returned output.")
+
+    def sync(self, original_latent, upscaled_latent, positive,
+             method="bilinear",
+             motion_ref_mode="conditioning_policy", negative=None):
+        original, _source_width, _source_height = _target_video_geometry(
+            original_latent)
+        upscaled, width, height = _target_video_geometry(upscaled_latent)
+        if tuple(original.shape[:2]) != tuple(upscaled.shape[:2]):
+            raise ValueError(
+                "H3 conditioning sync requires matching batch/channel; "
+                "original %s vs upscaled %s." %
+                (tuple(original.shape[:2]), tuple(upscaled.shape[:2])))
+        if method not in CONDITIONING_SYNC_METHODS:
+            raise ValueError("Unknown H3 conditioning sync method %r." % method)
+        if motion_ref_mode not in CONDITIONING_SYNC_MOTION_MODES:
+            raise ValueError(
+                "Unknown H3 motion reference mode %r." % motion_ref_mode)
+        scale_x = int(upscaled.shape[-1]) / float(original.shape[-1])
+        scale_y = int(upscaled.shape[-2]) / float(original.shape[-2])
+        return (
+            _sync_h3_conditioning(
+                positive, scale_x, scale_y, method, motion_ref_mode),
+            _sync_h3_conditioning(
+                negative, scale_x, scale_y, method, motion_ref_mode),
+            width, height, scale_x, scale_y,
+        )
+
+
+class MiniMaxH3ChainPass2Prepare:
+    """Rejoin LBH's video-only result with clean audio and CONST re-noise."""
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "upscaled_video": ("LATENT", {
+                    "tooltip": "24-channel clean H3 video latent emitted by "
+                               "LBH's 2D/3D latent upscaler."}),
+                "source_audio": ("LATENT", {
+                    "tooltip": "Untouched 32-channel audio latent from H3 "
+                               "Upscale Current Scene."}),
+                "model": ("MODEL", {
+                    "tooltip": "The exact pass-2 H3 model after LoRA and "
+                               "sigma-shift patches."}),
+                "noise": ("NOISE", {
+                    "tooltip": "Pass-2 random noise. Only the video member is "
+                               "generated; audio stays at the saved x0."}),
+                "sigmas": ("SIGMAS", {
+                    "tooltip": "Pass-2 sigma schedule. Its first sigma is "
+                               "used for NestedTensor-safe CONST re-noise."}),
+            },
+            "optional": {
+                "state": (UPSCALE_STATE_TYPE, {
+                    "tooltip": "Current Upscale state. When the source scene "
+                               "uses Drift-Control AV, its previous HQ latent "
+                               "tail replaces and protects the pass-2 prefix."}),
+            },
+        }
+
+    RETURN_TYPES = ("LATENT", "INT", "INT", "STRING")
+    RETURN_NAMES = ("latent", "width", "height", "status")
+    OUTPUT_TOOLTIPS = (
+        "Joint H3 AV latent ready for Sampler Custom Advanced with Disable "
+        "Noise; video is re-noised and audio is masked clean.",
+        "Exact output pixel width inferred from the upscaled latent.",
+        "Exact output pixel height inferred from the upscaled latent.",
+        "Verified stream geometry, audio lock, and sigma start.",
+    )
+    FUNCTION = "prepare"
+    CATEGORY = "conditioning/minimax/context_loop/upscale"
+    DESCRIPTION = (
+        "Adapt a video-only learned upscale into a joint MiniMax H3 pass-2 "
+        "latent. Rejoins the saved audio, applies MiniMax CONST re-noise to "
+        "the open video region only, protects a Drift-Control AV prefix from "
+        "the previous HQ latent when available, inverse-scales for Disable "
+        "Noise sampling, and locks audio so pass 2 cannot rewrite speech.")
+
+    def prepare(self, upscaled_video, source_audio, model, noise, sigmas,
+                state=None):
+        if chain.torch is None:
+            raise RuntimeError("PyTorch is required for H3 pass-2 preparation.")
+        video, width, height = _target_video_geometry(upscaled_video)
+        video, prefix_steps, continuation_route = _drift_continuation_video(
+            video, state)
+        audio = _single_latent_tensor(source_audio, "Source audio latent")
+        if getattr(audio, "ndim", 0) != 4 or int(audio.shape[1]) != 32:
+            raise ValueError(
+                "Source audio latent must be [B,32,2,T], got %s." %
+                (tuple(getattr(audio, "shape", ())),))
+        if int(video.shape[0]) != int(audio.shape[0]):
+            raise ValueError(
+                "Upscaled video/audio batch sizes differ: %d vs %d." %
+                (int(video.shape[0]), int(audio.shape[0])))
+        sigma_count = int(getattr(sigmas, "numel", lambda: len(sigmas))())
+        if sigma_count < 1:
+            raise ValueError("Pass-2 sigma schedule is empty.")
+
+        joint = {"samples": _packed_samples([video, audio])}
+        generated = noise.generate_noise({"samples": video})
+        generated_members, _generated_nested = _sample_members(generated)
+        if len(generated_members) != 1:
+            raise ValueError(
+                "Pass-2 noise source returned %d video streams; expected 1." %
+                len(generated_members))
+        video_noise = generated_members[0]
+        if tuple(video_noise.shape) != tuple(video.shape):
+            raise ValueError(
+                "Pass-2 video noise shape %s does not match latent %s." %
+                (tuple(video_noise.shape), tuple(video.shape)))
+        if prefix_steps:
+            video_noise = video_noise.clone()
+            video_noise[:, :, :prefix_steps] = 0
+        joint_noise = _packed_samples([
+            video_noise, chain.torch.zeros_like(audio)])
+
+        process_in = model.get_model_object("process_latent_in")
+        process_out = model.get_model_object("process_latent_out")
+        model_sampling = model.get_model_object("model_sampling")
+        processed = process_in(joint["samples"])
+        latent_members, latent_nested = _sample_members(processed)
+        noise_members, noise_nested = _sample_members(joint_noise)
+        if len(latent_members) != 2 or len(noise_members) != 2:
+            raise ValueError(
+                "MiniMax pass-2 AV preparation expected two joint streams.")
+        sigma_start = sigmas[0]
+        mixed_members = []
+        for latent_member, noise_member in zip(
+                latent_members, noise_members):
+            mixed = model_sampling.noise_scaling(
+                sigma_start, noise_member, latent_member)
+            inverse = getattr(model_sampling, "inverse_noise_scaling", None)
+            if callable(inverse):
+                mixed = inverse(sigma_start, mixed)
+            mixed_members.append(mixed)
+        mixed = _packed_samples(mixed_members)
+        # Preserve the real Comfy NestedTensor container even if a test double
+        # returned list-like members from process_latent_in.
+        if not (latent_nested or noise_nested) and _ComfyNestedTensor is None:
+            mixed = mixed_members
+        output_samples = process_out(mixed)
+        output_members, _ = _sample_members(output_samples)
+        output_samples = _packed_samples([
+            chain.torch.nan_to_num(member, nan=0.0, posinf=0.0, neginf=0.0)
+            for member in output_members])
+
+        output_video, output_audio = output_members[:2]
+        video_mask = chain.torch.ones(
+            (output_video.shape[0], 1, output_video.shape[2],
+             output_video.shape[3], output_video.shape[4]),
+            device=output_video.device, dtype=chain.torch.float32)
+        if prefix_steps:
+            video_mask[:, :, :prefix_steps] = 0
+        audio_mask = chain.torch.zeros(
+            (output_audio.shape[0], 1, output_audio.shape[2],
+             output_audio.shape[3]),
+            device=output_audio.device, dtype=chain.torch.float32)
+        result = {
+            "samples": output_samples,
+            "noise_mask": _packed_samples([video_mask, audio_mask]),
+        }
+        sigma_value = float(sigma_start.detach().cpu().item()) if hasattr(
+            sigma_start, "detach") else float(sigma_start)
+        status = (
+            "prepared H3 pass 2 at %dx%d: video %s, audio %s locked, "
+            "sigma_start=%.6g; %s%s" % (
+                width, height, tuple(video.shape), tuple(audio.shape),
+                sigma_value, continuation_route,
+                " (%d latent steps)" % prefix_steps if prefix_steps else ""))
+        return result, width, height, status
+
+
+class MiniMaxH3ChainUpscaleSegmentSave:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "state": (UPSCALE_STATE_TYPE, {
+                    "tooltip": "Current child-run state from Upscale Current Scene."}),
+                "images": ("IMAGE", {
+                    "tooltip": "Decoded HQ RAW scene frames, including the source "
+                               "scene's repeated head. This node trims it exactly."}),
+            },
+            "optional": {
+                "upscaled_latent": ("LATENT", {
+                    "tooltip": "Final HQ latent. Required when save_latent is "
+                               "enabled and whenever a following Drift-Control "
+                               "scene needs its compact HQ context tail."}),
+                "recovered_audio": ("AUDIO", {
+                    "tooltip": "Optional RAW-clock audio from H3 Audio "
+                               "Recover. When connected, Segment Save applies "
+                               "the same repeated-head trim as video and "
+                               "replaces the source checkpoint audio."}),
+            },
+            "hidden": {"dynprompt": "DYNPROMPT", "unique_id": "UNIQUE_ID"},
+        }
+
+    RETURN_TYPES = (UPSCALE_SEGMENT_TYPE, "STRING")
+    RETURN_NAMES = ("segment", "status")
+    OUTPUT_TOOLTIPS = (
+        "Verified HQ scene record for Upscale Loop End.",
+        "Saved scene path, dimensions, and HQ latent persistence result.",
+    )
+    FUNCTION = "save"
+    OUTPUT_NODE = True
+    CATEGORY = "conditioning/minimax/context_loop/upscale"
+    DESCRIPTION = ("Persist one trimmed HQ scene plus a self-contained assembly "
+                   "checkpoint; always retain the small HQ tail needed by a "
+                   "following Drift-Control scene and optionally retain the "
+                   "complete large HQ latent.")
+
+    @classmethod
+    def IS_CHANGED(cls, *args, **kwargs):
+        return float("NaN")
+
+    def save(self, state, images, upscaled_latent=None,
+             recovered_audio=None, dynprompt=None, unique_id=None):
+        if chain._st_save is None or chain.torch is None:
+            raise RuntimeError("safetensors and torch are required for H3 upscale saves.")
+        index = int(state["index"])
+        source = _source_segment(state)
+        raw = int(source["raw_frames"])
+        delivered = int(source["delivered_frames"])
+        trim = raw - delivered
+        if int(images.shape[0]) != raw:
+            raise ValueError(
+                "Upscale scene %d decoded %d frames; expected %d RAW frames "
+                "before trimming %d repeated frames." %
+                (index, int(images.shape[0]), raw, trim))
+        delivered_images = images[trim:trim + delivered]
+        height = int(delivered_images.shape[1])
+        width = int(delivered_images.shape[2])
+        existing = state["segments"]
+        if existing:
+            first = existing[0]
+            if (int(first.get("width", width)) != width or
+                    int(first.get("height", height)) != height):
+                raise ValueError(
+                    "Upscale scene %d is %dx%d; profile scene %d is %dx%d." %
+                    (index, width, height, int(first["index"]),
+                     int(first["width"]), int(first["height"])))
+
+        save_latent = bool(state["profile_config"]["save_latent"])
+        context_steps = _next_drift_context_steps(state, index)
+        if save_latent and upscaled_latent is None:
+            raise ValueError(
+                "Upscale profile enables save_latent, but scene %d received no HQ latent."
+                % index)
+        if context_steps and upscaled_latent is None:
+            raise ValueError(
+                "Upscale scene %d precedes a Drift-Control AV scene and must "
+                "receive the final HQ latent so its %d-step context tail can "
+                "be resumed." % (index, context_steps))
+        # Only audio is needed here; do not reload the full source AV latents
+        # while the complete HQ pixel clip is still being encoded to disk.
+        source_tensors = _load_source_tensors(source, ("delivered_audio",))
+        tensors = {"upscale_marker": chain.torch.tensor([index])}
+        sample_rate = int(source.get("sample_rate", 0))
+        audio_route = "none"
+        if recovered_audio is not None:
+            waveform, sample_rate = chain._validate_audio(
+                recovered_audio, "Recovered H3 de-rope audio")
+            expected_raw = int(round(raw / float(chain.FPS) * sample_rate))
+            available = int(waveform.shape[-1])
+            # H3's 40 Hz audio clock and VAE decode may leave a sub-frame
+            # tail, but a delivered-only track is materially too short and
+            # must not be mistaken for the RAW scene clock.
+            tolerance = max(2, int(round(sample_rate / float(chain.FPS))))
+            if available + tolerance < expected_raw:
+                raise ValueError(
+                    "Recovered H3 de-rope audio contains %d samples at %d Hz; "
+                    "the %d-frame RAW scene needs about %d. Connect H3 Audio "
+                    "Recover output, not delivered source audio." %
+                    (available, sample_rate, raw, expected_raw))
+            start = int(round(trim / float(chain.FPS) * sample_rate))
+            count = int(round(delivered / float(chain.FPS) * sample_rate))
+            padded = chain._pad_audio_to_samples({
+                "waveform": waveform,
+                "sample_rate": sample_rate,
+            }, start + count, "Recovered H3 de-rope audio")
+            tensors["delivered_audio"] = chain._tensor_cpu_clone(
+                padded["waveform"][..., start:start + count])
+            audio_route = "recovered de-rope audio"
+        elif "delivered_audio" in source_tensors:
+            tensors["delivered_audio"] = chain._tensor_cpu_clone(
+                source_tensors["delivered_audio"])
+            audio_route = "source checkpoint audio"
+        latent_layout = "omitted"
+        if save_latent:
+            latent_tensors, latent_layout = _latent_checkpoint_tensors(
+                upscaled_latent)
+            tensors.update(latent_tensors)
+            from .checkpoint_variants import processing_stage
+            if processing_stage(state["profile_config"]) == "derope":
+                # The saver also guards callers that bypass Recovered AV.
+                video = _video_stream_from_latent(upscaled_latent, "Saved DeRoPE latent")
+                expected_steps = (chain._validate_h3_length(raw, "DeRoPE RAW length") - 5) // 17 * 5 + 2
+                if (int(video.shape[2]) != expected_steps or
+                        int(video.shape[3]) * 16 != height or int(video.shape[4]) * 16 != width):
+                    raise ValueError("Save the full DeRoPE latent after Exact Recover and VAE Encode on the original RAW clock/canvas.")
+                if recovered_audio is not None and latent_layout != "joint_av":
+                    raise ValueError("Saving recovered DeRoPE audio requires audio_latent on Recovered AV for later deferred passes.")
+                if latent_layout == "joint_av":
+                    _validate_recovered_audio_shape(tensors["upscaled_audio"].shape, int(video.shape[0]), raw)
+        if context_steps:
+            tensors["upscaled_video_context"] = _upscaled_context_tensor(
+                upscaled_latent, context_steps)
+
+        paths = _state_profile_paths(state, index)
+        for key in ("segment", "checkpoint", "metadata", "prompt", "audio"):
+            os.makedirs(os.path.dirname(paths[key]), exist_ok=True)
+        transaction = uuid.uuid4().hex
+        segment_path = chain._versioned_path(paths["segment"], transaction)
+        checkpoint_path = chain._versioned_path(paths["checkpoint"], transaction)
+        metadata_path = chain._versioned_path(paths["metadata"], transaction)
+        prompt_path = chain._versioned_path(paths["prompt"], transaction)
+        audio_path = (chain._versioned_path(paths["audio"], transaction)
+                      if "delivered_audio" in tensors else None)
+        checkpoint_tmp = "%s.%s.tmp" % (checkpoint_path, uuid.uuid4().hex)
+        committed = False
+        publication_started = False
+        save_warning = ""
+        try:
+            chain._write_segment_video(
+                delivered_images, segment_path, chain.FPS,
+                int(state["profile_config"]["segment_crf"]), metadata={
+                    "title": "H3 upscale scene %d - %s" %
+                             (index, source.get("id", "scene")),
+                    "comment": str(source.get("prompt") or ""),
+                    "h3_upscale_profile": state["profile"],
+                    "h3_upscale_backend": state["profile_config"]["backend"],
+                    "h3_source_revision": str(source.get("revision") or ""),
+                })
+            chain._atomic_text(prompt_path, str(source.get("prompt") or ""))
+            if audio_path is not None:
+                chain._atomic_wav({
+                    "waveform": tensors["delivered_audio"],
+                    "sample_rate": sample_rate,
+                }, audio_path)
+            chain._st_save(tensors, checkpoint_tmp, metadata={
+                "format": "h3_chain_upscale_checkpoint_v1",
+                "index": str(index),
+                "profile": state["profile"],
+                "backend": state["profile_config"]["backend"],
+                "source_revision": str(source.get("revision") or ""),
+                "source_checkpoint_sha256": str(
+                    source.get("checkpoint_sha256") or ""),
+                "latent_layout": latent_layout,
+                "latent_saved": "true" if save_latent else "false",
+                "context_steps": str(context_steps),
+                "sample_rate": str(sample_rate),
+                "audio_route": audio_route,
+            })
+            os.replace(checkpoint_tmp, checkpoint_path)
+
+            segment = {
+                "index": index,
+                "id": str(source.get("id") or "clip_%04d" % index),
+                "revision": transaction,
+                "created_at": datetime.now(timezone.utc).isoformat(
+                    timespec="seconds").replace("+00:00", "Z"),
+                "segment": chain._relative_output_path(segment_path),
+                "checkpoint": chain._relative_output_path(checkpoint_path),
+                "metadata": chain._relative_output_path(paths["metadata"]),
+                "revision_metadata": chain._relative_output_path(metadata_path),
+                "prompt_file": chain._relative_output_path(prompt_path),
+                "raw_frames": raw,
+                "delivered_frames": delivered,
+                "trim_frames": trim,
+                "width": width,
+                "height": height,
+                "sample_rate": sample_rate,
+                "audio_route": audio_route,
+                "latent_saved": save_latent,
+                "latent_layout": latent_layout,
+                "context_steps": context_steps,
+                "source_revision": str(source.get("revision") or ""),
+                "source_checkpoint": str(source.get("checkpoint") or ""),
+                "source_checkpoint_sha256": str(
+                    source.get("checkpoint_sha256") or ""),
+                "source_segment_sha256": str(source.get("segment_sha256") or ""),
+                "prompt_prefix": str(source.get("prompt_prefix") or ""),
+                "scene_prompt": str(source.get("scene_prompt") or ""),
+                "prompt": str(source.get("prompt") or ""),
+                "prompt_hash": str(source.get("prompt_hash") or ""),
+                "seed": source.get("seed"),
+                "steps": source.get("steps"),
+                "segment_sha256": chain._file_sha256(segment_path),
+                "checkpoint_sha256": chain._file_sha256(checkpoint_path),
+                "prompt_file_sha256": chain._file_sha256(prompt_path),
+            }
+            if audio_path is not None:
+                segment.update({
+                    "generated_audio": chain._relative_output_path(audio_path),
+                    "generated_audio_sha256": chain._file_sha256(audio_path),
+                })
+            previous = None
+            if os.path.isfile(paths["metadata"]):
+                try:
+                    previous = chain._read_json(paths["metadata"])
+                except (OSError, ValueError, json.JSONDecodeError):
+                    previous = None
+            old_segment = previous.get("segment") if isinstance(previous, dict) else None
+            if isinstance(old_segment, dict):
+                segment["supersedes"] = old_segment.get("revision_metadata")
+            metadata = {
+                "format": "h3_chain_upscale_segment_v1",
+                "run_name": state["run_name"],
+                "profile": state["profile"],
+                "source_manifest_hash": state["source_manifest_hash"],
+                "source_scene_contract": _upscale_source_contract(source),
+                "profile_config_hash": state["profile_config"]["config_hash"],
+                "profile_config": state["profile_config"],
+                "segment": segment,
+            }
+            from .checkpoint_variants import processing_lineage
+            metadata["processing_lineage"] = processing_lineage(
+                list(state.get("segments", [])) + [segment])
+            prefix = list(state.get("segments", [])) + [segment]
+            complete = (index == _source_bounds(state["source_manifest"])[1])
+            partial = _upscale_manifest(state, prefix, complete=complete)
+            from .processing_checkpoint_delete import require_saved_processing_segments
+            from . import processing_persistence as persistence
+            # Media must reach storage before any durable document references it.
+            artifacts = [segment_path, checkpoint_path, prompt_path]
+            if audio_path:
+                artifacts.append(audio_path)
+            for artifact in artifacts:
+                persistence.sync_file(artifact)
+            for directory in {os.path.dirname(p) for p in artifacts}:
+                persistence.sync_directory(directory)
+            with chain.checkpoint_run_lock(chain._output_root(), state["run_name"]):
+                require_saved_processing_segments(chain._output_root(),
+                    list(state.get("segments", [])) + [item for item in
+                        state["source_manifest"]["segments"] if item.get("processing_source")])
+                # Once publication starts, a network error can mean "committed
+                # but acknowledgement lost". Never remove media that an immutable
+                # revision or current pointer may already reference.
+                publication_started = True
+                persistence.atomic_json(metadata_path, metadata)
+                persistence.atomic_json(paths["metadata"], metadata)
+                committed = True
+                try:
+                    persistence.atomic_json(
+                        paths["manifest"] if complete else paths["partial"], partial)
+                except OSError as exc:
+                    save_warning = "; scene saved; manifest refresh failed (resume from scene checkpoints)"
+                    chain._LOG.warning("H3 upscale scene %d is saved, but its manifest refresh failed: %s", index, exc)
+        finally:
+            chain._safe_unlink(checkpoint_tmp)
+            if publication_started and not committed:
+                chain._LOG.warning(
+                    "H3 upscale scene %d publication was interrupted or uncertain; "
+                    "new media was retained at %s. The previous take was not deleted.", index, segment_path)
+            if not committed and not publication_started:
+                for value in (segment_path, checkpoint_path, metadata_path,
+                              prompt_path, audio_path):
+                    if value:
+                        chain._safe_unlink(value)
+
+        cache_cleanup = chain.confirm_saved_use(
+            dynprompt, unique_id, metadata_path, chain._output_root(), chain._LOG)
+        status = ("saved HQ scene %d/%d at %dx%d; latent %s -> %s" %
+                  (index, _source_bounds(state["source_manifest"])[1], width,
+                   height, "saved" if save_latent else "omitted", segment_path))
+        status += save_warning
+        if audio_route != "none":
+            status += "; %s" % audio_route
+        if context_steps:
+            status += "; retained %d-step Drift-Control HQ tail" % context_steps
+        if cache_cleanup:
+            status += "; retired %d verified legacy reference bundle(s)" % len(cache_cleanup)
+        return {
+            "ui": {"text": [status],
+                   "images": [chain._video_output_item(segment_path)],
+                   "animated": (True,)},
+            "result": (segment, status),
+        }
+
+
+class MiniMaxH3ChainUpscaleLoopEnd:
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "flow": (UPSCALE_FLOW_TYPE, {
+                    "rawLink": True,
+                    "lazy": True,
+                    "tooltip": "Connect directly from Upscale Adapter; this raw "
+                               "link defines the recursive child-loop body."}),
+                "state": (UPSCALE_STATE_TYPE, {
+                    "lazy": True,
+                    "tooltip": "Current child-run state from Upscale Current Scene."}),
+                "images": ("IMAGE", {
+                    "lazy": True,
+                    "tooltip": "Same RAW HQ frames sent to Upscale Segment Save."}),
+                "segment": (UPSCALE_SEGMENT_TYPE, {
+                    "lazy": True,
+                    "tooltip": "Persisted HQ scene record from Upscale Segment Save."}),
+            },
+            "optional": {
+                "upscaled_latent": ("LATENT", {
+                    "lazy": True,
+                    "tooltip": "Optional transient HQ carry for the next scene. "
+                               "It is independent of save_latent."}),
+            },
+            "hidden": {"dynprompt": "DYNPROMPT", "unique_id": "UNIQUE_ID"},
+        }
+
+    RETURN_TYPES = (UPSCALE_MANIFEST_TYPE, "STRING", "IMAGE", "LATENT")
+    RETURN_NAMES = ("manifest", "manifest_json", "last_context_frames",
+                    "last_context_latent")
+    OUTPUT_TOOLTIPS = (
+        "Complete verified child manifest for H3 Chain Assemble, or a partial manifest.",
+        "Readable JSON form of the emitted child manifest.",
+        "Delivered HQ tail retained from the last processed scene.",
+        "Transient HQ latent retained from the last processed scene, if connected.",
+    )
+    FUNCTION = "end"
+    CATEGORY = "conditioning/minimax/context_loop/upscale"
+    DESCRIPTION = ("Advance the child upscale graph scene by scene and emit a "
+                   "mergeable manifest after the selected range completes.")
+
+    def _explore_dependencies(self, node_id, dynprompt, upstream, parent_ids):
+        node_info = dynprompt.get_node(node_id)
+        for value in node_info.get("inputs", {}).values():
+            if not chain.is_link(value):
+                continue
+            parent_id = value[0]
+            display_id = dynprompt.get_display_node_id(parent_id)
+            display_node = dynprompt.get_node(display_id)
+            if display_node["class_type"] != "MiniMaxH3ChainUpscaleLoopEnd":
+                parent_ids.append(display_id)
+            if parent_id not in upstream:
+                upstream[parent_id] = []
+                self._explore_dependencies(parent_id, dynprompt, upstream, parent_ids)
+            upstream[parent_id].append(node_id)
+
+    def _explore_output_nodes(self, dynprompt, upstream, parent_ids):
+        try:
+            import nodes as comfy_nodes
+            mappings = comfy_nodes.NODE_CLASS_MAPPINGS
+        except Exception:
+            return
+        output_nodes = {}
+        for node_id, node in dynprompt.get_original_prompt().items():
+            class_def = mappings.get(node.get("class_type"))
+            if not class_def or not getattr(class_def, "OUTPUT_NODE", False):
+                continue
+            for value in node.get("inputs", {}).values():
+                if chain.is_link(value):
+                    output_nodes[node_id] = value
+        for parent_id in list(upstream):
+            display_id = dynprompt.get_display_node_id(parent_id)
+            for output_id, link in output_nodes.items():
+                linked_id = link[0]
+                if (linked_id in parent_ids and display_id == linked_id and
+                        output_id not in upstream[parent_id]):
+                    if "." in parent_id:
+                        parts = parent_id.split(".")
+                        parts[-1] = output_id
+                        upstream[parent_id].append(".".join(parts))
+                    else:
+                        upstream[parent_id].append(output_id)
+
+    def _collect_contained(self, node_id, upstream, contained):
+        for child_id in upstream.get(node_id, []):
+            if child_id in contained:
+                continue
+            contained[child_id] = True
+            self._collect_contained(child_id, upstream, contained)
+
+    def _recurse(self, flow, next_state, dynprompt, unique_id):
+        if chain.GraphBuilder is None:
+            raise RuntimeError("H3 Upscale Loop requires ComfyUI GraphBuilder.")
+        unique_id = str(unique_id)
+        upstream, parent_ids = {}, []
+        self._explore_dependencies(unique_id, dynprompt, upstream, parent_ids)
+        parent_ids = list(set(parent_ids))
+        self._explore_output_nodes(dynprompt, upstream, parent_ids)
+        open_node = str(flow[0])
+        start_info = dynprompt.get_node(open_node)
+        if start_info["class_type"] != "MiniMaxH3ChainUpscaleAdapter":
+            raise ValueError("Upscale Loop End flow must connect directly to Upscale Adapter.")
+        contained = {unique_id: True, open_node: True}
+        self._collect_contained(open_node, upstream, contained)
+        graph = chain.GraphBuilder()
+        for node_id in contained:
+            original = dynprompt.get_node(node_id)
+            clone_id = "Recurse" if node_id == unique_id else node_id
+            node = graph.node(original["class_type"], clone_id)
+            node.set_override_display_id(node_id)
+        for node_id in contained:
+            original = dynprompt.get_node(node_id)
+            clone_id = "Recurse" if node_id == unique_id else node_id
+            node = graph.lookup_node(clone_id)
+            for key, value in original.get("inputs", {}).items():
+                if chain.is_link(value) and value[0] in contained:
+                    parent = graph.lookup_node(value[0])
+                    node.set_input(key, parent.out(value[1]))
+                else:
+                    node.set_input(key, value)
+        graph.lookup_node(open_node).set_input("initial_state", next_state)
+        # Recurse with the already verified immutable document rather than the
+        # external manager link; the manager browser is bootstrap-only.
+        graph.lookup_node(open_node).set_input(
+            "source_manifest", next_state["source_manifest"])
+        recurse = graph.lookup_node("Recurse")
+        return {"result": tuple(recurse.out(index)
+                                for index in range(len(self.RETURN_TYPES))),
+                "expand": graph.finalize()}
+
+    def _prepare_next_state(self, state, images, segment, upscaled_latent=None):
+        index = int(state["index"])
+        if int(segment.get("index", -1)) != index:
+            raise ValueError("Upscale Loop End received the wrong scene segment.")
+        source = _source_segment(state)
+        raw = int(source["raw_frames"])
+        delivered = int(source["delivered_frames"])
+        trim = raw - delivered
+        if int(images.shape[0]) != raw:
+            raise ValueError("Upscale Loop End expected %d RAW frames." % raw)
+        delivered_images = images[trim:trim + delivered]
+        context_length = min(
+            int(state["source_manifest"].get("compatibility", {}).get(
+                "context_length", 0)), delivered)
+        next_state = dict(state)
+        next_state.update({
+            "index": index + 1,
+            "segments": list(state.get("segments", [])) +
+                        [_public_upscale_segment(segment)],
+            "previous_frames": chain._tensor_cpu_clone(
+                delivered_images[-context_length:]) if context_length else
+                chain._tensor_cpu_clone(delivered_images[:0]),
+            "previous_latent": _cpu_latent(upscaled_latent),
+            "previous_context_status": (
+                "live previous HQ latent" if upscaled_latent is not None
+                else "previous HQ latent unavailable"),
+        })
+        return next_state
+
+    def _advance(self, flow, next_state, dynprompt=None, unique_id=None):
+        index = int(next_state["index"]) - 1
+        state = {**next_state, "index": index}
+        if index < int(state["end_clip"]):
+            return self._recurse(flow, next_state, dynprompt, unique_id)
+        complete = index == _source_bounds(state["source_manifest"])[1]
+        manifest = _upscale_manifest(state, next_state["segments"], complete)
+        paths = _state_profile_paths(state, index)
+        from .processing_checkpoint_delete import require_saved_processing_segments
+        from .processing_persistence import atomic_json
+        with chain.checkpoint_run_lock(chain._output_root(), state["run_name"]):
+            require_saved_processing_segments(chain._output_root(),
+                next_state["segments"] + [item for item in
+                    state["source_manifest"]["segments"] if item.get("processing_source")])
+            atomic_json(paths["manifest"] if complete else paths["partial"], manifest)
+        manifest_json = json.dumps(manifest, ensure_ascii=False, indent=2,
+                                   sort_keys=True)
+        return (manifest, manifest_json, next_state["previous_frames"],
+                next_state["previous_latent"])
+
+
+    def end(self, flow, state, images, segment, upscaled_latent=None,
+            dynprompt=None, unique_id=None):
+        if dynprompt is None or unique_id is None:
+            # Preserve direct Python callers; graph execution uses the lazy
+            # boundary below so the pending node never owns RGB/latent inputs.
+            return self._advance(flow, self._prepare_next_state(
+                state, images, segment, upscaled_latent), dynprompt, unique_id)
+        graph = chain.GraphBuilder()
+        inputs = dynprompt.get_node(str(unique_id))["inputs"]
+        prepare = graph.node("MiniMaxH3ChainUpscaleHandoff", "Handoff")
+        for name in ("state", "images", "segment", "upscaled_latent"):
+            if name in inputs:
+                prepare.set_input(name, inputs[name])
+        advance = graph.node("MiniMaxH3ChainUpscaleAdvance", "Advance",
+                             next_state=prepare.out(0),
+                             loop_id=str(unique_id))
+        return {"result": tuple(advance.out(i) for i in range(len(self.RETURN_TYPES))),
+                "expand": graph.finalize()}
+
+
+class MiniMaxH3ChainUpscaleHandoff:
+    """Finish the tensor-consuming step BEFORE starting the next subgraph."""
+    @classmethod
+    def INPUT_TYPES(cls):
+        schema = MiniMaxH3ChainUpscaleLoopEnd.INPUT_TYPES()
+        schema.pop("hidden")
+        schema["required"].pop("flow")
+        for group in schema.values():
+            for _kind, options in group.values():
+                options.pop("lazy", None)
+        return schema
+
+    RETURN_TYPES = (UPSCALE_STATE_TYPE,)
+    OUTPUT_TOOLTIPS = ("Small continuation state after completed scene pixels are released.",)
+    FUNCTION = "prepare"
+    CATEGORY = "_internal/minimax/upscale"
+    DESCRIPTION = "Internal tensor-to-context handoff for Upscale Loop End."
+
+    def prepare(self, state, images, segment, upscaled_latent=None):
+        return (MiniMaxH3ChainUpscaleLoopEnd()._prepare_next_state(
+            state, images, segment, upscaled_latent),)
+
+
+class MiniMaxH3ChainUpscaleAdvance:
+    """Only the small handoff remains an input while recursion is pending."""
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {"required": {"next_state": (UPSCALE_STATE_TYPE, {
+                                 "tooltip": "Prepared state for the next upscale scene."}),
+                             "loop_id": ("STRING", {
+                                 "tooltip": "Originating Upscale Loop End node id."})},
+                "hidden": {"dynprompt": "DYNPROMPT"}}
+
+    RETURN_TYPES = MiniMaxH3ChainUpscaleLoopEnd.RETURN_TYPES
+    OUTPUT_TOOLTIPS = MiniMaxH3ChainUpscaleLoopEnd.OUTPUT_TOOLTIPS
+    FUNCTION = "advance"
+    CATEGORY = "_internal/minimax/upscale"
+    DESCRIPTION = "Internal continuation for Upscale Loop End; no full pixel input."
+
+    def advance(self, next_state, loop_id, dynprompt):
+        flow = dynprompt.get_node(loop_id)["inputs"]["flow"]
+        return MiniMaxH3ChainUpscaleLoopEnd()._advance(
+            flow, next_state, dynprompt, loop_id)
+
+
+def _validate_upscale_manifest(manifest: dict[str, Any]) -> list[dict[str, Any]]:
+    if manifest.get("format") != "h3_chain_upscale_manifest_v1":
+        raise ValueError("H3 Chain Assemble requires a complete upscale manifest.")
+    segments = manifest.get("segments") or []
+    count = int(manifest.get("clip_count", 0))
+    if count < 1 or len(segments) != count:
+        raise ValueError("Upscale manifest contains %d/%d scenes." %
+                         (len(segments), count))
+    total = 0
+    source = manifest.get("source_manifest") or {}
+    first, last = _source_bounds(source)
+    if count != last - first + 1:
+        raise ValueError("Upscale manifest does not cover its selected source scenes.")
+    if (int(manifest.get("scene_start", first)) != first or
+            int(manifest.get("scene_end", last)) != last):
+        raise ValueError("Upscale manifest scene bounds do not match its source.")
+    for index, segment in enumerate(segments, start=first):
+        _verify_upscale_segment(segment, index)
+        total += int(segment.get("delivered_frames", 0))
+    if total != int(manifest.get("total_delivered_frames", -1)):
+        raise ValueError("Upscale manifest delivered-frame total is inconsistent.")
+    return segments
+
+
+def _assembly_manifest(manifest: dict[str, Any],
+                       segments: list[dict[str, Any]]) -> dict[str, Any]:
+    source = manifest.get("source_manifest")
+    if not isinstance(source, dict):
+        raise ValueError("Upscale manifest has no embedded source manifest.")
+    compatibility = dict(source.get("compatibility") or {})
+    compatibility["video_blend_frames"] = 0
+    compatibility["segment_crf"] = int(
+        manifest["profile_config"].get("segment_crf", 18))
+    # Child output dimensions are pixels, not the H3 source latent grid (a
+    # custom image backend may legitimately deliver e.g. 1920x1080).
+    sizes = {(int(item.get("width", 0)), int(item.get("height", 0)))
+             for item in segments}
+    if len(sizes) != 1 or min(next(iter(sizes), (0, 0))) < 1:
+        raise ValueError("Upscaled scenes must have one valid output resolution before assembly.")
+    width, height = next(iter(sizes))
+    resolution = {"width": width, "height": height}
+    compatibility.update(resolution)
+    assembled = []
+    for item in segments:
+        assembled.append({
+            **item,
+            "blend_frames": 0,
+        })
+    assembly = {
+        "format": "h3_chain_manifest_v3",
+        "run_name": manifest["run_name"],
+        "plan_hash": source.get("plan_hash"),
+        "prompt_prefix": source.get("prompt_prefix", ""),
+        "compatibility": compatibility,
+        "clip_count": len(assembled),
+        "total_delivered_frames": int(manifest["total_delivered_frames"]),
+        "duration_seconds": float(manifest["duration_seconds"]),
+        "segments": assembled,
+        "archives": source.get("archives", {}),
+        "upscale": {
+            "profile": manifest["profile"],
+            "source_manifest_hash": manifest["source_manifest_hash"],
+            "profile_config": manifest["profile_config"],
+        },
+    }
+    if isinstance(source.get("source_timeline"), dict):
+        assembly["source_timeline"] = chain._json_document(
+            source["source_timeline"])
+    if source.get("chapter"):
+        assembly["format"] = chain.CHAPTER_MANIFEST_FORMAT
+        for key in ("chapter", "scene_start", "scene_end", "source_scene_count", "editorial"):
+            if key in source:
+                assembly[key] = (chain._json_document(source[key])
+                                 if isinstance(source[key], dict) else source[key])
+        assembly["chapter"]["resolution"] = resolution
+    if source.get("presentation_source"):
+        # ALT pictures have already been baked into HQ. Keep the frozen cut's
+        # timing but never substitute low-resolution alternates during assembly.
+        assembly["editorial"] = {**chain._json_document(source["editorial"]), "replacements": []}
+    return assembly
+
+
+def _write_upscale_final_record(manifest: dict[str, Any],
+                                final_path: str) -> None:
+    """Publish the child-profile provenance beside a unified assembly."""
+    generated_sidecar = os.path.splitext(final_path)[0] + ".generated.wav"
+    record = {
+        "format": "h3_chain_upscale_final_v1",
+        "run_name": manifest["run_name"],
+        "profile": manifest["profile"],
+        "profile_config": manifest["profile_config"],
+        "source_manifest_hash": manifest["source_manifest_hash"],
+        "video": chain._relative_output_path(final_path),
+        "video_sha256": chain._file_sha256(final_path),
+        "frame_count": int(manifest["total_delivered_frames"]),
+        "created_at": datetime.now(timezone.utc).isoformat(
+            timespec="seconds").replace("+00:00", "Z"),
+    }
+    if os.path.isfile(generated_sidecar):
+        record.update({
+            "generated_audio": chain._relative_output_path(
+                generated_sidecar),
+            "generated_audio_sha256": chain._file_sha256(
+                generated_sidecar),
+        })
+    chain._atomic_json(os.path.splitext(final_path)[0] + ".json", record)
+
+
+class MiniMaxH3ChainUpscaleMerge:
+    DEPRECATED = True
+
+    @classmethod
+    def INPUT_TYPES(cls):
+        return {
+            "required": {
+                "manifest": (chain.MANIFEST_TYPE, {
+                    "tooltip": "Legacy compatibility input. New workflows "
+                               "connect this manifest directly to H3 Chain "
+                               "Assemble."}),
+                "audio_source": (["plan", "source", "generated", "none"],
+                                 {"default": "plan",
+                                  "tooltip": "Final audio policy. plan follows the "
+                                             "parent chain's configured mode."}),
+                "filename": ("STRING", {
+                    "default": "final",
+                    "tooltip": "Final MP4 basename; collisions are versioned."}),
+                "audio_bitrate": ("INT", {
+                    "default": 256, "min": 64, "max": 512,
+                    "tooltip": "AAC bitrate in kbps when audio is muxed."}),
+            },
+            "optional": {
+                "source_audio": ("AUDIO", {
+                    "tooltip": "Original full source track when audio_source "
+                               "resolves to source."}),
+                "source_timeline": (chain.SOURCE_TIMELINE_TYPE, {
+                    "tooltip": "Optional 0.5 Source Timeline. Usually the "
+                               "parent manifest's recovery descriptor is enough."}),
+            },
+        }
+
+    RETURN_TYPES = ("STRING",)
+    RETURN_NAMES = ("video_path",)
+    OUTPUT_TOOLTIPS = (
+        "Absolute path of the verified merged HQ MP4 under the child profile.",
+    )
+    FUNCTION = "merge"
+    OUTPUT_NODE = True
+    CATEGORY = "conditioning/minimax/context_loop/upscale"
+    DESCRIPTION = ("Deprecated compatibility wrapper. New workflows connect "
+                   "Upscale Loop End directly to H3 Chain Assemble.")
+
+    @classmethod
+    def IS_CHANGED(cls, *args, **kwargs):
+        return float("NaN")
+
+    def merge(self, manifest, audio_source, filename, audio_bitrate,
+              source_audio=None, source_timeline=None):
+        return chain.MiniMaxH3ChainAssemble().assemble(
+            manifest, audio_source, filename, audio_bitrate,
+            source_audio=source_audio, source_timeline=source_timeline)
+
+
+UPSCALE_NODE_CLASS_MAPPINGS = {
+    "MiniMaxH3ChainUpscalePixelCurrent": MiniMaxH3ChainUpscalePixelCurrent,
+    "MiniMaxH3ChainUpscalePixelConditioning": MiniMaxH3ChainUpscalePixelConditioning,
+    "MiniMaxH3ChainUpscaleAdapter": MiniMaxH3ChainUpscaleAdapter,
+    "MiniMaxH3ChainUpscaleCurrent": MiniMaxH3ChainUpscaleCurrent,
+    "MiniMaxH3ChainDeropeGuard": MiniMaxH3ChainDeropeGuard,
+    "MiniMaxH3ChainDeropeFreezeMask": MiniMaxH3ChainDeropeFreezeMask,
+    "MiniMaxH3ChainDeropeContinuity": MiniMaxH3ChainDeropeContinuity,
+    "MiniMaxH3ChainRecoveredAV": MiniMaxH3ChainRecoveredAV,
+    "MiniMaxH3UpscaleReferencePromptOverride": (
+        MiniMaxH3UpscaleReferencePromptOverride),
+    "MiniMaxH3ChainUpscaleReferenceConditioning": (
+        MiniMaxH3ChainUpscaleReferenceConditioning),
+    "H3ConditioningSyncFromLatents": H3ConditioningSyncFromLatents,
+    "MiniMaxH3ChainPass2Prepare": MiniMaxH3ChainPass2Prepare,
+    "MiniMaxH3ChainUpscaleSegmentSave": MiniMaxH3ChainUpscaleSegmentSave,
+    "MiniMaxH3ChainUpscaleLoopEnd": MiniMaxH3ChainUpscaleLoopEnd,
+    "MiniMaxH3ChainUpscaleHandoff": MiniMaxH3ChainUpscaleHandoff,
+    "MiniMaxH3ChainUpscaleAdvance": MiniMaxH3ChainUpscaleAdvance,
+    "MiniMaxH3ChainUpscaleMerge": MiniMaxH3ChainUpscaleMerge,
+}
+
+UPSCALE_NODE_DISPLAY_NAME_MAPPINGS = {
+    "MiniMaxH3ChainUpscalePixelCurrent": "MiniMax H3 Pixel Upscale Current Scene (Experimental)",
+    "MiniMaxH3ChainUpscalePixelConditioning": "MiniMax H3 Pixel Upscale Conditioning (Experimental)",
+    "MiniMaxH3ChainUpscaleAdapter": "MiniMax H3 Checkpoint Upscale Adapter",
+    "MiniMaxH3ChainUpscaleCurrent": "MiniMax H3 Upscale Current Scene",
+    "MiniMaxH3ChainDeropeGuard": "MiniMax H3 Chain De-Rope Guard",
+    "MiniMaxH3ChainDeropeFreezeMask": (
+        "MiniMax H3 Chain De-Rope Freeze Mask"),
+    "MiniMaxH3ChainDeropeContinuity": (
+        "MiniMax H3 Chain De-Rope Continuity"),
+    "MiniMaxH3ChainRecoveredAV": "MiniMax H3 Chain Recovered AV",
+    "MiniMaxH3UpscaleReferencePromptOverride": (
+        "MiniMax H3 Upscale Reference + Prompt Override"),
+    "MiniMaxH3ChainUpscaleReferenceConditioning": (
+        "MiniMax H3 Upscale Reference Conditioning"),
+    "H3ConditioningSyncFromLatents": "H3 Conditioning Sync From Latents",
+    "MiniMaxH3ChainPass2Prepare": "MiniMax H3 Pass-2 AV Prepare",
+    "MiniMaxH3ChainUpscaleSegmentSave": "MiniMax H3 Upscale Segment Save",
+    "MiniMaxH3ChainUpscaleLoopEnd": "MiniMax H3 Upscale Loop End",
+    "MiniMaxH3ChainUpscaleMerge": "MiniMax H3 Upscale Merger (Legacy)",
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_cancel_reroll.js b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_cancel_reroll.js
new file mode 100644
index 0000000000000000000000000000000000000000..7417d7623ef149b2af0292f5a9beb1e299e7eb85
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_cancel_reroll.js
@@ -0,0 +1,436 @@
+import {app} from "/scripts/app.js";
+import {api} from "/scripts/api.js";
+import {parsePlanJson, planToJson, randomSceneSeed} from "./h3_chain_plan_core.mjs?v=0.6.5";
+import {
+    activeSceneFromOutput,
+    applySceneReroll,
+    resumeSelection,
+} from "./h3_chain_cancel_reroll_core.mjs?v=0.6.5";
+import {refreshRestoredPlanEditors} from "./h3_plan_restore_core.mjs?v=0.6.6";
+
+// The compact scene expands Current Shot internally. ComfyUI routes that
+// internal node's active-scene event to the compact node's display id.
+const CURRENT_TYPES = new Set([
+    "MiniMaxH3ChainCurrent",
+    "MiniMaxH3CurrentTaggedReferenceScene",
+]);
+const PLAN_TYPE = "MiniMaxH3ChainPlan";
+const PLAN_TYPES = new Set([PLAN_TYPE, "MiniMaxH3ChainPlanModern"]);
+const START_TYPE = "MiniMaxH3ChainLoopStart";
+const SETTING_ID = "MiniMaxH3ContexLoop.cancelRerollControl";
+const GENERATION_FINISHED_TYPES = new Set([
+    "MiniMaxH3ChainSegmentSave",
+    "MiniMaxH3ChainReview",
+    "MiniMaxH3ChainLoopEnd",
+]);
+
+let root = null;
+let actionButton = null;
+let status = null;
+let active = null;
+let busy = false;
+let controlAllowed = true;
+let wantsVisible = false;
+const interruptionWaiters = new Map();
+
+function nodeType(node) {
+    return node?.comfyClass ?? node?.type ?? null;
+}
+
+function findNodeByDisplayId(qid) {
+    if (!app.graph || qid == null) return null;
+    const parts = String(qid).split(":");
+    let graph = app.graph;
+    for (let index = 0; index < parts.length - 1; index += 1) {
+        const id = Number(parts[index]);
+        const parent = Number.isFinite(id) ? graph?.getNodeById?.(id) : null;
+        if (!parent?.subgraph) return null;
+        graph = parent.subgraph;
+    }
+    const leaf = Number(parts.at(-1));
+    return Number.isFinite(leaf) ? graph?.getNodeById?.(leaf) ?? null : null;
+}
+
+function activeWorkflowIdentity() {
+    const workflow = app.extensionManager?.workflow?.activeWorkflow;
+    const value = workflow?.path
+        ?? workflow?.activeState?.id
+        ?? workflow?.filename
+        ?? null;
+    if (value == null || String(value).trim() === "") return null;
+    return String(value);
+}
+
+function findUpstreamNode(start, wantedType) {
+    const queue = [start];
+    const seen = new Set();
+    while (queue.length) {
+        const node = queue.shift();
+        if (!node || seen.has(node)) continue;
+        seen.add(node);
+        const matches = wantedType instanceof Set
+            ? wantedType.has(nodeType(node)) : nodeType(node) === wantedType;
+        if (node !== start && matches) return node;
+        for (const input of node.inputs ?? []) {
+            if (input.link == null) continue;
+            const link = node.graph?.links?.[input.link];
+            const parent = link ? node.graph?.getNodeById?.(link.origin_id) : null;
+            if (parent) queue.push(parent);
+        }
+    }
+    return null;
+}
+
+function widgetByName(node, name) {
+    return node?.widgets?.find((item) => item.name === name);
+}
+
+function injectStyles() {
+    if (document.getElementById("h3-chain-cancel-reroll-style")) return;
+    const style = document.createElement("style");
+    style.id = "h3-chain-cancel-reroll-style";
+    style.textContent = `
+        .h3cr-root { position:fixed; right:18px; bottom:76px; z-index:10020;
+            display:flex; flex-direction:column; align-items:flex-end; gap:5px;
+            max-width:min(390px,calc(100vw - 36px)); pointer-events:auto;
+            font:12px/1.35 system-ui,sans-serif; }
+        .h3cr-root[hidden] { display:none; }
+        .h3cr-button { display:flex; align-items:center; gap:7px; padding:9px 13px;
+            border:1px solid #c77b4e; border-radius:999px; background:#44281e;
+            color:#fff4ed; box-shadow:0 4px 18px #0009; cursor:pointer; font-weight:700; }
+        .h3cr-button:hover { background:#573225; }
+        .h3cr-button:disabled { opacity:.58; cursor:wait; }
+        .h3cr-icon { width:16px; height:16px; fill:none; stroke:currentColor;
+            stroke-width:1.8; stroke-linecap:round; stroke-linejoin:round; }
+        .h3cr-status { padding:5px 9px; border:1px solid #4a4f5d; border-radius:7px;
+            background:#181a20ee; color:#d9dce5; box-shadow:0 3px 12px #0008;
+            box-sizing:border-box; max-width:100%; min-width:0;
+            text-align:right; white-space:pre-wrap; overflow-wrap:anywhere; }
+        .h3cr-status:empty { display:none; }
+        .h3cr-error { color:#ffd0bc; border-color:#a86148; }
+    `;
+    document.head.appendChild(style);
+}
+
+function rerollIcon() {
+    const namespace = "http://www.w3.org/2000/svg";
+    const svg = document.createElementNS(namespace, "svg");
+    svg.classList.add("h3cr-icon");
+    svg.setAttribute("viewBox", "0 0 24 24");
+    svg.setAttribute("aria-hidden", "true");
+    const path = document.createElementNS(namespace, "path");
+    path.setAttribute("d", "M20 7v5h-5M4 17v-5h5M6.1 8.2A7 7 0 0 1 18.7 7M17.9 15.8A7 7 0 0 1 5.3 17");
+    svg.append(path);
+    return svg;
+}
+
+function ensureControl() {
+    if (root) return;
+    injectStyles();
+    root = document.createElement("div");
+    root.className = "h3cr-root";
+    root.hidden = true;
+    actionButton = document.createElement("button");
+    actionButton.type = "button";
+    actionButton.className = "h3cr-button";
+    actionButton.title = "Cancel only this H3 prompt, assign a new scene seed, resume from the preceding checkpoint, and queue it again.";
+    actionButton.append(rerollIcon(), document.createElement("span"));
+    status = document.createElement("div");
+    status.className = "h3cr-status";
+    status.setAttribute("role", "status");
+    status.setAttribute("aria-live", "polite");
+    root.append(actionButton, status);
+    document.body.append(root);
+    actionButton.addEventListener("click", (event) => {
+        event.preventDefault();
+        event.stopPropagation();
+        void cancelAndReroll();
+    });
+}
+
+function settingEnabled() {
+    return app.ui?.settings?.getSettingValue?.(SETTING_ID) !== false;
+}
+
+function setControlAllowed(value) {
+    controlAllowed = value !== false;
+    if (root) root.hidden = !controlAllowed || !wantsVisible;
+}
+
+function setControlVisible(value) {
+    wantsVisible = Boolean(value);
+    if (root) root.hidden = !controlAllowed || !wantsVisible;
+}
+
+function showActive(record) {
+    ensureControl();
+    active = record;
+    busy = false;
+    actionButton.disabled = false;
+    actionButton.lastElementChild.textContent =
+        `Cancel & reroll scene ${record.scene.clipIndex}`;
+    status.className = "h3cr-status";
+    status.textContent = `${record.scene.shotId} · current seed ${record.scene.seed}`;
+    setControlVisible(true);
+}
+
+function hideControl() {
+    active = null;
+    busy = false;
+    setControlVisible(false);
+}
+
+function showFailure(message, retryable = Boolean(active)) {
+    ensureControl();
+    busy = false;
+    actionButton.disabled = !retryable;
+    status.className = "h3cr-status h3cr-error";
+    status.textContent = String(message);
+    setControlVisible(true);
+}
+
+function waitForInterruption(promptId, timeoutMilliseconds = 30000) {
+    let timer;
+    const promise = new Promise((resolve, reject) => {
+        timer = window.setTimeout(() => {
+            interruptionWaiters.delete(promptId);
+            reject(new Error("ComfyUI did not confirm interruption within 30 seconds."));
+        }, timeoutMilliseconds);
+        interruptionWaiters.set(promptId, {
+            resolve: () => {
+                window.clearTimeout(timer);
+                interruptionWaiters.delete(promptId);
+                resolve();
+            },
+            reject: (message) => {
+                window.clearTimeout(timer);
+                interruptionWaiters.delete(promptId);
+                reject(new Error(message));
+            },
+        });
+    });
+    // Cancellation can race the HTTP response. Attach a handler immediately
+    // so a terminal websocket event cannot become a transient unhandled
+    // rejection before cancelAndReroll reaches `await waiter.promise`.
+    void promise.catch(() => {});
+    return {
+        promise,
+        cancel() {
+            window.clearTimeout(timer);
+            interruptionWaiters.delete(promptId);
+        },
+    };
+}
+
+async function verifyPredecessorCheckpoint(record) {
+    if (record.scene.clipIndex === 1) return;
+    const query = new URLSearchParams({run_name: record.scene.runName});
+    const response = await api.fetchApi(
+        `/minimax_h3_context_loop/checkpoints?${query.toString()}`,
+    );
+    const body = await response.json();
+    if (!response.ok) throw new Error(body.error || `HTTP ${response.status}`);
+    const predecessor = record.scene.clipIndex - 1;
+    const ready = (body.checkpoints ?? []).some((item) =>
+        item?.ready && Number(item.scene) === predecessor);
+    if (!ready) {
+        throw new Error(
+            `Cannot reroll scene ${record.scene.clipIndex}: checkpoint ${predecessor} is not ready.`,
+        );
+    }
+}
+
+function requireVisibleWorkflow(record) {
+    const workflowIdentity = activeWorkflowIdentity();
+    if (record.workflowIdentity && workflowIdentity
+        && workflowIdentity !== record.workflowIdentity) {
+        throw new Error("Return to the running H3 workflow before requeueing the scene.");
+    }
+    const currentNode = findNodeByDisplayId(record.displayNode);
+    if (!CURRENT_TYPES.has(nodeType(currentNode))) {
+        throw new Error("Return to the running H3 workflow before requeueing the scene.");
+    }
+    const startNode = findUpstreamNode(currentNode, START_TYPE);
+    const planNode = findUpstreamNode(currentNode, PLAN_TYPES);
+    const runName = String(widgetByName(planNode, "run_name")?.value ?? "").trim();
+    if (!startNode || !planNode
+        || (record.scene.runName && runName !== record.scene.runName)) {
+        throw new Error("Return to the running H3 workflow before requeueing the scene.");
+    }
+    // ComfyUI may reconstruct graph and node objects when workflow tabs change.
+    // Refresh the cached references after validating stable workflow, node-path,
+    // and run identities instead of requiring stale JavaScript object equality.
+    record.workflowIdentity ??= workflowIdentity;
+    record.currentNode = currentNode;
+    record.startNode = startNode;
+    record.planNode = planNode;
+    return {currentNode, startNode, planNode};
+}
+
+function updateWorkflowForReroll(record, seed) {
+    const {planNode, startNode} = requireVisibleWorkflow(record);
+    const planWidget = widgetByName(planNode, "plan_json");
+    const startWidget = widgetByName(startNode, "start_clip");
+    const rangeWidget = widgetByName(startNode, "scene_range");
+    if (!planWidget || !startWidget) {
+        throw new Error("The active Current Shot is not connected to an editable Plan and Loop Start.");
+    }
+    const plan = applySceneReroll(
+        parsePlanJson(String(planWidget.value ?? "")),
+        record.scene.clipIndex,
+        seed,
+    );
+    const resume = resumeSelection(
+        record.scene.clipIndex,
+        record.scene.endClip,
+        record.scene.clipCount,
+    );
+    const serialized = planToJson(plan);
+    planWidget.value = serialized;
+    planWidget.callback?.(serialized);
+    refreshRestoredPlanEditors(planNode);
+    startWidget.value = resume.startClip;
+    startWidget.callback?.(resume.startClip);
+    if (rangeWidget) {
+        rangeWidget.value = resume.sceneRange;
+        rangeWidget.callback?.(resume.sceneRange);
+    }
+    planNode.graph?.setDirtyCanvas?.(true, true);
+    startNode.graph?.setDirtyCanvas?.(true, true);
+}
+
+async function cancelAndReroll() {
+    if (!controlAllowed || !active || busy) return;
+    const record = active;
+    busy = true;
+    actionButton.disabled = true;
+    status.className = "h3cr-status";
+    status.textContent = `Checking checkpoint for scene ${record.scene.clipIndex}…`;
+    let waiter = null;
+    let rerollPrepared = false;
+    try {
+        if (!record.scene.runName) throw new Error("The active H3 run_name is empty.");
+        // A fixed overlay survives ComfyUI tab switches. Refuse before
+        // cancellation unless the graph that emitted this scene is still the
+        // visible graph; app.queuePrompt always serializes the visible graph.
+        requireVisibleWorkflow(record);
+        await verifyPredecessorCheckpoint(record);
+        let seed = randomSceneSeed();
+        while (seed === record.scene.seed) seed = randomSceneSeed();
+        status.textContent = `Cancelling scene ${record.scene.clipIndex}…`;
+        waiter = waitForInterruption(record.promptId);
+        const response = await api.fetchApi(
+            `/api/jobs/${encodeURIComponent(record.promptId)}/cancel`,
+            {method: "POST"},
+        );
+        let body = {};
+        try {
+            body = await response.json();
+        } catch (_error) {
+            // A proxy may replace an unsupported endpoint's JSON response.
+        }
+        if (!response.ok) {
+            throw new Error(body.error ||
+                `Targeted cancellation is unavailable (HTTP ${response.status}). Update ComfyUI.`);
+        }
+        if (!body.cancelled) {
+            active = null;
+            throw new Error("The scene finished before targeted cancellation; nothing was requeued.");
+        }
+        // The exact prompt accepted cancellation. Never offer another action
+        // against its now-terminal id, even if a proxy loses the websocket
+        // confirmation or the following Plan update needs manual recovery.
+        active = null;
+        status.textContent = "Waiting for ComfyUI to finish interrupting the scene…";
+        await waiter.promise;
+        waiter = null;
+        updateWorkflowForReroll(record, seed);
+        rerollPrepared = true;
+        status.textContent = `Queueing scene ${record.scene.clipIndex} with seed ${seed}…`;
+        await app.queuePrompt(0, 1);
+        busy = false;
+        actionButton.disabled = true;
+        status.textContent = `Scene ${record.scene.clipIndex} requeued with seed ${seed}.`;
+        window.setTimeout(() => {
+            if (!active && !busy) setControlVisible(false);
+        }, 5000);
+    } catch (error) {
+        waiter?.cancel();
+        const suffix = rerollPrepared
+            ? " The Plan and Loop Start are prepared; queue the workflow manually."
+            : "";
+        showFailure(`${error?.message || error}${suffix}`);
+    }
+}
+
+function onCurrentExecuted(data) {
+    const scene = activeSceneFromOutput(data?.output);
+    if (!scene || !data?.prompt_id || data?.display_node == null) return;
+    const currentNode = findNodeByDisplayId(data.display_node);
+    if (!CURRENT_TYPES.has(nodeType(currentNode))) return;
+    const startNode = findUpstreamNode(currentNode, START_TYPE);
+    const planNode = findUpstreamNode(currentNode, PLAN_TYPES);
+    if (!startNode || !planNode) return;
+    showActive({
+        promptId: String(data.prompt_id),
+        displayNode: String(data.display_node),
+        workflowIdentity: activeWorkflowIdentity(),
+        currentNode,
+        startNode,
+        planNode,
+        scene,
+    });
+}
+
+function onExecuting(data) {
+    if (!active || String(data?.prompt_id ?? "") !== active.promptId) return;
+    const node = findNodeByDisplayId(data?.display_node);
+    if (GENERATION_FINISHED_TYPES.has(nodeType(node))) hideControl();
+}
+
+function onTerminal(kind, data) {
+    const promptId = String(data?.prompt_id ?? "");
+    const waiter = interruptionWaiters.get(promptId);
+    if (waiter) {
+        if (kind === "interrupted") waiter.resolve();
+        else {
+            if (active?.promptId === promptId) active = null;
+            waiter.reject(
+                kind === "success"
+                    ? "The scene completed before cancellation; nothing was requeued."
+                    : "The H3 prompt ended before cancellation was confirmed.",
+            );
+        }
+    }
+    if (active?.promptId === promptId && !busy) hideControl();
+}
+
+app.registerExtension({
+    name: "minimax_h3_context_loop.cancel_reroll",
+    init() {
+        app.ui?.settings?.addSetting?.({
+            id: SETTING_ID,
+            category: ["MiniMax H3 Context Loop", "Interface", "Cancel & reroll"],
+            name: "Show floating Cancel & reroll control",
+            tooltip: "Show the guarded floating action while an H3 scene is sampling. Disabling it does not remove Review Gate retry or reroll controls.",
+            type: "boolean",
+            defaultValue: true,
+            onChange(value) {
+                setControlAllowed(value);
+            },
+        });
+        setControlAllowed(settingEnabled());
+    },
+    setup() {
+        ensureControl();
+        setControlAllowed(settingEnabled());
+        api.addEventListener("executed", (event) => onCurrentExecuted(event.detail));
+        api.addEventListener("executing", (event) => onExecuting(event.detail));
+        api.addEventListener("execution_interrupted", (event) =>
+            onTerminal("interrupted", event.detail));
+        api.addEventListener("execution_success", (event) =>
+            onTerminal("success", event.detail));
+        api.addEventListener("execution_error", (event) =>
+            onTerminal("error", event.detail));
+    },
+});
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_cancel_reroll_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_cancel_reroll_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..43879e8703831a2583285e4a53c05df835e47ca0
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_cancel_reroll_core.mjs
@@ -0,0 +1,64 @@
+import {MAX_SEED} from "./h3_chain_plan_core.mjs?v=0.6.5";
+
+function normalizedPositiveInteger(value, label) {
+    const number = Number(value);
+    if (!Number.isInteger(number) || number < 1) {
+        throw new Error(`${label} must be a positive integer.`);
+    }
+    return number;
+}
+
+export function applySceneReroll(plan, oneBasedIndex, seed) {
+    const scene = normalizedPositiveInteger(oneBasedIndex, "Scene index");
+    if (!Array.isArray(plan?.shots) || scene > plan.shots.length) {
+        throw new Error(`Scene ${scene} does not exist in the Plan.`);
+    }
+    let normalizedSeed;
+    try {
+        normalizedSeed = BigInt(String(seed));
+    } catch (_error) {
+        throw new Error("Reroll seed must be an unsigned 64-bit integer.");
+    }
+    if (normalizedSeed < 0n || normalizedSeed > MAX_SEED) {
+        throw new Error("Reroll seed is outside the unsigned 64-bit range.");
+    }
+    plan.shots[scene - 1].seed = normalizedSeed.toString();
+    return plan;
+}
+
+export function resumeSelection(oneBasedIndex, endClip, clipCount) {
+    const scene = normalizedPositiveInteger(oneBasedIndex, "Scene index");
+    const end = normalizedPositiveInteger(endClip, "Range end");
+    const total = normalizedPositiveInteger(clipCount, "Scene count");
+    if (scene > end || end > total) {
+        throw new Error(`Invalid reroll range ${scene}:${end} for ${total} scenes.`);
+    }
+    return {
+        startClip: scene,
+        sceneRange: end < total
+            ? scene === end ? String(scene) : `${scene}:${end}`
+            : "",
+    };
+}
+
+export function activeSceneFromOutput(output) {
+    const values = output?.h3_chain_active_scene;
+    const value = Array.isArray(values) ? values.at(-1) : null;
+    if (!value || typeof value !== "object") return null;
+    const clipIndex = Number(value.clip_index);
+    const clipCount = Number(value.clip_count);
+    const endClip = Number(value.end_clip ?? clipCount);
+    if (!Number.isInteger(clipIndex) || clipIndex < 1
+        || !Number.isInteger(clipCount) || clipCount < clipIndex
+        || !Number.isInteger(endClip) || endClip < clipIndex || endClip > clipCount) {
+        return null;
+    }
+    return {
+        runName: String(value.run_name ?? "").trim(),
+        clipIndex,
+        clipCount,
+        endClip,
+        shotId: String(value.shot_id ?? `scene_${clipIndex}`),
+        seed: String(value.seed ?? ""),
+    };
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_checkpoint_manager.js b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_checkpoint_manager.js
new file mode 100644
index 0000000000000000000000000000000000000000..d2f00e993e17058f67d60a444f363f28045dcb78
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_checkpoint_manager.js
@@ -0,0 +1,2064 @@
+import {app} from "/scripts/app.js";
+import {api} from "/scripts/api.js";
+import {
+    CHECKPOINT_STAGES,
+    checkpointStageVariants,
+    checkpointVariantLatentStatus,
+    checkpointBranchRows,
+    checkpointChapterBranchRows,
+    checkpointOutputBranchTip,
+    checkpointActivationMode,
+    checkpointDeletionTitle,
+    checkpointDependencyText,
+    checkpointRevisionKey,
+    checkpointRevisionLineage,
+    checkpointSelectionJson,
+    checkpointLocalSelection,
+    checkpointLocalSelectionJson,
+    checkpointDeropeSelectionJson,
+    checkpointOutputSelectionJson,
+    checkpointOutputSummary,
+    formatCheckpointBytes,
+    selectedCheckpointRevision,
+} from "./h3_checkpoint_manager_core.mjs?v=0.6.7";
+import {
+    parsePlanJson,
+    planToJson,
+    promptValueToText,
+} from "./h3_chain_plan_core.mjs?v=0.6.5";
+import {applyCheckpointRevisionSet} from "./h3_chain_review_core.mjs?v=0.6.5";
+import * as promptCompanionSync from "./h3_prompt_companion_sync.mjs?v=0.6.2";
+import {
+    refreshRestoredPlanEditors,
+    restoreConnectedPolicyInputs,
+} from "./h3_plan_restore_core.mjs?v=0.6.6";
+
+const NODE_NAME = "MiniMaxH3ChainCheckpointManager";
+const PLAN_NAME = "MiniMaxH3ChainPlan";
+const PLAN_NAMES = new Set([PLAN_NAME, "MiniMaxH3ChainPlanModern"]);
+const START_NAME = "MiniMaxH3ChainLoopStart";
+const RUN_PROPERTY = "h3_checkpoint_manager_run";
+const SCENE_PROPERTY = "h3_checkpoint_manager_scene";
+const REVISION_PROPERTY = "h3_checkpoint_manager_revision";
+const CHAPTER_PROPERTY = "h3_checkpoint_manager_chapter";
+const OUTPUT_SCOPE_PROPERTY = "h3_checkpoint_manager_output_scope";
+const STAGE_PROPERTY = "h3_checkpoint_manager_stage";
+const VARIANT_PROPERTY = "h3_checkpoint_manager_variant";
+const COLLAPSED_CHAPTERS_PROPERTY = "h3_checkpoint_manager_collapsed_chapters";
+const PREVIEW_HEIGHT_PROPERTY = "h3_checkpoint_manager_preview_height";
+const DEFAULT_PREVIEW_HEIGHT = 280;
+const MIN_PREVIEW_HEIGHT = 120;
+const MAX_PREVIEW_HEIGHT = 720;
+const SHARED_COLORS = ["#6ea8ff", "#58c99d", "#bd8cff", "#e8a84f", "#f07f8c", "#55bfd0"];
+
+function previewHeight(value) {
+    const number = Number(value);
+    return Number.isFinite(number)
+        ? Math.max(MIN_PREVIEW_HEIGHT, Math.min(MAX_PREVIEW_HEIGHT, Math.round(number)))
+        : DEFAULT_PREVIEW_HEIGHT;
+}
+
+function nodeType(node) {
+    return node?.comfyClass ?? node?.type ?? "";
+}
+
+function upstreamPlanNode(start) {
+    const queue = [start];
+    const seen = new Set();
+    while (queue.length) {
+        const current = queue.shift();
+        if (!current || seen.has(current)) continue;
+        seen.add(current);
+        if (current !== start && PLAN_NAMES.has(nodeType(current))) return current;
+        for (const input of current.inputs ?? []) {
+            if (input.link == null) continue;
+            const link = graphLink(current.graph, input.link);
+            const candidate = link
+                ? current.graph?.getNodeById?.(link.origin_id) : null;
+            if (candidate) queue.push(candidate);
+        }
+    }
+    return null;
+}
+
+function widget(node, name) {
+    return node?.widgets?.find((item) => item.name === name);
+}
+
+function graphLink(graph, linkId) {
+    return graph?.links?.[linkId] ?? graph?.links?.get?.(linkId) ?? null;
+}
+
+function connectedNode(start, wantedType) {
+    const queue = [start];
+    const seen = new Set();
+    while (queue.length) {
+        const current = queue.shift();
+        if (!current || seen.has(current)) continue;
+        seen.add(current);
+        if (current !== start && nodeType(current) === wantedType) return current;
+        for (const input of current.inputs ?? []) {
+            if (input.link == null) continue;
+            const link = graphLink(current.graph, input.link);
+            const candidate = link
+                ? current.graph?.getNodeById?.(link.origin_id) : null;
+            if (candidate) queue.push(candidate);
+        }
+        for (const output of current.outputs ?? []) {
+            for (const linkId of output.links ?? []) {
+                const link = graphLink(current.graph, linkId);
+                const candidate = link
+                    ? current.graph?.getNodeById?.(link.target_id) : null;
+                if (candidate) queue.push(candidate);
+            }
+        }
+    }
+    return null;
+}
+
+function publishCompanionPrompt(...args) {
+    return promptCompanionSync.publishCompanionPrompt?.(...args) ?? 0;
+}
+
+function element(tag, className = "", text = undefined) {
+    const item = document.createElement(tag);
+    if (className) item.className = className;
+    if (text !== undefined) item.textContent = text;
+    return item;
+}
+
+function button(label, title, action, className = "") {
+    const item = element("button", className, label);
+    item.type = "button";
+    item.title = title;
+    item.addEventListener("click", action);
+    return item;
+}
+
+function videoUrl(item) {
+    if (!item?.filename) return "";
+    const query = new URLSearchParams({
+        filename:item.filename,
+        subfolder:item.subfolder ?? "",
+        type:item.type ?? "output",
+    });
+    return api.apiURL(`/view?${query.toString()}`);
+}
+
+function localTime(value) {
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? String(value || "unknown") : date.toLocaleString();
+}
+
+function sharedColor(key) {
+    let hash = 0;
+    for (const character of String(key ?? "")) {
+        hash = ((hash * 31) + character.codePointAt(0)) >>> 0;
+    }
+    return SHARED_COLORS[hash % SHARED_COLORS.length];
+}
+
+async function jsonRequest(path, options = {}) {
+    const response = await api.fetchApi(path, options);
+    const payload = await response.json();
+    if (!response.ok) throw Object.assign(
+        new Error(payload.error || `HTTP ${response.status}`), {payload});
+    return payload;
+}
+
+function injectStyles() {
+    if (document.getElementById("h3-checkpoint-manager-style")) return;
+    const style = document.createElement("style");
+    style.id = "h3-checkpoint-manager-style";
+    style.textContent = `
+      .h3cm-root { --h3cm-bg:color-mix(in srgb,var(--comfy-menu-bg,#202124) 93%,#101827);
+        --h3cm-panel:var(--comfy-input-bg,#15171d); --h3cm-border:var(--border-color,#586174);
+        --h3cm-text:var(--input-text,#edf1f8); --h3cm-muted:color-mix(in srgb,var(--h3cm-text) 58%,transparent);
+        --h3cm-accent:color-mix(in srgb,var(--h3cm-text) 38%,#4f83ff);
+        --h3cm-chapter:color-mix(in srgb,var(--h3cm-text) 68%,#d99121);
+        --h3cm-danger:color-mix(in srgb,var(--h3cm-text) 40%,#d44747);
+        box-sizing:border-box; width:100%; height:100%; min-height:620px; display:flex; flex-direction:column;
+        gap:8px; overflow:hidden; padding:10px; border:1px solid var(--h3cm-border); border-radius:9px;
+        background:var(--h3cm-bg); color:var(--h3cm-text); font:12px/1.4 system-ui,sans-serif; }
+      .h3cm-root *, .h3cm-root *::before, .h3cm-root *::after { box-sizing:border-box; }
+      .h3cm-head,.h3cm-run-row,.h3cm-chapter-tabs,.h3cm-scenes,.h3cm-branch-head,.h3cm-branch-path,.h3cm-delete-actions {
+        display:flex; align-items:center; gap:6px; }
+      .h3cm-head { justify-content:space-between; }
+      .h3cm-title { font-size:15px; font-weight:760; color:var(--h3cm-accent); }
+      .h3cm-summary,.h3cm-status,.h3cm-muted { color:var(--h3cm-muted); }
+      .h3cm-root button,.h3cm-root select { min-height:30px; border:1px solid var(--h3cm-border);
+        border-radius:6px; background:var(--h3cm-panel); color:var(--h3cm-text); font:inherit; }
+      .h3cm-root button { padding:5px 8px; cursor:pointer; }
+      .h3cm-root button:hover,.h3cm-root button:focus-visible { border-color:var(--h3cm-accent); outline:none; }
+      .h3cm-root button:disabled { cursor:not-allowed; opacity:.45; }
+      .h3cm-run-select { flex:1; min-width:0; padding:5px 7px; }
+      .h3cm-run-delete { white-space:nowrap; color:var(--h3cm-danger) !important; }
+      .h3cm-output { display:flex; flex-wrap:wrap; align-items:center; gap:6px;
+        flex:0 0 auto; padding:7px; border:1px solid var(--h3cm-border); border-radius:7px; }
+      .h3cm-output-summary { flex:1 1 250px; overflow-wrap:anywhere; }
+      .h3cm-local-label { color:var(--h3cm-accent) !important; font-weight:700; }
+      .h3cm-scenes { flex:0 0 auto; overflow:auto; padding-bottom:2px; }
+      .h3cm-stage-tabs { display:flex; flex:0 0 auto; gap:6px; overflow:auto; }
+      .h3cm-stage-tab { white-space:nowrap; }
+      .h3cm-stage-tab[aria-selected="true"] { color:var(--h3cm-accent); border-color:var(--h3cm-accent); }
+      .h3cm-stage-note { flex:0 0 auto; color:var(--h3cm-muted); overflow-wrap:anywhere; }
+      .h3cm-variant-group { display:flex; flex-direction:column; gap:5px; }
+      .h3cm-chapter-tabs { flex:0 0 auto; overflow:auto; padding:2px 0; }
+      .h3cm-chapter-tab { white-space:nowrap; border-radius:999px !important; }
+      .h3cm-chapter-selected { color:var(--h3cm-chapter) !important; border-color:#d6a650 !important;
+        background:color-mix(in srgb,var(--h3cm-panel) 78%,#6d4b16) !important; }
+      .h3cm-scene { white-space:nowrap; }
+      .h3cm-scene-selected,.h3cm-revision-selected { border-color:var(--h3cm-accent) !important;
+        color:var(--h3cm-accent) !important; }
+      .h3cm-main { min-height:0; flex:1 1 auto; display:grid; grid-template-columns:minmax(310px,.9fr) minmax(390px,1.1fr); gap:8px; }
+      .h3cm-panel { min-height:0; overflow:auto; padding:8px; border:1px solid var(--h3cm-border);
+        border-radius:7px; background:color-mix(in srgb,var(--h3cm-panel) 90%,transparent); }
+      .h3cm-panel-title { display:flex; justify-content:space-between; gap:8px; margin-bottom:7px; font-weight:750; }
+      .h3cm-shared-legend { color:var(--h3cm-muted); font-size:10px; font-weight:500; }
+      .h3cm-branches { position:relative; }
+      .h3cm-branch-chapter { margin-bottom:12px; padding:7px; border:1px solid color-mix(in srgb,var(--h3cm-border) 62%,transparent);
+        border-radius:8px; background:color-mix(in srgb,var(--h3cm-panel) 70%,transparent); }
+      .h3cm-branch-chapter:last-child { margin-bottom:0; }
+      .h3cm-branch-chapter-title { width:100%; min-height:0 !important; display:flex; align-items:center;
+        justify-content:flex-start; gap:7px; margin:0 0 7px; padding:2px !important; border:0 !important;
+        background:transparent !important; color:var(--h3cm-chapter) !important; font-size:11px !important;
+        font-weight:750 !important; text-align:left; }
+      .h3cm-branch-chapter-title:hover,.h3cm-branch-chapter-title:focus-visible {
+        color:var(--h3cm-accent) !important; outline:1px solid var(--h3cm-accent) !important; }
+      .h3cm-branch-chapter-title .h3cm-muted { margin-left:auto; font-weight:500; }
+      .h3cm-branch-chapter-caret { width:11px; color:currentColor; text-align:center; }
+      .h3cm-branch-chapter-collapsed { padding-bottom:7px; }
+      .h3cm-branch-chapter-collapsed .h3cm-branch-chapter-title { margin-bottom:0; }
+      .h3cm-branch { position:relative; z-index:1; margin-bottom:8px; padding:6px;
+        border:1px solid color-mix(in srgb,var(--h3cm-border) 75%,transparent); border-radius:6px; }
+      .h3cm-branch-head { justify-content:space-between; margin-bottom:5px; }
+      .h3cm-branch-head[role="button"] { cursor:pointer; border-radius:4px; }
+      .h3cm-branch-head[role="button"]:hover,.h3cm-branch-head[role="button"]:focus-visible {
+        color:var(--h3cm-accent); outline:1px solid var(--h3cm-accent); outline-offset:2px; }
+      .h3cm-branch-selected { border-color:var(--h3cm-accent) !important; }
+      .h3cm-branch-active { color:var(--h3cm-accent); font-weight:700; }
+      .h3cm-branch-path { position:relative; z-index:3; align-items:stretch; overflow:auto; padding-bottom:2px; }
+      .h3cm-arrow { align-self:center; color:var(--h3cm-muted); }
+      .h3cm-revision { position:relative; min-width:112px; text-align:left; white-space:nowrap; }
+      .h3cm-revision small { display:block; color:var(--h3cm-muted); font-size:10px; }
+      .h3cm-alternates { display:flex; flex-direction:column; gap:3px; min-width:104px;
+        padding-left:7px; border-left:2px solid #8264bd; }
+      .h3cm-alternate { min-width:100px; min-height:24px !important; padding:3px 6px !important;
+        border-color:#7259a8 !important; color:#d9c9f7 !important; font-size:10px !important; }
+      .h3cm-alternate-used { background:color-mix(in srgb,var(--h3cm-panel) 68%,#56358b) !important;
+        box-shadow:inset 3px 0 0 #b493f0; }
+      .h3cm-revision-empty { border-style:dashed !important; color:var(--h3cm-muted) !important;
+        background:color-mix(in srgb,var(--h3cm-panel) 72%,transparent) !important; }
+      .h3cm-revision-empty-selected { border-color:var(--h3cm-accent) !important;
+        color:var(--h3cm-accent) !important; }
+      .h3cm-revision-shared { border-color:var(--h3cm-shared-color) !important;
+        box-shadow:inset 3px 0 0 var(--h3cm-shared-color); }
+      .h3cm-shared-label { display:block; width:max-content; margin:2px 0; padding:1px 5px;
+        border-radius:999px; background:color-mix(in srgb,var(--h3cm-shared-color) 23%,transparent);
+        color:color-mix(in srgb,var(--h3cm-shared-color) 72%,var(--h3cm-text)); font-size:9px; font-weight:750; }
+      .h3cm-detail { display:flex; flex-direction:column; gap:8px; }
+      .h3cm-preview-frame { width:100%; height:280px; min-height:120px; max-height:720px;
+        flex:0 0 auto; display:flex; flex-direction:column; overflow:hidden; border-radius:6px;
+        background:#08090c; }
+      .h3cm-preview { width:100%; min-height:0; flex:1 1 auto; object-fit:contain; background:#08090c; }
+      .h3cm-preview-resizer { position:relative; flex:0 0 12px; min-height:12px;
+        cursor:ns-resize; touch-action:none; background:color-mix(in srgb,var(--h3cm-panel) 88%,#000); }
+      .h3cm-preview-resizer::after { content:""; position:absolute; top:5px; left:calc(50% - 28px);
+        width:56px; height:2px; border-radius:2px; background:var(--h3cm-border); }
+      .h3cm-preview-resizer:hover::after,.h3cm-preview-resizer:focus-visible::after {
+        background:var(--h3cm-accent); }
+      .h3cm-preview-resizer:focus-visible { outline:1px solid var(--h3cm-accent); outline-offset:-1px; }
+      .h3cm-audio { width:100%; height:36px; }
+      .h3cm-inspector { display:grid; grid-template-columns:auto minmax(0,1fr); gap:3px 9px; }
+      .h3cm-inspector dt { color:var(--h3cm-muted); }
+      .h3cm-inspector dd { margin:0; overflow-wrap:anywhere; }
+      .h3cm-prompt { max-height:90px; overflow:auto; padding:6px; border-radius:5px;
+        background:var(--h3cm-panel); white-space:pre-wrap; overflow-wrap:anywhere; }
+      .h3cm-attribution { padding:7px; border:1px dashed var(--h3cm-accent);
+        border-radius:6px; background:color-mix(in srgb,var(--h3cm-accent) 8%,transparent); }
+      .h3cm-attribution-title { margin-bottom:6px; font-weight:750; color:var(--h3cm-accent); }
+      .h3cm-attribution-candidates { display:flex; flex-wrap:wrap; gap:5px; margin-bottom:7px; }
+      .h3cm-attribution-candidate-selected { border-color:var(--h3cm-accent) !important;
+        color:var(--h3cm-accent) !important; }
+      .h3cm-delete { flex:0 0 auto; max-height:210px; overflow:auto; padding:8px;
+        border:1px solid var(--h3cm-border); border-radius:7px; }
+      .h3cm-delete-blocked { border-color:var(--h3cm-danger); }
+      .h3cm-delete-title { font-weight:700; }
+      .h3cm-files,.h3cm-dependents { margin:5px 0 0; padding-left:18px; }
+      .h3cm-dependent { color:var(--h3cm-danger); cursor:pointer; }
+      .h3cm-delete-actions { margin-top:7px; }
+      .h3cm-delete-actions .h3cm-status { flex:1 1 180px; min-width:120px; }
+      .h3cm-delete-button { margin-left:auto; color:var(--h3cm-danger) !important; }
+      .h3cm-error { color:var(--h3cm-danger); }
+      @media (max-width:760px) { .h3cm-main { grid-template-columns:1fr; }
+        .h3cm-root { overflow:auto; } }
+    `;
+    document.head.append(style);
+}
+
+function mount(node) {
+    if (node._h3CheckpointManagerMounted) return;
+    node._h3CheckpointManagerMounted = true;
+    injectStyles();
+    node.properties ??= {};
+    let selectionWidget = widget(node, "selection_json");
+    const state = {
+        runs:[], runName:String(node.properties[RUN_PROPERTY] ?? ""), payload:null,
+        scene:Number(node.properties[SCENE_PROPERTY]) || null,
+        revision:String(node.properties[REVISION_PROPERTY] ?? ""),
+        chapterTab:String(node.properties[CHAPTER_PROPERTY] ?? "all"),
+        stage:CHECKPOINT_STAGES.some(item => item.id === node.properties[STAGE_PROPERTY])
+            ? node.properties[STAGE_PROPERTY] : "original",
+        variantKey:String(node.properties[VARIANT_PROPERTY] ?? ""),
+        collapsedChapters:new Set(
+            Array.isArray(node.properties[COLLAPSED_CHAPTERS_PROPERTY])
+                ? node.properties[COLLAPSED_CHAPTERS_PROPERTY].map(String) : [],
+        ),
+        previewHeight:previewHeight(node.properties[PREVIEW_HEIGHT_PROPERTY]),
+        selected:null, outputTip:null, previewTip:null, deletion:null, busy:false, requestToken:0,
+        initialRefresh:true, attribution:null, attributionButton:null,
+    };
+    const root = element("div", "h3cm-root");
+    const head = element("div", "h3cm-head");
+    const title = element("div", "h3cm-title", "Checkpoint Manager");
+    const summary = element("div", "h3cm-summary", "Select a saved run");
+    head.append(title, summary);
+    const runRow = element("div", "h3cm-run-row");
+    const runSelect = element("select", "h3cm-run-select");
+    const refresh = button("Refresh", "Rescan saved runs and checkpoint revisions", () => void refreshRuns());
+    const open = button("Open folder", "Open the selected run folder on the ComfyUI host", () => void openFolder());
+    const deleteRun = button(
+        "Delete run folder",
+        "Permanently delete the selected output/h3_chains run folder after a content preview and two confirmations. Original input project assets are kept.",
+        () => void deleteRunFolder(),
+        "h3cm-run-delete",
+    );
+    deleteRun.disabled = true;
+    runRow.append(runSelect, refresh, open, deleteRun);
+    const outputRow = element("div", "h3cm-output");
+    const outputSummary = element("div", "h3cm-output-summary");
+    const outputScope = element("select", "h3cm-output-scope");
+    outputScope.title = "Output scope only; never changes the project's active branch. Chapter output keeps original scene numbers.";
+    outputScope.setAttribute("aria-label", "Checkpoint output scope");
+    for (const [value, label] of [["project", "Selected branch + earlier chapters"], ["chapter", "Selected chapter only"]]) {
+        const option = element("option", "", label);
+        option.value = value;
+        outputScope.append(option);
+    }
+    restoreOutputScope();
+    outputScope.addEventListener("change", () => {
+        node.properties[OUTPUT_SCOPE_PROPERTY] = outputScope.value;
+        const local = checkpointLocalSelection(selectionWidget?.value);
+        if (local) {
+            // Change only the scope of the existing pin, not its browsed tip.
+            writeOutputSelection(JSON.stringify({...local, output_scope:outputScope.value}));
+        } else persistSelection();
+        render();
+    });
+    const useLocal = button("Use branch locally",
+        "Use the entire browsed branch in this workflow. Previewing an earlier clip does not trim it. Set the processing range downstream. No project activation or Plan change.",
+        () => pinLocalOutput());
+    const followSelection = button("Follow branch selection",
+        "Release the local pin: output follows branch selections, not clip previews. The project's active branch is unchanged.",
+        () => releaseLocalOutput());
+    outputRow.append(outputSummary, outputScope, useLocal, followSelection);
+    const chapterTabs = element("div", "h3cm-chapter-tabs");
+    const stageTabs = element("div", "h3cm-stage-tabs");
+    stageTabs.setAttribute("role", "tablist");
+    stageTabs.setAttribute("aria-label", "Saved clip processing stage");
+    const stageNote = element("div", "h3cm-stage-note");
+    const scenes = element("div", "h3cm-scenes");
+    const main = element("div", "h3cm-main");
+    const branchesPanel = element("section", "h3cm-panel");
+    const branchesTitle = element("div", "h3cm-panel-title", "Revision branches");
+    const branchLegend = element("span", "h3cm-shared-legend", "matching color = same saved clip");
+    branchesTitle.append(branchLegend);
+    const branches = element("div", "h3cm-branches");
+    branchesPanel.append(branchesTitle, branches);
+    const detail = element("section", "h3cm-panel h3cm-detail");
+    const previewFrame = element("div", "h3cm-preview-frame");
+    const preview = element("video", "h3cm-preview");
+    preview.controls = true;
+    preview.preload = "metadata";
+    const previewResizer = element("div", "h3cm-preview-resizer");
+    previewResizer.tabIndex = 0;
+    previewResizer.setAttribute("role", "separator");
+    previewResizer.setAttribute("aria-orientation", "horizontal");
+    previewResizer.setAttribute("aria-label", "Resize clip preview height");
+    previewResizer.title = "Drag to resize the clip preview. Double-click to reset.";
+    previewFrame.append(preview, previewResizer);
+    const audio = element("audio", "h3cm-audio");
+    audio.controls = true;
+    audio.preload = "metadata";
+    audio.hidden = true;
+    const inspector = element("dl", "h3cm-inspector");
+    const attributionPanel = element("div", "h3cm-attribution");
+    attributionPanel.hidden = true;
+    const prompt = element("div", "h3cm-prompt");
+    detail.append(previewFrame, audio, attributionPanel, inspector, prompt);
+    main.append(branchesPanel, detail);
+    const deletion = element("section", "h3cm-delete");
+    const deletionTitle = element("div", "h3cm-delete-title", "Select a checkpoint revision.");
+    const deletionBody = element("div");
+    const deletionActions = element("div", "h3cm-delete-actions");
+    let retireButtons = [];
+    const status = element("div", "h3cm-status");
+    const load = button("Load selected branch", "Project-wide: activate this chapter lineage and restore the connected Plan for generation", () => void loadSelected());
+    const activate = button("Make branch active (project)", "Project-wide: promote this chapter for all workflows using this Run", () => void activateSelected());
+    const remove = button("Delete selected revision", "Delete an inactive leaf or roll back the active branch tip after confirmation", () => void deleteSelected(), "h3cm-delete-button");
+    load.disabled = true;
+    activate.disabled = true;
+    remove.disabled = true;
+    deletionActions.append(load, activate, status, remove);
+    deletion.append(deletionTitle, deletionBody, deletionActions);
+    root.append(head, runRow, outputRow, stageTabs, stageNote, chapterTabs, scenes, main, deletion);
+
+    function setPreviewHeight(value, persist = false) {
+        state.previewHeight = previewHeight(value);
+        previewFrame.style.height = `${state.previewHeight}px`;
+        previewResizer.setAttribute("aria-valuemin", String(MIN_PREVIEW_HEIGHT));
+        previewResizer.setAttribute("aria-valuemax", String(MAX_PREVIEW_HEIGHT));
+        previewResizer.setAttribute("aria-valuenow", String(state.previewHeight));
+        if (!persist) return;
+        node.properties[PREVIEW_HEIGHT_PROPERTY] = state.previewHeight;
+        node.graph?.setDirtyCanvas?.(true, true);
+        app.graph?.setDirtyCanvas?.(true, true);
+    }
+
+    setPreviewHeight(state.previewHeight);
+    previewResizer.addEventListener("pointerdown", (event) => {
+        if (event.button !== 0) return;
+        event.preventDefault();
+        event.stopPropagation();
+        const pointerId = event.pointerId;
+        const startY = event.clientY;
+        const startHeight = state.previewHeight;
+        previewResizer.setPointerCapture?.(pointerId);
+        const move = (moveEvent) => {
+            if (moveEvent.pointerId !== pointerId) return;
+            moveEvent.preventDefault();
+            setPreviewHeight(startHeight + moveEvent.clientY - startY);
+        };
+        const finish = (finishEvent) => {
+            if (finishEvent.pointerId !== pointerId) return;
+            previewResizer.removeEventListener("pointermove", move);
+            previewResizer.removeEventListener("pointerup", finish);
+            previewResizer.removeEventListener("pointercancel", finish);
+            if (previewResizer.hasPointerCapture?.(pointerId)) {
+                previewResizer.releasePointerCapture(pointerId);
+            }
+            setPreviewHeight(state.previewHeight, true);
+        };
+        previewResizer.addEventListener("pointermove", move);
+        previewResizer.addEventListener("pointerup", finish);
+        previewResizer.addEventListener("pointercancel", finish);
+    });
+    previewResizer.addEventListener("keydown", (event) => {
+        let next = state.previewHeight;
+        const step = event.shiftKey ? 48 : 16;
+        if (event.key === "ArrowUp") next -= step;
+        else if (event.key === "ArrowDown") next += step;
+        else if (event.key === "Home") next = MIN_PREVIEW_HEIGHT;
+        else if (event.key === "End") next = MAX_PREVIEW_HEIGHT;
+        else return;
+        event.preventDefault();
+        event.stopPropagation();
+        setPreviewHeight(next, true);
+    });
+    previewResizer.addEventListener("dblclick", (event) => {
+        event.preventDefault();
+        event.stopPropagation();
+        setPreviewHeight(DEFAULT_PREVIEW_HEIGHT, true);
+    });
+
+    function activePlanRun() {
+        const plan = upstreamPlanNode(node);
+        return String(widget(plan, "run_name")?.value ?? "").trim();
+    }
+
+    function restoreOutputScope() {
+        let scope = node.properties[OUTPUT_SCOPE_PROPERTY];
+        try { scope = JSON.parse(selectionWidget?.value || "{}").output_scope ?? scope; }
+        catch { /* Preserve the saved scope even while selection is empty. */ }
+        outputScope.value = scope === "chapter" ? "chapter" : "project";
+    }
+
+    function outputSelectionForScope(value) {
+        // Scope is an explicit UI choice, not the range of the browsed branch.
+        // Keep the exact pinned lineage; only repair a stale/missing scope flag.
+        try {
+            const selection = JSON.parse(value);
+            if (!selection || typeof selection !== "object" || Array.isArray(selection)) return value;
+            if (selection.output_scope != null && !["project", "chapter"].includes(selection.output_scope)) return value;
+            if ((selection.output_scope ?? "project") === outputScope.value) return value;
+            return JSON.stringify({...selection, output_scope:outputScope.value});
+        } catch { return value; } // Invalid selections still fail backend validation.
+    }
+
+    function bindSelectionSerializer() {
+        selectionWidget = widget(node, "selection_json");
+        if (!selectionWidget) return;
+        selectionWidget.hidden = true;
+        selectionWidget.type = "hidden";
+        selectionWidget.computeSize = () => [0, -4];
+        if (selectionWidget._h3ScopeSerializer) return;
+        const previous = selectionWidget.serializeValue;
+        selectionWidget.serializeValue = function (...args) {
+            const value = previous ? previous.apply(this, args) : this.value;
+            const normalize = (saved) => outputSelectionForScope(saved ?? this.value);
+            return value?.then ? value.then(normalize) : normalize(value);
+        };
+        selectionWidget._h3ScopeSerializer = true;
+    }
+
+    function persistSelection() {
+        const previousRun = node.properties[RUN_PROPERTY];
+        const previousScene = node.properties[SCENE_PROPERTY];
+        const previousRevision = node.properties[REVISION_PROPERTY];
+        const previousChapter = node.properties[CHAPTER_PROPERTY];
+        const previousScope = node.properties[OUTPUT_SCOPE_PROPERTY];
+        node.properties[RUN_PROPERTY] = state.runName;
+        node.properties[SCENE_PROPERTY] = state.scene;
+        node.properties[REVISION_PROPERTY] = state.revision;
+        node.properties[CHAPTER_PROPERTY] = state.chapterTab;
+        node.properties[OUTPUT_SCOPE_PROPERTY] = outputScope.value;
+        let changed = previousRun !== state.runName ||
+            previousScene !== state.scene ||
+            previousRevision !== state.revision ||
+            previousChapter !== state.chapterTab || previousScope !== outputScope.value;
+        if (selectionWidget && state.stage === "original") {
+            const value = checkpointOutputSelectionJson(
+                selectionWidget.value, state.payload, state.runName, state.outputTip,
+                chapterRangeFor(state.outputTip), outputScope.value);
+            if (selectionWidget.value !== value) {
+                selectionWidget.value = value;
+                selectionWidget.callback?.(value);
+                changed = true;
+            }
+        }
+        if (changed) node.graph?.setDirtyCanvas?.(true, true);
+    }
+
+    function writeOutputSelection(value) {
+        if (!selectionWidget) return;
+        node.properties[OUTPUT_SCOPE_PROPERTY] = outputScope.value;
+        selectionWidget.value = value;
+        selectionWidget.callback?.(value);
+        node.graph?.setDirtyCanvas?.(true, true);
+    }
+
+    function pinLocalOutput() {
+        if (!["original", "derope"].includes(state.stage) || state.busy || state.attribution || !selectionWidget) return;
+        try {
+            const tip = state.previewTip;
+            if (!tip) throw new Error("Choose a branch heading first; this clip belongs to more than one branch.");
+            writeOutputSelection(state.stage === "derope"
+                ? checkpointDeropeSelectionJson(state.payload, state.runName, tip, currentVariant(), chapterRangeFor(tip), outputScope.value)
+                : checkpointLocalSelectionJson(state.payload, state.runName, tip, chapterRangeFor(tip), outputScope.value));
+            state.outputTip = tip;
+            status.className = "h3cm-status";
+            status.textContent = state.stage === "derope"
+                ? "DeRoPE branch selected for deferred processing. Unsaved scenes use the selected original take; missing/corrupt full latents fail explicitly. Set the range downstream. Project unchanged."
+                : "Whole original branch saved for this workflow. Set start/end on the downstream range selector. Project active branch and connected Plan unchanged.";
+            render();
+        } catch (error) {
+            status.className = "h3cm-status h3cm-error";
+            status.textContent = error.message;
+        }
+    }
+
+    function releaseLocalOutput() {
+        if (state.stage !== "original" || state.busy || !checkpointLocalSelection(selectionWidget?.value)) return;
+        if (!state.previewTip) return;
+        state.outputTip = state.previewTip;
+        writeOutputSelection(checkpointSelectionJson(
+            state.payload, state.runName, state.outputTip, chapterRangeFor(state.outputTip), outputScope.value));
+        status.className = "h3cm-status";
+        status.textContent = "Output follows whole-branch selections. Clip previews do not change the processing range.";
+        render();
+    }
+
+    function localRevisionKeys() {
+        const local = checkpointLocalSelection(selectionWidget?.value);
+        return new Set(local?.run_name === state.runName
+            ? (local.lineage ?? []).filter((item) => local.output_scope !== "chapter" || item.scene >= local.scope_start_scene)
+                .map((item) => checkpointRevisionKey(item.scene, item.revision)) : []);
+    }
+
+    function renderOutputSelection() {
+        const local = checkpointLocalSelection(selectionWidget?.value);
+        outputScope.disabled = state.busy || state.stage !== "original";
+        if (local) restoreOutputScope();
+        useLocal.textContent = state.stage === "derope" ? "Use DeRoPE branch locally" : "Use branch locally";
+        useLocal.disabled = state.busy || Boolean(state.attribution) || !selectionWidget || !["original", "derope"].includes(state.stage) || !state.previewTip?.ready;
+        useLocal.title = state.stage === "derope"
+            ? "Use this saved DeRoPE branch as the deferred source, with original takes for unsaved scenes. No project activation. A full recovered latent is required."
+            : state.previewTip
+            ? "Save the entire browsed branch for this workflow; set start/end on the downstream range selector. No project activation or Plan change."
+            : "Choose a branch heading first. A shared clip alone does not identify which branch to use.";
+        followSelection.disabled = state.busy || !local || state.stage !== "original" || !state.previewTip;
+        outputSummary.className = "h3cm-output-summary";
+        const outputValue = outputSelectionForScope(selectionWidget?.value || "null");
+        outputSummary.textContent = checkpointOutputSummary(outputValue);
+        if (local) {
+            if (state.payload && local.run_name === state.runName) {
+                const available = new Set((state.payload.revisions ?? []).filter((item) => item.ready)
+                    .map((item) => checkpointRevisionKey(item.scene, item.revision)));
+                if ((local.lineage ?? []).some((item) =>
+                    (local.output_scope !== "chapter" || item.scene >= local.scope_start_scene) &&
+                    !available.has(checkpointRevisionKey(item.scene, item.revision)))) {
+                    outputSummary.className += " h3cm-error";
+                    outputSummary.textContent += " · pinned checkpoint unavailable; reselect explicitly (no fallback)";
+                }
+            }
+        }
+        let saved = null;
+        try { saved = JSON.parse(outputValue); } catch { /* invalid selections fail at execution */ }
+        if (saved && state.payload && saved.run_name === state.runName) {
+            const tip = saved.lineage?.at(-1);
+            const range = {start:saved.scope_start_scene, end:saved.scope_end_scene};
+            const fullTip = checkpointOutputBranchTip(state.payload, tip, range);
+            if (!fullTip || Number(fullTip.scene) > Number(tip?.scene)) {
+                outputSummary.textContent += " · old partial selection: choose the desired branch heading"
+                    + (local ? ", then Use branch locally" : "") + " to include its later clips";
+            }
+        }
+    }
+
+    function setBusy(value, message = "") {
+        state.busy = Boolean(value);
+        runSelect.disabled = state.busy;
+        refresh.disabled = state.busy;
+        open.disabled = state.busy || !state.runName;
+        deleteRun.disabled = state.busy || !state.runName;
+        load.disabled = state.busy || Boolean(state.attribution) || !canLoadSelected();
+        activate.disabled = state.busy || Boolean(state.attribution) || !canActivateSelected();
+        remove.disabled = state.busy || Boolean(state.attribution) || !state.deletion?.allowed;
+        for (const control of retireButtons) control.disabled = state.busy || Boolean(state.attribution);
+        if (state.attributionButton) {
+            state.attributionButton.disabled = state.busy || !state.attribution?.candidate;
+        }
+        renderOutputSelection();
+        renderStageTabs();
+        if (message) status.textContent = message;
+    }
+
+    function selectedLineage() {
+        return checkpointRevisionLineage(
+            state.payload, state.selected, selectedChapterRange());
+    }
+
+    function canLoadSelected() {
+        const lineage = selectedLineage();
+        const scope = selectedChapterRange();
+        return Boolean(state.stage === "original" && state.selected?.ready &&
+            state.selected?.take_kind !== "editorial_alternate" &&
+            lineage.length === Number(state.selected.scene) - scope.start + 1);
+    }
+
+    function canActivateSelected() {
+        return ["activate", "rollback"].includes(selectedActivationMode());
+    }
+
+    function selectedActivationMode() {
+        if (state.stage !== "original") return "disabled";
+        return checkpointActivationMode(
+            state.payload, state.selected, selectedChapterRange());
+    }
+
+    function selectRevision(record, requestDeletion = true, variantKey = "", branchTip = null) {
+        state.attribution = null;
+        state.variantKey = variantKey;
+        node.properties[VARIANT_PROPERTY] = variantKey;
+        state.selected = record;
+        state.scene = record ? Number(record.scene) : null;
+        state.revision = record ? String(record.revision) : "";
+        if (state.stage === "original") {
+            state.previewTip = branchTip ?? checkpointOutputBranchTip(
+                state.payload, record, chapterRangeFor(record), state.previewTip ?? state.outputTip);
+        }
+        state.deletion = null;
+        state.requestToken += 1;
+        persistSelection();
+        render();
+        if (requestDeletion) void refreshDeletionPreview();
+    }
+
+    function selectOutputBranch(tip) {
+        if (state.stage !== "original") return;
+        state.outputTip = tip;
+        selectRevision(tip, true, "", tip);
+    }
+
+    function stageLabel() {
+        return CHECKPOINT_STAGES.find(item => item.id === state.stage)?.label ?? "Original";
+    }
+
+    function currentVariant() {
+        const records = checkpointStageVariants(state.payload, state.stage);
+        const exact = records.find(item => item.key === state.variantKey);
+        if (exact) return exact;
+        // A vanished explicitly browsed take must not silently turn into
+        // another take on refresh. A key belonging to another tab is fine.
+        if (state.variantKey && !(state.payload?.processing_variants ?? []).some(item => item.key === state.variantKey)) return null;
+        return state.selected ? checkpointStageVariants(state.payload, state.stage, state.selected)[0] ?? null : null;
+    }
+
+    function selectVariant(record, original = null, branchTip = null) {
+        original ??= (state.payload?.revisions ?? []).find(item => (record.originals ?? []).some(
+            source => checkpointRevisionKey(item.scene, item.revision) === checkpointRevisionKey(source.scene, source.revision)));
+        state.previewTip = branchTip ?? checkpointOutputBranchTip(state.payload, original, chapterRangeFor(original), state.previewTip);
+        selectRevision(original, true, record.key);
+    }
+
+    function selectStage(stage) {
+        if (state.busy) return;
+        state.stage = stage;
+        state.attribution = null;
+        state.deletion = null;
+        state.requestToken += 1;
+        node.properties[STAGE_PROPERTY] = stage;
+        if (stage === "original") state.previewTip = checkpointOutputBranchTip(
+            state.payload, state.selected, chapterRangeFor(state.selected));
+        node.graph?.setDirtyCanvas?.(true, true);
+        // A view switch never writes selection_json or promotes a branch.
+        render();
+        void refreshDeletionPreview();
+    }
+
+    function renderStageTabs() {
+        stageTabs.replaceChildren();
+        for (const stage of CHECKPOINT_STAGES) {
+            const count = stage.id === "original" ? (state.payload?.revisions ?? []).filter(item => sceneVisible(item.scene)).length
+                : checkpointStageVariants(state.payload, stage.id, null, activeChapterRange()).length;
+            if (["pixel_upscale", "other"].includes(stage.id) && !count && state.stage !== stage.id) continue;
+            const tab = button(`${stage.label} · ${count}`, `Browse saved ${stage.label} versions; does not activate a generation branch`,
+                () => selectStage(stage.id), "h3cm-stage-tab");
+            tab.setAttribute("role", "tab");
+            tab.setAttribute("aria-selected", String(state.stage === stage.id));
+            tab.disabled = state.busy;
+            stageTabs.append(tab);
+        }
+        stageNote.textContent = state.stage === "original" ? ""
+            : `${stageLabel()} versions grouped by their original source branch. Browsing does not change output.`
+                + (state.stage === "derope" ? " Select a saved take, then Use DeRoPE branch locally for deferred upscaling. Unsaved scenes use their original take." : "");
+        const warnings = state.payload?.processing_variant_warnings ?? [];
+        if (warnings.length) stageNote.textContent += ` ${warnings.length} processing metadata warning(s): ${warnings[0]}`;
+        stageNote.hidden = !stageNote.textContent;
+        branchLegend.textContent = state.stage === "original" ? "matching color = same saved clip"
+            : "saved versions per source clip";
+    }
+
+    function selectAttribution(parent, slot) {
+        const candidates = slot?.candidates ?? [];
+        if (!parent || !(candidates.length || slot?.blocked_candidates?.length)) return;
+        state.selected = parent;
+        state.scene = Number(parent.scene);
+        state.revision = String(parent.revision);
+        state.attribution = {
+            parent,
+            scene:Number(slot.scene),
+            candidates,
+            blocked:slot?.blocked_candidates ?? [],
+            candidate:candidates[0] ?? null,
+        };
+        persistSelection();
+        render();
+    }
+
+    function chapterRanges() {
+        const chapters = Array.isArray(state.payload?.editorial?.chapters)
+            ? state.payload.editorial.chapters : [];
+        const ordered = chapters.slice().sort(
+            (left, right) => Number(left.start_scene) - Number(right.start_scene),
+        );
+        const maximum = Math.max(
+            0,
+            ...(state.payload?.scenes ?? []).map((scene) => Number(scene.scene) || 0),
+            ...(state.payload?.editorial?.scene_order ?? []).map(
+                (scene) => Number(scene.scene) || 0,
+            ),
+        );
+        const ranges = ordered.map((chapter, index) => ({
+            id:String(chapter.id),
+            title:String(chapter.title || `Chapter ${index + 1}`),
+            text:String(chapter.text || ""),
+            start:Number(chapter.start_scene),
+            end:index + 1 < ordered.length
+                ? Number(ordered[index + 1].start_scene) - 1 : maximum,
+        })).filter((chapter) => Number.isFinite(chapter.start) && chapter.start > 0);
+        if (ranges.length && ranges[0].start > 1) {
+            ranges.unshift({id:"unassigned", title:"Unassigned", text:"", start:1, end:ranges[0].start - 1});
+        }
+        return ranges;
+    }
+
+    function activeChapterRange() {
+        if (state.chapterTab === "all") return null;
+        return chapterRanges().find((chapter) => chapter.id === state.chapterTab) ?? null;
+    }
+
+    function selectedChapterRange() {
+        return chapterRangeFor(state.selected);
+    }
+
+    function chapterRangeFor(record) {
+        const scene = Number(record?.scene);
+        const ranges = chapterRanges();
+        const selected = ranges.find((range) =>
+            scene >= range.start && scene <= range.end);
+        if (selected) return selected;
+        const maximum = Math.max(
+            1,
+            ...(state.payload?.scenes ?? []).map(
+                (item) => Number(item.scene) || 0),
+            ...(state.payload?.editorial?.scene_order ?? []).map(
+                (item) => Number(item.scene) || 0),
+        );
+        return {id:"all", title:"All scenes", text:"", start:1, end:maximum};
+    }
+
+    function sceneVisible(scene) {
+        const range = activeChapterRange();
+        const number = Number(scene);
+        return !range || (number >= range.start && number <= range.end);
+    }
+
+    function chapterCollapseKey(range) {
+        return `${state.runName}:${String(range.id)}`;
+    }
+
+    function setChapterCollapsed(range, collapsed) {
+        const key = chapterCollapseKey(range);
+        if (collapsed) state.collapsedChapters.add(key);
+        else state.collapsedChapters.delete(key);
+        node.properties[COLLAPSED_CHAPTERS_PROPERTY] = [
+            ...state.collapsedChapters,
+        ].sort();
+        node.graph?.setDirtyCanvas?.(true, true);
+        renderBranches();
+    }
+
+    function selectChapterTab(chapterId) {
+        state.chapterTab = chapterId;
+        state.variantKey = "";
+        node.properties[VARIANT_PROPERTY] = "";
+        const visibleScenes = (state.payload?.scenes ?? []).filter(
+            (scene) => sceneVisible(scene.scene),
+        );
+        if (!sceneVisible(state.selected?.scene) && visibleScenes.length) {
+            const scene = visibleScenes.at(-1);
+            state.selected = selectedCheckpointRevision(state.payload, scene.scene);
+            state.scene = Number(state.selected?.scene ?? scene.scene);
+            state.revision = String(state.selected?.revision ?? "");
+            state.deletion = null;
+        }
+        persistSelection();
+        render();
+        if (state.selected) void refreshDeletionPreview();
+    }
+
+    function renderChapterTabs() {
+        chapterTabs.replaceChildren();
+        const ranges = chapterRanges();
+        chapterTabs.hidden = !ranges.length;
+        if (!ranges.length) {
+            state.chapterTab = "all";
+            return;
+        }
+        const valid = new Set(["all", ...ranges.map((chapter) => chapter.id)]);
+        if (!valid.has(state.chapterTab)) state.chapterTab = "all";
+        const tabs = [{id:"all", title:"All scenes", text:""}, ...ranges];
+        for (const chapter of tabs) {
+            const item = button(
+                chapter.title,
+                chapter.text || (chapter.id === "all"
+                    ? "Show every saved scene" : `Show scenes ${chapter.start}–${chapter.end}`),
+                () => selectChapterTab(chapter.id),
+                "h3cm-chapter-tab",
+            );
+            if (chapter.id === state.chapterTab) {
+                item.classList.add("h3cm-chapter-selected");
+            }
+            chapterTabs.append(item);
+        }
+    }
+
+    function renderScenes() {
+        scenes.replaceChildren();
+        for (const scene of state.payload?.scenes ?? []) {
+            if (!sceneVisible(scene.scene)) continue;
+            const original = state.stage === "original";
+            const count = original ? scene.revision_count : checkpointStageVariants(state.payload, state.stage)
+                .filter(item => Number(item.scene) === Number(scene.scene)).length;
+            const noun = original ? "take" : "version";
+            const label = `${scene.scene} · ${scene.scene_id} · ${count} ${noun}${count === 1 ? "" : "s"}`;
+            const item = button(label, original ? `${formatCheckpointBytes(scene.bytes)} saved for this scene`
+                : `${count} saved ${stageLabel()} versions for this scene`, () => {
+                selectRevision(selectedCheckpointRevision(state.payload, scene.scene));
+            }, "h3cm-scene");
+            if (Number(scene.scene) === Number(state.scene)) item.classList.add("h3cm-scene-selected");
+            scenes.append(item);
+        }
+    }
+
+    function renderBranchRows(container, rows) {
+        if (state.stage !== "original") {
+            renderVariantBranchRows(container, rows);
+            return;
+        }
+        const localKeys = localRevisionKeys();
+        const occurrences = new Map();
+        for (const branch of rows) {
+            for (const revision of branch.revisions) {
+                const key = checkpointRevisionKey(revision.scene, revision.revision);
+                occurrences.set(key, (occurrences.get(key) ?? 0) + 1);
+            }
+        }
+        for (const branch of rows) {
+            const row = element("div", "h3cm-branch");
+            const header = element("div", "h3cm-branch-head");
+            const tip = branch.revisions.at(-1) ?? null;
+            const selectedTip = Boolean(tip &&
+                Number(state.previewTip?.scene) === Number(tip.scene) &&
+                String(state.previewTip?.revision) === String(tip.revision));
+            if (selectedTip) row.classList.add("h3cm-branch-selected");
+            if (tip) {
+                header.role = "button";
+                header.tabIndex = 0;
+                header.title = `Select this whole branch (ends at scene ${tip.scene}); set start/end downstream`;
+                header.addEventListener("click", () => selectOutputBranch(tip));
+                header.addEventListener("keydown", (event) => {
+                    if (event.key !== "Enter" && event.key !== " ") return;
+                    event.preventDefault();
+                    selectOutputBranch(tip);
+                });
+            }
+            const name = element("span", branch.active ? "h3cm-branch-active" : "", branch.active ? "Project active branch" : branch.label);
+            const count = element("span", "h3cm-muted", `${branch.revisions.length} visible scene${branch.revisions.length === 1 ? "" : "s"}`);
+            header.append(name, count);
+            const path = element("div", "h3cm-branch-path");
+            branch.revisions.forEach((revision, index) => {
+                if (index) path.append(element("span", "h3cm-arrow", "→"));
+                const key = checkpointRevisionKey(revision.scene, revision.revision);
+                const sharedCount = occurrences.get(key) ?? 1;
+                const card = button(
+                    `S${revision.scene} · ${revision.revision.slice(0, 8)}`,
+                    revision.prompt_preview || revision.scene_id,
+                    () => selectRevision(revision, true, "", tip), "h3cm-revision",
+                );
+                const selected = state.selected?.scene === revision.scene &&
+                    state.selected?.revision === revision.revision;
+                if (sharedCount > 1) {
+                    card.classList.add("h3cm-revision-shared");
+                    card.dataset.sharedKey = key;
+                    card.style.setProperty("--h3cm-shared-color", sharedColor(key));
+                    card.append(element(
+                        "span", "h3cm-shared-label",
+                        `shared ×${sharedCount}`,
+                    ));
+                }
+                card.append(element("small", "", `${selected ? "selected · " : ""}${revision.active ? "saved active" : "saved inactive"}${revision.ready ? "" : " · broken"}`));
+                if (localKeys.has(key)) card.append(element("small", "h3cm-local-label", "local output"));
+                if (selected) {
+                    card.classList.add("h3cm-revision-selected");
+                }
+                path.append(card);
+                const alternates = (revision.alternates ?? []).filter(
+                    (alternate) => alternate.ready,
+                );
+                if (alternates.length) {
+                    const group = element("span", "h3cm-alternates");
+                    for (const alternate of alternates) {
+                        const alt = button(
+                            `ALT · ${String(alternate.revision).slice(0, 8)}`,
+                            alternate.prompt_preview || alternate.prompt ||
+                                "Prompt-only editorial alternate",
+                            () => selectRevision(alternate),
+                            "h3cm-alternate",
+                        );
+                        if (alternate.used_in_final_cut) {
+                            alt.classList.add("h3cm-alternate-used");
+                            alt.append(element("small", "", "used in final cut"));
+                        } else {
+                            alt.append(element("small", "", "available take"));
+                        }
+                        if (state.selected?.scene === alternate.scene
+                                && state.selected?.revision === alternate.revision) {
+                            alt.classList.add("h3cm-revision-selected");
+                        }
+                        group.append(alt);
+                    }
+                    path.append(group);
+                }
+            });
+            const slot = branch.attribution_slot;
+            if ((slot?.candidates?.length || slot?.blocked_candidates?.length)
+                    && tip && sceneVisible(slot.scene)) {
+                path.append(element("span", "h3cm-arrow", "→"));
+                const count = slot.candidates.length;
+                const empty = button(
+                    `S${slot.scene} · reuse saved clip`,
+                    `${count} independent saved candidate${count === 1 ? "" : "s"} can be attributed here`,
+                    () => selectAttribution(tip, slot),
+                    "h3cm-revision h3cm-revision-empty",
+                );
+                empty.append(element(
+                    "small", "", count ? `${count} available candidate${count === 1 ? "" : "s"}`
+                        : "Check saved context requirements",
+                ));
+                if (state.attribution &&
+                        state.attribution.parent.revision === tip.revision) {
+                    empty.classList.add("h3cm-revision-empty-selected");
+                }
+                path.append(empty);
+            }
+            row.append(header, path);
+            container.append(row);
+        }
+    }
+
+    function variantCard(record, original = null, branchTip = null) {
+        const card = button(`S${record.scene} · ${record.revision.slice(0, 8)}`,
+            `${record.profile_path}\n${checkpointVariantLatentStatus(record)}`,
+            () => selectVariant(record, original, branchTip), "h3cm-revision h3cm-processing-variant");
+        card.append(element("small", "", record.profile));
+        card.append(element("small", "", `${record.width || "?"}×${record.height || "?"} · ${record.ready ? "saved" : "missing artifacts"}`));
+        card.append(element("small", "", record.latent_saved ? "full latent saved" : "full latent not saved"));
+        if (currentVariant()?.key === record.key) card.classList.add("h3cm-revision-selected");
+        return card;
+    }
+
+    function renderVariantBranchRows(container, rows) {
+        for (const branch of rows) {
+            const row = element("div", "h3cm-branch");
+            const header = element("div", "h3cm-branch-head");
+            header.append(element("span", branch.active ? "h3cm-branch-active" : "",
+                `Source: ${branch.active ? "Project active branch" : branch.label}`));
+            const path = element("div", "h3cm-branch-path");
+            branch.revisions.forEach((original, index) => {
+                if (index) path.append(element("span", "h3cm-arrow", "→"));
+                const group = element("div", "h3cm-variant-group");
+                group.append(element("small", "h3cm-muted", `Original S${original.scene} · ${original.revision.slice(0, 8)}`));
+                const records = checkpointStageVariants(state.payload, state.stage, original);
+                for (const record of records) group.append(variantCard(record, original, branch.revisions.at(-1)));
+                if (!records.length) group.append(button(`S${original.scene} · not saved`,
+                    `No saved ${stageLabel()} version of this source revision`,
+                    () => selectRevision(original, false), "h3cm-revision h3cm-revision-empty"));
+                path.append(group);
+            });
+            row.append(header, path);
+            container.append(row);
+        }
+    }
+
+    function renderUnlinkedVariants() {
+        if (state.stage === "original") return;
+        const records = checkpointStageVariants(state.payload, state.stage, null, activeChapterRange())
+            .filter(item => !(item.originals ?? []).length);
+        if (!records.length) return;
+        branches.append(element("div", "h3cm-muted", "Saved versions with an unavailable or mismatched original (not attached to another take)"));
+        const row = element("div", "h3cm-branch-path");
+        for (const record of records) row.append(variantCard(record));
+        branches.append(row);
+    }
+
+    function renderBranches() {
+        branches.replaceChildren();
+        const ranges = chapterRanges();
+        if (!ranges.length) {
+            const rows = checkpointBranchRows(state.payload);
+            if (rows.length) renderBranchRows(branches, rows);
+            else branches.append(element(
+                "div", "h3cm-muted", "No versioned checkpoints were found.",
+            ));
+            return;
+        }
+        const visibleRanges = state.chapterTab === "all"
+            ? ranges : ranges.filter((range) => range.id === state.chapterTab);
+        let rendered = 0;
+        for (const range of visibleRanges) {
+            const rows = checkpointChapterBranchRows(state.payload, range);
+            if (!rows.length) continue;
+            if (state.chapterTab === "all") {
+                const section = element("section", "h3cm-branch-chapter");
+                const collapseKey = chapterCollapseKey(range);
+                const collapsed = state.collapsedChapters.has(collapseKey);
+                section.classList.toggle(
+                    "h3cm-branch-chapter-collapsed", collapsed);
+                const heading = button(
+                    "",
+                    `${collapsed ? "Expand" : "Collapse"} ${range.title}`,
+                    () => setChapterCollapsed(range, !collapsed),
+                    "h3cm-branch-chapter-title",
+                );
+                heading.setAttribute("aria-expanded", String(!collapsed));
+                heading.append(
+                    element("span", "h3cm-branch-chapter-caret", collapsed ? "▸" : "▾"),
+                    element("span", "", range.title),
+                    element("span", "h3cm-muted", `Scenes ${range.start}–${range.end}`),
+                );
+                const body = element("div", "h3cm-branch-chapter-body");
+                body.hidden = collapsed;
+                if (!collapsed) renderBranchRows(body, rows);
+                section.append(heading, body);
+                branches.append(section);
+            } else renderBranchRows(branches, rows);
+            rendered += rows.length;
+        }
+        if (!rendered) {
+            branches.append(element(
+                "div", "h3cm-muted", "No versioned checkpoints were found in this chapter.",
+            ));
+        }
+    }
+
+    function addInspector(label, value) {
+        inspector.append(element("dt", "", label), element("dd", "", value));
+    }
+
+    function renderDetail() {
+        inspector.replaceChildren();
+        attributionPanel.replaceChildren();
+        attributionPanel.hidden = !state.attribution;
+        state.attributionButton = null;
+        const processing = state.stage !== "original";
+        const record = processing ? currentVariant() : state.attribution?.candidate ?? state.selected;
+        if (!record) {
+            preview.removeAttribute("src");
+            delete preview.dataset.source;
+            preview.load();
+            audio.hidden = true;
+            audio.removeAttribute("src");
+            delete audio.dataset.source;
+            prompt.textContent = processing ? (state.variantKey
+                ? "The previously browsed processing take is unavailable. Select a saved version; no other take has been substituted."
+                : `No saved ${stageLabel()} version for this source revision. The original clip has not been substituted.`)
+                : "Select a revision from the branch graph.";
+            return;
+        }
+        if (state.attribution) {
+            const attribution = state.attribution;
+            attributionPanel.append(element(
+                "div", "h3cm-attribution-title",
+                `Attribute an existing scene ${attribution.scene} candidate to branch ${attribution.parent.revision.slice(0, 8)}`,
+            ));
+            const candidates = element("div", "h3cm-attribution-candidates");
+            for (const candidate of attribution.candidates) {
+                const choice = button(
+                    `${candidate.revision.slice(0, 8)} · seed ${candidate.seed || "?"}`,
+                    candidate.prompt_preview || candidate.scene_id,
+                    () => {
+                        attribution.candidate = candidate;
+                        renderDetail();
+                    },
+                );
+                if (candidate.revision === record.revision) {
+                    choice.classList.add("h3cm-attribution-candidate-selected");
+                }
+                candidates.append(choice);
+            }
+            const attach = button(
+                "Attach selected candidate",
+                "Create a metadata-only lineage link; saved media and checkpoint files remain shared",
+                () => void attributeCandidate(),
+            );
+            attach.disabled = state.busy || !attribution.candidate;
+            state.attributionButton = attach;
+            attributionPanel.append(
+                candidates,
+                element("div", "h3cm-muted",
+                    attribution.candidate
+                        ? "This candidate uses no predecessor video or generated-audio context. Attribution creates a new lineage link without regeneration or media duplication."
+                        : "No reusable candidate is proven independent by its saved metadata."),
+                attach,
+            );
+            for (const blocked of attribution.blocked ?? []) {
+                attributionPanel.append(element("div", "h3cm-muted",
+                    `${blocked.revision.slice(0, 8)}: ${blocked.reason}`));
+            }
+        }
+        const media = record.preview_video ?? record.video;
+        const nextVideo = videoUrl(media);
+        if (nextVideo && preview.dataset.source !== nextVideo) {
+            preview.src = nextVideo;
+            preview.dataset.source = nextVideo;
+            preview.load();
+        } else if (!nextVideo) {
+            preview.removeAttribute("src");
+            delete preview.dataset.source;
+            preview.load();
+        }
+        const audioUrl = videoUrl(record.audio);
+        audio.hidden = !audioUrl;
+        if (audioUrl && audio.dataset.source !== audioUrl) {
+            audio.src = audioUrl;
+            audio.dataset.source = audioUrl;
+            audio.load();
+        } else if (!audioUrl) {
+            audio.removeAttribute("src");
+            delete audio.dataset.source;
+        }
+        if (processing) {
+            addInspector("Version", `${stageLabel()} · Scene ${record.scene} · ${record.revision}`);
+            addInspector("Profile", record.profile_path);
+            addInspector("State", record.ready ? "Saved files present (integrity checked at execution)" : `Missing: ${(record.missing_files ?? []).join(", ")}`);
+            addInspector("Original", (record.originals ?? []).map(item => `Scene ${item.scene} · ${item.revision.slice(0, 8)}`).join(", ") || record.source_status);
+            addInspector("Immediate source", record.source_revision || "Unknown");
+            addInspector("Created", localTime(record.created_at));
+            addInspector("Canvas", `${record.width || "?"}×${record.height || "?"} @ 24 fps`);
+            addInspector("Frames", `${record.raw_frames} raw · ${record.delivered_frames} delivered`);
+            addInspector("Latent", checkpointVariantLatentStatus(record));
+            addInspector("Audio", record.audio_route);
+            addInspector("Storage", formatCheckpointBytes(record.size_bytes));
+            addInspector("Metadata", record.metadata_path);
+            prompt.textContent = record.prompt || "No saved scene prompt.";
+            return;
+        }
+        addInspector("Identity", `${state.attribution ? "Candidate " : ""}Scene ${record.scene} · ${record.scene_id} · ${record.revision}`);
+        addInspector("State", record.take_kind === "editorial_alternate"
+            ? `Editorial alternate · ${record.used_in_final_cut ? "used in final cut" : "available"} · ${record.ready ? "Ready" : "Broken"}`
+            : `${record.active ? "Active generation checkpoint" : "Inactive generation checkpoint"} · ${record.ready ? "Ready" : "Broken"}`);
+        if (record.take_kind === "editorial_alternate") {
+            addInspector("Original base", `Scene ${record.scene} · ${String(record.alternate_of_revision).slice(0, 8)}`);
+            addInspector("Media", "Picture only · original audio and downstream lineage stay unchanged");
+            addInspector("Use", "Select Original or ALT for this scene in Plan Studio; ALT cannot be loaded or activated as generation lineage");
+        }
+        addInspector("Branches", (record.branches ?? []).map((item) => item.label).join(", ") || "Unresolved lineage");
+        addInspector("Created", localTime(record.created_at));
+        addInspector("Frames", `${record.raw_frames} raw · ${record.delivered_frames} delivered`);
+        addInspector("Sampling", `seed ${record.seed || "unknown"} · ${record.steps || "?"} steps`);
+        addInspector("Incoming", `${record.continuation_mode} · Video ${record.context_length}f · Audio ${record.audio_context_length}f`);
+        if (record.inactive_reason) addInspector("Inactive", record.inactive_reason);
+        addInspector("Parent", state.attribution
+            ? `Will become Scene ${state.attribution.parent.scene} · ${state.attribution.parent.revision.slice(0, 8)}`
+            : record.parent ? `Scene ${record.parent.scene} · ${record.parent.revision.slice(0, 8)}` : record.lineage_status);
+        addInspector("Following", (record.children ?? []).length
+            ? record.children.map(checkpointDependencyText).join(" · ") : "No dependent revision");
+        addInspector("Storage", `${formatCheckpointBytes(record.size_bytes)}` +
+            `${record.shared_size_bytes ? ` · ${formatCheckpointBytes(record.shared_size_bytes)} shared` : ""}` +
+            ` · ${(record.missing_files ?? []).length ? `missing ${record.missing_files.join(", ")}` : "complete"}`);
+        const compatibility = record.compatibility ?? {};
+        addInspector("Canvas", compatibility.width && compatibility.height
+            ? `${compatibility.width}×${compatibility.height} @ ${compatibility.fps ?? 24} fps` : "Unknown");
+        addInspector("Audio mode", compatibility.audio_mode ?? "Unknown");
+        addInspector("Encoding", [compatibility.encode_mode, compatibility.anchor_mode,
+            compatibility.crop].filter(Boolean).join(" · ") || "Unknown");
+        addInspector("Metadata", record.metadata_path ?? "Unknown");
+        prompt.textContent = record.prompt || record.prompt_preview || "No saved scene prompt.";
+    }
+
+    function renderDeletion() {
+        deletionBody.replaceChildren();
+        retireButtons = [];
+        const processing = state.stage !== "original";
+        const activationMode = selectedActivationMode();
+        const rollsBack = !processing && activationMode === "rollback";
+        remove.textContent = processing ? "Delete processed version" : "Delete selected revision";
+        remove.title = processing ? "Preview and permanently delete only this processed take's owned files" : "Delete an inactive leaf or roll back the active branch tip after confirmation";
+        deletion.classList.toggle("h3cm-delete-blocked", Boolean(state.deletion && !state.deletion.allowed));
+        if (processing) {
+            deletionTitle.textContent = !state.deletion ? "Select a processed version to inspect deletion safety."
+                : state.deletion.allowed
+                    ? `Delete processed version · ${state.deletion.owned_file_count} files · ${formatCheckpointBytes(state.deletion.reclaimed_bytes)} · originals kept`
+                    : state.deletion.blockers?.join(" ") || "Deletion is blocked.";
+            activate.textContent = "Make branch active (project)";
+            load.disabled = activate.disabled = true;
+        } else {
+            activate.textContent = rollsBack
+                ? "Roll active branch back (project)" : "Make branch active (project)";
+            activate.title = rollsBack
+                ? "Project-wide: retire later active scene pointers in this chapter without deleting saved revisions"
+                : "Project-wide: promote this chapter for all workflows using this Run";
+            deletionTitle.textContent = checkpointDeletionTitle(state.deletion);
+            load.disabled = state.busy || !canLoadSelected();
+            activate.disabled = state.busy || !canActivateSelected();
+        }
+        remove.disabled = state.busy || !state.deletion?.allowed;
+        if (state.attribution) {
+            load.disabled = true;
+            activate.disabled = true;
+            remove.disabled = true;
+        }
+        if (!state.deletion) return;
+        if (!processing && state.deletion.chapter_references?.length) {
+            const snapshots = element("div", "h3cm-delete-actions");
+            for (const reference of state.deletion.chapter_references) {
+                if (reference.error || !reference.path || !reference.snapshot) continue;
+                const control = button(
+                    `Retire Chapter ${reference.number} snapshot ${reference.snapshot.slice(0, 8)}…`,
+                    "Preview releasing this snapshot's recovery pins. Its JSON is archived; no clips are deleted.",
+                    () => void retireChapterSnapshot(reference),
+                );
+                control.disabled = state.busy || Boolean(state.attribution);
+                retireButtons.push(control);
+                snapshots.append(control);
+            }
+            deletionBody.append(snapshots);
+        }
+        const files = (state.deletion.files ?? []).filter((item) => item.exists);
+        if (files.length) {
+            const list = element("ul", "h3cm-files");
+            for (const file of files) {
+                list.append(element("li", file.shared ? "h3cm-muted" : "",
+                    `${file.label} · ${formatCheckpointBytes(file.size_bytes)} · ${file.path}` +
+                    `${file.shared ? " · shared, kept" : ""}`));
+            }
+            deletionBody.append(list);
+        }
+        if (processing && state.deletion.retained_independent_takes?.length) {
+            deletionBody.append(element("div", "h3cm-muted",
+                "Independent pixel takes kept: " + state.deletion.retained_independent_takes.map(item =>
+                    `Scene ${item.scene} · ${String(item.revision).slice(0, 8)}`).join(", ") +
+                ". Affected sequence manifests are invalidated; rebuild missing scenes before full-sequence resume."));
+        }
+        if (state.deletion.dependents?.length) {
+            const heading = element(
+                "div", "h3cm-error",
+                "Permanent deletion is blocked by dependent revisions:",
+            );
+            if (rollsBack) {
+                deletionBody.append(element(
+                    "div", "h3cm-muted",
+                    "To continue from this scene, use Roll active branch back. It clears later active pointers but keeps every saved take.",
+                ));
+            }
+            const list = element("ul", "h3cm-dependents");
+            for (const dependent of state.deletion.dependents) {
+                if (processing) {
+                    const item = element("li", "h3cm-dependent",
+                        `Scene ${dependent.scene ?? "?"} · ${String(dependent.revision ?? "").slice(0, 8)} · ${dependent.reason} · ${dependent.metadata_path}`);
+                    item.addEventListener("click", () => {
+                        const variant = (state.payload?.processing_variants ?? []).find(v => v.key === dependent.metadata_path);
+                        if (variant) { selectStage(variant.stage); selectVariant(variant); }
+                    });
+                    list.append(item);
+                    continue;
+                }
+                const action = dependent.leaf
+                    ? (dependent.active
+                        ? " · active leaf: select to delete it"
+                        : " · leaf: delete this first")
+                    : "";
+                const item = element("li", "h3cm-dependent",
+                    `${checkpointDependencyText(dependent)}${action}`);
+                item.title = dependent.leaf && !dependent.active
+                    ? "Select this deletable leaf checkpoint"
+                    : dependent.leaf
+                        ? "Select this active branch tip to inspect its rollback"
+                        : "Select this dependent checkpoint to inspect its own descendants";
+                item.addEventListener("click", () => {
+                    const revision = selectedCheckpointRevision(
+                        state.payload, dependent.scene, dependent.revision);
+                    if (revision) selectRevision(revision);
+                });
+                list.append(item);
+            }
+            deletionBody.append(heading, list);
+        }
+        if (state.deletion.not_deleted?.length) {
+            const kept = element("details", "h3cm-muted");
+            kept.append(element("summary", "", "Always kept by this deletion"));
+            const list = element("ul", "h3cm-files");
+            for (const label of state.deletion.not_deleted) {
+                list.append(element("li", "", label));
+            }
+            kept.append(list);
+            deletionBody.append(kept);
+        }
+    }
+
+    function render() {
+        const total = state.payload?.summary;
+        summary.textContent = total
+            ? `${total.scene_count} scenes · ${total.revision_count} revisions · ${total.branch_count} branches · ${formatCheckpointBytes(total.bytes)}`
+            : "Select a saved run";
+        renderOutputSelection();
+        renderChapterTabs();
+        renderStageTabs();
+        renderScenes();
+        renderBranches();
+        renderUnlinkedVariants();
+        renderDetail();
+        renderDeletion();
+    }
+
+    async function refreshDeletionPreview() {
+        const processing = state.stage !== "original";
+        const record = processing ? currentVariant() : state.selected;
+        const token = ++state.requestToken;
+        if (!record || !state.runName || state.attribution) return;
+        deletionTitle.textContent = "Inspecting owned files and dependencies…";
+        remove.disabled = true;
+        try {
+            const payload = await jsonRequest(
+                processing ? "/minimax_h3_context_loop/processing-checkpoints/delete-preview"
+                    : "/minimax_h3_context_loop/checkpoint-revisions/delete-preview", {
+                    method:"POST", headers:{"Content-Type":"application/json"},
+                    body:JSON.stringify({run_name:state.runName, scene:record.scene, revision:record.revision,
+                        ...(processing ? {metadata_path:record.key} : {})}),
+                });
+            if (token !== state.requestToken) return;
+            state.deletion = payload;
+        } catch (error) {
+            if (token !== state.requestToken) return;
+            state.deletion = null;
+            status.className = "h3cm-status h3cm-error";
+            status.textContent = error.message;
+        }
+        renderDeletion();
+    }
+
+    async function refreshCheckpoints() {
+        if (!state.runName) {
+            state.payload = null;
+            selectRevision(null, false);
+            return;
+        }
+        setBusy(true, "Scanning checkpoint metadata…");
+        try {
+            const query = new URLSearchParams({
+                run_name:state.runName,
+                cache_bust:String(Date.now()),
+            });
+            state.payload = await jsonRequest(
+                `/minimax_h3_context_loop/checkpoints?${query}`,
+                {cache:"no-store"},
+            );
+            // Output is a branch selection, independent of the preview cursor.
+            // Preserve old snapshots on reload; never guess a descendant of a
+            // shared ancestor. The output row explains how to replace an old
+            // partial pin with an explicitly chosen whole branch.
+            let savedOutput = null;
+            try { savedOutput = JSON.parse(selectionWidget?.value || "null"); } catch { /* validated at execution */ }
+            const savedTip = savedOutput?.run_name === state.runName ? savedOutput.lineage?.at(-1) : null;
+            state.outputTip = savedTip
+                ? (state.payload.revisions ?? []).find(item => checkpointRevisionKey(item.scene, item.revision)
+                    === checkpointRevisionKey(savedTip.scene, savedTip.revision)) ?? savedTip
+                : selectedCheckpointRevision(state.payload);
+            let selected = selectedCheckpointRevision(
+                state.payload, state.scene, state.revision);
+            if (state.stage === "original" && state.initialRefresh && !checkpointLocalSelection(selectionWidget?.value)) {
+                const activeTip = selectedCheckpointRevision(state.payload);
+                if (checkpointRevisionLineage(
+                        state.payload, activeTip).length >
+                        checkpointRevisionLineage(
+                            state.payload, selected).length) {
+                    selected = activeTip;
+                }
+            }
+            state.initialRefresh = false;
+            status.className = "h3cm-status";
+            status.textContent = state.payload.summary?.broken_count
+                ? `${state.payload.summary.broken_count} broken revision${state.payload.summary.broken_count === 1 ? "" : "s"} found`
+                : "Checkpoint graph is current";
+            selectRevision(selected, false, state.variantKey);
+            void refreshDeletionPreview();
+        } catch (error) {
+            state.payload = null;
+            state.selected = null;
+            state.deletion = null;
+            status.className = "h3cm-status h3cm-error";
+            status.textContent = error.message;
+            render();
+        } finally {
+            setBusy(false);
+        }
+    }
+
+    async function refreshRuns() {
+        setBusy(true, "Scanning output/h3_chains…");
+        try {
+            const payload = await jsonRequest("/minimax_h3_context_loop/runs");
+            state.runs = payload.runs ?? [];
+            const connected = activePlanRun();
+            const local = checkpointLocalSelection(selectionWidget?.value);
+            const preferred = local?.run_name || state.runName || connected;
+            if (local && state.initialRefresh) {
+                state.scene = local.lineage?.at(-1)?.scene ?? null;
+                state.revision = local.lineage?.at(-1)?.revision ?? "";
+            }
+            state.runName = local ? preferred : state.runs.some((item) => item.run_name === preferred)
+                ? preferred : state.runs[0]?.run_name ?? "";
+            runSelect.replaceChildren();
+            for (const run of state.runs) {
+                const option = element("option", "", `${run.run_name} · ${run.checkpoint_count} active checkpoints`);
+                option.value = run.run_name;
+                runSelect.append(option);
+            }
+            if (local && !state.runs.some((item) => item.run_name === preferred)) {
+                const option = element("option", "", `${preferred} · pinned run unavailable`);
+                option.value = preferred;
+                runSelect.append(option);
+            }
+            runSelect.value = state.runName;
+        } catch (error) {
+            state.runs = [];
+            state.runName = "";
+            runSelect.replaceChildren();
+            status.className = "h3cm-status h3cm-error";
+            status.textContent = error.message;
+        } finally {
+            setBusy(false);
+        }
+        await refreshCheckpoints();
+    }
+
+    async function openFolder() {
+        if (!state.runName) return;
+        setBusy(true, "Opening run folder…");
+        try {
+            const payload = await jsonRequest("/minimax_h3_context_loop/open-run-folder", {
+                method:"POST", headers:{"Content-Type":"application/json"},
+                body:JSON.stringify({run_name:state.runName}),
+            });
+            status.textContent = payload.opened ? "Opened on ComfyUI host" : payload.path;
+        } catch (error) {
+            status.className = "h3cm-status h3cm-error";
+            status.textContent = error.message;
+        } finally {
+            setBusy(false);
+        }
+    }
+
+    async function deleteRunFolder() {
+        const runName = state.runName;
+        if (!runName || state.busy) return;
+        let plan;
+        setBusy(true, "Inspecting the complete run folder…");
+        try {
+            plan = await jsonRequest(
+                "/minimax_h3_context_loop/run-folder/delete-preview", {
+                    method:"POST", headers:{"Content-Type":"application/json"},
+                    body:JSON.stringify({run_name:runName}),
+                });
+        } catch (error) {
+            status.className = "h3cm-status h3cm-error";
+            status.textContent = error.message;
+            return;
+        } finally {
+            setBusy(false);
+        }
+        if (state.runName !== runName) return;
+        const confirmed = window.confirm(
+            `Delete the complete run folder "${runName}"?\n\n` +
+            `${plan.file_count} files · ${plan.directory_count} folders · ${formatCheckpointBytes(plan.reclaimed_bytes)}\n\n` +
+            `This permanently removes ${plan.folder}, including checkpoints, revisions, generated segments and audio, prompt history, archived workflows, reference backups, previews, and assembled exports.\n\n` +
+            "Original input project assets are kept. A second validation follows. This cannot be undone.",
+        );
+        if (!confirmed) return;
+        const typed = window.prompt(
+            `Second validation: type the exact Run name to delete ${plan.folder}:\n\n${runName}`,
+            "",
+        );
+        if (typed === null) return;
+        if (typed !== runName) {
+            status.className = "h3cm-status h3cm-error";
+            status.textContent = "Run folder not deleted: the second validation did not exactly match the Run name.";
+            return;
+        }
+        setBusy(true, "Deleting the complete run folder…");
+        try {
+            const payload = await jsonRequest(
+                "/minimax_h3_context_loop/run-folder/delete", {
+                    method:"POST", headers:{"Content-Type":"application/json"},
+                    body:JSON.stringify({run_name:runName,
+                        snapshot:plan.snapshot, confirmation:typed}),
+                });
+            state.runName = "";
+            state.scene = null;
+            state.revision = "";
+            state.selected = null;
+            state.deletion = null;
+            state.payload = null;
+            persistSelection();
+            await refreshRuns();
+            status.className = "h3cm-status";
+            status.textContent = `${payload.message} Reclaimed ${formatCheckpointBytes(payload.reclaimed_bytes)}. Original input project assets were kept.`;
+        } catch (error) {
+            status.className = "h3cm-status h3cm-error";
+            status.textContent = error.payload?.preview
+                ? `${error.message} Click Delete run folder to review it again.`
+                : error.message;
+        } finally {
+            setBusy(false);
+        }
+    }
+
+    function restoreSavedPlanInputs(inputs, policyInputs = {}) {
+        const planNode = upstreamPlanNode(node);
+        if (!planNode || !inputs || typeof inputs !== "object") {
+            throw new Error("The saved run has no Plan inputs to restore.");
+        }
+        const names = Object.keys(inputs).sort((left, right) =>
+            Number(left === "plan_json") - Number(right === "plan_json"));
+        const graph = planNode.graph ?? app.graph;
+        const applied = [];
+        graph?.beforeChange?.();
+        try {
+            for (const name of names) {
+                const target = widget(planNode, name);
+                if (!target) continue;
+                target.value = inputs[name];
+                target.callback?.(inputs[name]);
+                applied.push(name);
+            }
+        } finally {
+            graph?.afterChange?.();
+        }
+        if (!applied.includes("plan_json")) {
+            throw new Error("The connected Plan does not expose an editable plan_json widget.");
+        }
+        restoreConnectedPolicyInputs(planNode, policyInputs);
+        refreshRestoredPlanEditors(planNode);
+        app.graph?.setDirtyCanvas?.(true, true);
+        return planNode;
+    }
+
+    function applyLoadedRevisions(planNode, revisions) {
+        const target = widget(planNode, "plan_json");
+        if (!target) throw new Error("The connected Plan has no plan_json control.");
+        const plan = applyCheckpointRevisionSet(
+            parsePlanJson(String(target.value ?? "")), revisions,
+        );
+        const value = planToJson(plan);
+        target.value = value;
+        target.callback?.(value);
+        refreshRestoredPlanEditors(planNode);
+        planNode.graph?.setDirtyCanvas?.(true, true);
+        for (const revision of revisions ?? []) {
+            const sceneIndex = Number(revision.scene) - 1;
+            if (sceneIndex < 0 || sceneIndex >= plan.shots.length) continue;
+            publishCompanionPrompt(
+                node, planNode, sceneIndex,
+                promptValueToText(plan.shots[sceneIndex]?.prompt),
+            );
+        }
+        return plan;
+    }
+
+    function applyActivatedRevisions(planNode, revisions) {
+        const target = widget(planNode, "plan_json");
+        if (!target) return false;
+        const plan = applyCheckpointRevisionSet(
+            parsePlanJson(String(target.value ?? "")), revisions, {
+                useEffectivePrompts: true,
+                useTipSharedPrompt: true,
+            },
+        );
+        const value = planToJson(plan);
+        target.value = value;
+        target.callback?.(value);
+        refreshRestoredPlanEditors(planNode);
+        planNode.graph?.setDirtyCanvas?.(true, true);
+        for (const revision of revisions ?? []) {
+            const sceneIndex = Number(revision.scene) - 1;
+            if (sceneIndex < 0 || sceneIndex >= plan.shots.length) continue;
+            publishCompanionPrompt(
+                node, planNode, sceneIndex,
+                promptValueToText(plan.shots[sceneIndex]?.prompt),
+            );
+        }
+        return true;
+    }
+
+    function prepareResume(scene) {
+        const start = connectedNode(node, START_NAME);
+        const startClip = widget(start, "start_clip");
+        if (!startClip) return false;
+        startClip.value = scene;
+        startClip.callback?.(scene);
+        const range = widget(start, "scene_range");
+        if (range) {
+            range.value = "";
+            range.callback?.("");
+        }
+        start.graph?.setDirtyCanvas?.(true, true);
+        return true;
+    }
+
+    async function attributeCandidate() {
+        const attribution = state.attribution;
+        const candidate = attribution?.candidate;
+        const parent = attribution?.parent;
+        if (!candidate || !parent || state.busy) return;
+        const confirmed = window.confirm(
+            `Attribute scene ${candidate.scene} candidate ${candidate.revision.slice(0, 8)} after scene ${parent.scene} revision ${parent.revision.slice(0, 8)}?\n\n` +
+            "The candidate has no predecessor video or generated-audio dependency. A new immutable lineage record will be created; its existing video, audio, prompt, and checkpoint files remain shared. Nothing is regenerated or copied.",
+        );
+        if (!confirmed) return;
+        setBusy(true, "Attributing saved candidate to branch…");
+        try {
+            const payload = await jsonRequest(
+                "/minimax_h3_context_loop/checkpoint-revisions/attribute", {
+                    method:"POST", headers:{"Content-Type":"application/json"},
+                    body:JSON.stringify({
+                        run_name:state.runName,
+                        parent_scene:parent.scene,
+                        parent_revision:parent.revision,
+                        candidate_scene:candidate.scene,
+                        candidate_revision:candidate.revision,
+                    }),
+                });
+            state.attribution = null;
+            state.scene = Number(payload.scene);
+            state.revision = String(payload.revision);
+            await refreshCheckpoints();
+            // Attachment is an explicit branch edit, unlike a preview click.
+            const attached = (state.payload?.revisions ?? []).find(item =>
+                Number(item.scene) === Number(payload.scene) && item.revision === payload.revision);
+            if (attached) selectOutputBranch(checkpointOutputBranchTip(
+                state.payload, attached, chapterRangeFor(attached)) ?? attached);
+            status.className = "h3cm-status";
+            status.textContent = payload.message;
+        } catch (error) {
+            status.className = "h3cm-status h3cm-error";
+            status.textContent = error.message;
+        } finally {
+            setBusy(false);
+        }
+    }
+
+    async function loadSelected() {
+        const record = state.selected;
+        const lineage = selectedLineage();
+        const scope = selectedChapterRange();
+        if (!record || !canLoadSelected() || state.busy) return;
+        const planNode = upstreamPlanNode(node);
+        if (!planNode || !widget(planNode, "plan_json")) {
+            status.className = "h3cm-status h3cm-error";
+            status.textContent = "Connect the Checkpoint Manager to an editable H3 Chain Plan first.";
+            return;
+        }
+        const confirmed = window.confirm(
+            `Load ${state.runName} through scene ${record.scene} revision ${record.revision.slice(0, 8)}?\n\n` +
+            "This activates the branch project-wide and restores the connected Plan. For output only, cancel and choose Use branch locally.\n\n" +
+            `${scope.title} scenes ${scope.start}–${scope.end} will use this branch. Other chapters keep their active checkpoint branches. Saved revision files are kept.`,
+        );
+        if (!confirmed) return;
+        setBusy(true, "Loading saved Plan and checkpoint lineage…");
+        try {
+            const runQuery = new URLSearchParams({
+                run_name: state.runName,
+                include_assets: "false",
+            });
+            const runBody = await jsonRequest(
+                `/minimax_h3_context_loop/run?${runQuery.toString()}`,
+            );
+            const sameConnectedRun = activePlanRun() === state.runName;
+            const savedPlan = parsePlanJson(String(sameConnectedRun
+                ? widget(planNode, "plan_json")?.value ?? ""
+                : runBody.plan_inputs?.plan_json ?? ""));
+            const chapters = state.payload?.editorial?.chapters ?? [];
+            if (chapters.length) {
+                savedPlan.chapters = chapters.map((chapter) => ({
+                    id:chapter.id,
+                    title:chapter.title,
+                    start_scene_id:chapter.start_scene_id,
+                    text:chapter.text ?? "",
+                }));
+            }
+            if (savedPlan.shots.length < Number(record.scene)) {
+                throw new Error(
+                    `The saved Plan has only ${savedPlan.shots.length} scenes.`,
+                );
+            }
+            const resumeScene = Number(record.scene) + 1;
+            if (resumeScene <= savedPlan.shots.length &&
+                    !widget(connectedNode(node, START_NAME), "start_clip")) {
+                throw new Error("Could not find the connected H3 Chain Loop Start node.");
+            }
+            const restored = await jsonRequest(
+                "/minimax_h3_context_loop/checkpoint-revisions/restore", {
+                    method:"POST", headers:{"Content-Type":"application/json"},
+                    body:JSON.stringify({
+                        run_name:state.runName,
+                        resume_scene:resumeScene,
+                        revisions:lineage,
+                        scope_start_scene:scope.start,
+                        scope_end_scene:scope.end,
+                    }),
+                });
+            const activePlan = sameConnectedRun ? planNode
+                : restoreSavedPlanInputs(
+                    {...runBody.plan_inputs, plan_json:planToJson(savedPlan)},
+                    restored.policy_inputs ?? runBody.policy_inputs,
+                );
+            const plan = applyLoadedRevisions(activePlan, restored.restored ?? []);
+            const canResume = resumeScene <= plan.shots.length &&
+                resumeScene <= scope.end;
+            if (canResume && !prepareResume(resumeScene)) {
+                throw new Error("Loaded the branch, but could not arm H3 Chain Loop Start.");
+            }
+            await refreshCheckpoints();
+            status.className = "h3cm-status";
+            status.textContent = canResume
+                ? `Loaded ${scope.title} scenes ${scope.start}–${record.scene}; Loop Start is armed for scene ${resumeScene}.`
+                : `Loaded ${scope.title} through scene ${record.scene}; other chapters were preserved.`;
+        } catch (error) {
+            status.className = "h3cm-status h3cm-error";
+            status.textContent = error.message;
+        } finally {
+            setBusy(false);
+        }
+    }
+
+    async function activateSelected() {
+        const record = state.selected;
+        const lineage = selectedLineage();
+        const scope = selectedChapterRange();
+        const activationMode = selectedActivationMode();
+        const rollsBack = activationMode === "rollback";
+        if (!record || !canActivateSelected() || state.busy) return;
+        const confirmed = window.confirm(
+            `${rollsBack ? "Roll" : "Make"} ${scope.title} ${rollsBack ? "back" : "active"} through scene ${record.scene} revision ${record.revision.slice(0, 8)}?\n\n` +
+            "This changes the project-wide active branch for all workflows using this Run. Use branch locally changes only this manager's output.\n\n" +
+            `${rollsBack ? `Active pointers after scene ${record.scene} will be cleared. ` : ""}` +
+            `Only scenes ${scope.start}–${scope.end} are affected. Other chapters keep their active branches. If a Plan is connected, the selected chapter's saved scene settings are restored. No saved revision, workflow, reference, or assembled video is deleted.`,
+        );
+        if (!confirmed) return;
+        setBusy(true, rollsBack
+            ? "Rolling active checkpoint branch back…"
+            : "Promoting selected checkpoint lineage…");
+        try {
+            const payload = await jsonRequest(
+                "/minimax_h3_context_loop/checkpoint-revisions/restore", {
+                    method:"POST", headers:{"Content-Type":"application/json"},
+                    body:JSON.stringify({
+                        run_name:state.runName,
+                        resume_scene:Number(record.scene) + 1,
+                        revisions:lineage,
+                        activate_only:true,
+                        scope_start_scene:scope.start,
+                        scope_end_scene:scope.end,
+                    }),
+                });
+            const planNode = upstreamPlanNode(node);
+            const planUpdated = Boolean(planNode &&
+                applyActivatedRevisions(planNode, payload.restored ?? []));
+            await refreshCheckpoints();
+            status.className = "h3cm-status";
+            status.textContent = `${scope.title} ${rollsBack ? "rolled back" : "is now active"} through scene ${record.scene} revision ${record.revision.slice(0, 8)}. ` +
+                `${payload.retired_scope_pointers || 0} later pointer${payload.retired_scope_pointers === 1 ? " was" : "s were"} cleared inside this chapter; other chapters were preserved; all immutable revisions were kept` +
+                `${planUpdated ? "; connected Plan scene settings were restored." : "."}`;
+        } catch (error) {
+            status.className = "h3cm-status h3cm-error";
+            status.textContent = error.message;
+        } finally {
+            setBusy(false);
+        }
+    }
+
+    async function retireChapterSnapshot(reference) {
+        const runName = state.runName, record = state.selected;
+        if (state.busy || state.stage !== "original" || state.attribution || !record) return;
+        setBusy(true, "Inspecting chapter snapshot retirement…");
+        try {
+            const plan = await jsonRequest(
+                "/minimax_h3_context_loop/chapter-snapshots/retire-preview", {
+                    method:"POST", headers:{"Content-Type":"application/json"},
+                    body:JSON.stringify({run_name:runName, path:reference.path}),
+                });
+            // A slow response must not apply to a different run or selection.
+            if (state.runName !== runName || state.selected !== record || state.stage !== "original") return;
+            const scenes = (plan.scenes ?? []).map(item =>
+                `Scene ${item.scene} · ${String(item.revision).slice(0, 8)}${item.active ? " · currently active" : ""}`).join("\n");
+            if (!window.confirm(
+                `Retire Chapter ${plan.chapter_number} snapshot ${plan.chapter_manifest_id.slice(0, 8)}?\n\n` +
+                `${scenes}\n\n${plan.message}\n\n` +
+                `Archive: ${plan.retired_path}\n\n` +
+                "This snapshot will no longer load in Chapter Loader or protect its old takes from cleanup. " +
+                "Workflows pinned to it need a new source. Deleting its inputs later makes full recovery unavailable. " +
+                "Other snapshots and branch dependencies remain protected.")) {
+                status.textContent = "Snapshot retirement cancelled; nothing changed.";
+                return;
+            }
+            const result = await jsonRequest(
+                "/minimax_h3_context_loop/chapter-snapshots/retire", {
+                    method:"POST", headers:{"Content-Type":"application/json"},
+                    body:JSON.stringify({run_name:runName, path:plan.path, snapshot:plan.snapshot}),
+                });
+            await refreshDeletionPreview();
+            status.className = "h3cm-status";
+            status.textContent = result.message;
+        } catch (error) {
+            await refreshDeletionPreview();
+            status.className = "h3cm-status h3cm-error";
+            status.textContent = error.message;
+        } finally {
+            setBusy(false);
+        }
+    }
+
+    async function deleteSelected() {
+        if (state.stage !== "original") return deleteProcessedVersion();
+        const record = state.selected;
+        const plan = state.deletion;
+        if (!record || !plan?.allowed || state.busy) return;
+        const confirmed = window.confirm(
+            `${plan.rollback ? "Roll back and permanently delete" : "Permanently delete"} scene ${record.scene} revision ${record.revision.slice(0, 8)}?\n\n` +
+            `${plan.owned_file_count} owned files · ${formatCheckpointBytes(plan.reclaimed_bytes)}\n` +
+            `${plan.rollback ? (plan.rollback_to_scene > 0
+                ? `The active chain will roll back through scene ${plan.rollback_to_scene}. `
+                : "The run will have no active checkpoint scenes. ") : ""}` +
+            "Run archives, references, prompt history, and assembled exports are kept. This cannot be undone.",
+        );
+        if (!confirmed) return;
+        setBusy(true, "Deleting staged revision files…");
+        try {
+            const payload = await jsonRequest(
+                "/minimax_h3_context_loop/checkpoint-revisions/delete", {
+                    method:"POST", headers:{"Content-Type":"application/json"},
+                    body:JSON.stringify({run_name:state.runName, scene:record.scene,
+                        revision:record.revision, snapshot:plan.snapshot}),
+                });
+            state.scene = payload.rollback ? payload.rollback_to_scene : state.scene;
+            state.revision = "";
+            await refreshCheckpoints();
+            status.className = "h3cm-status";
+            status.textContent = `${payload.message} Reclaimed ${formatCheckpointBytes(payload.reclaimed_bytes)}.`;
+        } catch (error) {
+            state.deletion = error.payload?.preview ?? state.deletion;
+            status.className = "h3cm-status h3cm-error";
+            status.textContent = error.message;
+            renderDeletion();
+        } finally {
+            setBusy(false);
+        }
+    }
+
+    async function deleteProcessedVersion() {
+        const record = currentVariant(), plan = state.deletion, runName = state.runName;
+        if (state.busy || !record || !plan?.allowed || plan.metadata_path !== record.key) return;
+        const confirmed = window.confirm(
+            `Permanently delete ${stageLabel()} scene ${record.scene} take ${record.revision.slice(0, 8)} (${record.profile})?\n\n` +
+            `${plan.owned_file_count} files · ${formatCheckpointBytes(plan.reclaimed_bytes)}\n` +
+            "Its current processed pointer and affected branch manifests will be cleared. Original clips, shared references, other takes and assembled videos are kept. " +
+            (plan.retained_independent_takes?.length
+                ? "Later independent pixel clips are kept; rebuild missing scenes before full-sequence resume. " : "") +
+            "This cannot be undone.");
+        if (!confirmed) return;
+        setBusy(true, "Deleting processed version…");
+        try {
+            const payload = await jsonRequest(
+                "/minimax_h3_context_loop/processing-checkpoints/delete", {
+                    method:"POST", headers:{"Content-Type":"application/json"},
+                    body:JSON.stringify({run_name:runName, metadata_path:record.key, snapshot:plan.snapshot}),
+                });
+            // Keep the vanished browse key and output pin: never substitute a different take.
+            await refreshCheckpoints();
+            status.className = "h3cm-status";
+            status.textContent = `${payload.message} Reclaimed ${formatCheckpointBytes(payload.reclaimed_bytes)}.`;
+            let selection;
+            try { selection = JSON.parse(selectionWidget?.value || "null"); } catch { /* unchanged invalid selection */ }
+            if (selection?.processing_source?.branch?.lineage?.some(item => item.metadata_path === record.key)) {
+                status.textContent += " This workflow's output pin referenced the deleted take; explicitly select another source branch before running.";
+            }
+            if (payload.cleanup_pending?.length) status.textContent += ` Cleanup pending: ${payload.cleanup_pending.join(", ")}`;
+        } catch (error) {
+            state.deletion = error.payload?.preview ?? null;
+            status.className = "h3cm-status h3cm-error";
+            status.textContent = error.message;
+            renderDeletion();
+        } finally {
+            setBusy(false);
+        }
+    }
+
+    runSelect.addEventListener("change", () => {
+        if (checkpointLocalSelection(selectionWidget?.value)) {
+            if (!window.confirm("Switch runs and release this workflow's local output pin? The project active branches will not change.")) {
+                runSelect.value = state.runName;
+                return;
+            }
+            writeOutputSelection("");
+        }
+        state.runName = runSelect.value;
+        state.payload = null;
+        state.selected = null;
+        state.outputTip = state.previewTip = null;
+        state.scene = null;
+        state.revision = "";
+        persistSelection();
+        void refreshCheckpoints();
+    });
+
+    const domWidget = node.addDOMWidget("h3_checkpoint_manager", "h3-checkpoint-manager", root, {
+        serialize:false, hideOnZoom:false, getMinHeight:() => 620,
+    });
+    domWidget.serialize = false;
+    node.setSize?.([
+        Math.max(Number(node.size?.[0]) || 0, 900),
+        Math.max(Number(node.size?.[1]) || 0, 760),
+    ]);
+    const connectionsChanged = node.onConnectionsChange;
+    node.onConnectionsChange = function () {
+        const result = connectionsChanged?.apply(this, arguments);
+        window.setTimeout(() => {
+            const connected = activePlanRun();
+            if (connected && connected !== state.runName && !checkpointLocalSelection(selectionWidget?.value)) {
+                state.runName = connected;
+                void refreshRuns();
+            }
+        }, 0);
+        return result;
+    };
+    node._h3CheckpointManagerRefresh = () => void refreshRuns();
+    node._h3CheckpointManagerConfigured = () => {
+        // Configuration can arrive after mount, including undo/redo and tab
+        // restores. Hydrate the scope before refresh can persist a selection.
+        bindSelectionSerializer();
+        restoreOutputScope();
+        state.runName = String(node.properties[RUN_PROPERTY] ?? "");
+        state.scene = Number(node.properties[SCENE_PROPERTY]) || null;
+        state.revision = String(node.properties[REVISION_PROPERTY] ?? "");
+        state.chapterTab = String(node.properties[CHAPTER_PROPERTY] ?? "all");
+        state.stage = CHECKPOINT_STAGES.some(item => item.id === node.properties[STAGE_PROPERTY])
+            ? node.properties[STAGE_PROPERTY] : "original";
+        state.variantKey = String(node.properties[VARIANT_PROPERTY] ?? "");
+        state.initialRefresh = !state.scene || !state.revision;
+    };
+    bindSelectionSerializer();
+    const serialized = node.onSerialize;
+    node.onSerialize = function (saved) {
+        if (selectionWidget) selectionWidget.value = outputSelectionForScope(selectionWidget.value);
+        node.properties[OUTPUT_SCOPE_PROPERTY] = outputScope.value;
+        const result = serialized?.apply(this, arguments);
+        if (saved) {
+            saved.properties ??= {};
+            saved.properties[OUTPUT_SCOPE_PROPERTY] = outputScope.value;
+            const index = node.widgets?.indexOf(selectionWidget) ?? -1;
+            if (index >= 0 && Array.isArray(saved.widgets_values)) saved.widgets_values[index] = selectionWidget.value;
+            if (selectionWidget && saved.widgets_values_named) saved.widgets_values_named.selection_json = selectionWidget.value;
+        }
+        return result;
+    };
+    const removed = node.onRemoved;
+    node.onRemoved = function () {
+        return removed?.apply(this, arguments);
+    };
+    void refreshRuns();
+}
+
+app.registerExtension({
+    name:"minimax_h3_context_loop.checkpoint_manager",
+    async beforeRegisterNodeDef(nodeTypeClass, nodeData) {
+        if (nodeData.name !== NODE_NAME) return;
+        const created = nodeTypeClass.prototype.onNodeCreated;
+        nodeTypeClass.prototype.onNodeCreated = function () {
+            const result = created?.apply(this, arguments);
+            window.setTimeout(() => mount(this), 0);
+            return result;
+        };
+        const configured = nodeTypeClass.prototype.onConfigure;
+        nodeTypeClass.prototype.onConfigure = function () {
+            const result = configured?.apply(this, arguments);
+            this._h3CheckpointManagerConfigured?.();
+            window.setTimeout(() => this._h3CheckpointManagerRefresh?.(), 0);
+            return result;
+        };
+    },
+    async nodeCreated(node) {
+        if (nodeType(node) === NODE_NAME) mount(node);
+    },
+});
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_lora_scheduler.js b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_lora_scheduler.js
new file mode 100644
index 0000000000000000000000000000000000000000..7bafed133232e7716c2e286e0a3dc722174d8fb2
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_lora_scheduler.js
@@ -0,0 +1,91 @@
+import {app} from "/scripts/app.js";
+import {
+    LORA_ROUTE_LETTERS,
+    LORA_SCHEDULER_NODE,
+    connectedLoRARoutes,
+    loraInputRoute,
+    nextLoRARoute,
+} from "./h3_lora_scheduler_core.mjs?v=0.6.2";
+
+const ROUTES_CHANGED_EVENT = "h3-lora-routes-changed";
+
+function publishRoutes(node, routes) {
+    const signature = routes.join(",");
+    if (node._h3LoRARouteSignature === signature) return;
+    node._h3LoRARouteSignature = signature;
+    document.dispatchEvent(new CustomEvent(ROUTES_CHANGED_EVENT, {
+        detail: {nodeId: node.id, routes},
+    }));
+}
+
+function stabilizeRouteInputs(node) {
+    const routes = connectedLoRARoutes(node);
+    const next = nextLoRARoute(node);
+    for (let index = (node.inputs?.length ?? 0) - 1; index >= 0; index -= 1) {
+        const input = node.inputs[index];
+        const route = loraInputRoute(input.name);
+        if (route && input.link == null && route !== next) node.removeInput(index);
+    }
+    if (next && !node.inputs?.some(
+        (input) => input.name === `lora_${next}`,
+    )) node.addInput(`lora_${next}`, "MODEL");
+    for (const input of node.inputs ?? []) {
+        const route = loraInputRoute(input.name);
+        if (!route) continue;
+        input.label = input.link == null
+            ? `Connect next LoRA route · ${route.toUpperCase()}`
+            : `LoRA ${route.toUpperCase()}`;
+    }
+    node.properties ??= {};
+    node.properties.h3_lora_routes = routes;
+    publishRoutes(node, routes);
+    node.graph?.setDirtyCanvas?.(true, true);
+}
+
+function mount(node) {
+    if (node._h3LoRASchedulerMounted) return;
+    node._h3LoRASchedulerMounted = true;
+    const changed = node.onConnectionsChange;
+    node.onConnectionsChange = function () {
+        const result = changed?.apply(this, arguments);
+        setTimeout(() => stabilizeRouteInputs(this), 0);
+        return result;
+    };
+    node._h3LoRASchedulerRefresh = () => stabilizeRouteInputs(node);
+    setTimeout(() => stabilizeRouteInputs(node), 0);
+}
+
+app.registerExtension({
+    name: "minimax_h3_context_loop.dynamic_lora_scheduler",
+    async beforeRegisterNodeDef(nodeType, nodeData) {
+        if (nodeData.name !== LORA_SCHEDULER_NODE) return;
+        const created = nodeType.prototype.onNodeCreated;
+        nodeType.prototype.onNodeCreated = function () {
+            const result = created?.apply(this, arguments);
+            setTimeout(() => mount(this), 0);
+            return result;
+        };
+        const configured = nodeType.prototype.onConfigure;
+        nodeType.prototype.onConfigure = function () {
+            const result = configured?.apply(this, arguments);
+            setTimeout(() => this._h3LoRASchedulerRefresh?.(), 0);
+            return result;
+        };
+        const graphConfigured = nodeType.prototype.onGraphConfigured;
+        nodeType.prototype.onGraphConfigured = function () {
+            const result = graphConfigured?.apply(this, arguments);
+            setTimeout(() => this._h3LoRASchedulerRefresh?.(), 0);
+            return result;
+        };
+    },
+    async nodeCreated(node) {
+        if ((node?.comfyClass ?? node?.type) === LORA_SCHEDULER_NODE) mount(node);
+    },
+    async afterConfigureGraph() {
+        for (const node of app.graph?._nodes ?? []) {
+            if ((node?.comfyClass ?? node?.type) === LORA_SCHEDULER_NODE) {
+                setTimeout(() => node._h3LoRASchedulerRefresh?.(), 0);
+            }
+        }
+    },
+});
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_plan_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_plan_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..baa0404f6417ed30debe836f04fb6aa414735d5e
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_plan_core.mjs
@@ -0,0 +1,1898 @@
+// Pure data helpers for the H3 Chain Plan editor. Keep this module free of
+// ComfyUI/browser dependencies so its timing and serialization can be tested.
+
+export const FPS = 24;
+export const MAX_SHOTS = 128;
+export const MAX_CHAPTERS = MAX_SHOTS;
+export const MAX_H3_FRAMES = 3592;
+export const MAX_SEED = 18446744073709551615n;
+export const CONTINUATION_MODES = Object.freeze([
+    "guide", "tone_carry_guide", "latent_guide", "tapered_guide",
+    "masked_av", "tapered_av", "feathered_av", "audio_feathered_av",
+    "drift_control_av", "color_stable_drift_av",
+]);
+export const CONTEXT_SPATIAL_PROXY_MODES = Object.freeze([
+    "off", "rgb_5_6", "latent_5_6",
+]);
+export const SCENE_LORA_ROUTES = Object.freeze([
+    "base", ..."abcdefghijklmnopqrstuvwxyz",
+]);
+export const SCENE_PROMPT_SEED_MODES = Object.freeze([
+    "inherit", "fixed", "randomize",
+]);
+const RETIRED_CONTINUATION_MODES = Object.freeze({
+    feathered_av_rgb: "feathered_av",
+});
+export const H3_CONTEXT_LENGTHS = Object.freeze([
+    1, 5, 22, 39, 56, 73, 90, 107, 124,
+    141, 158, 175, 192, 209, 226, 243,
+]);
+export const AV_CONTEXT_LENGTHS = Object.freeze([39, 90, 141, 192, 243]);
+export const VIDEO_ONLY_AV_CONTEXT_LENGTHS = Object.freeze(
+    H3_CONTEXT_LENGTHS.filter((value) => value >= 5),
+);
+export const AUTO_SCENE_COLORS = Object.freeze([
+    "#6ea8fe", "#ffb86b", "#63d69f", "#c493ff",
+    "#ff7fa6", "#55d6e8", "#e6cb65", "#ff7878",
+    "#83c5ff", "#b7db68", "#d991ff", "#72d4c2",
+]);
+
+export function automaticSceneColor(index) {
+    const ordinal = Number.isFinite(Number(index)) ? Math.trunc(Number(index)) : 0;
+    return AUTO_SCENE_COLORS[((ordinal % AUTO_SCENE_COLORS.length)
+        + AUTO_SCENE_COLORS.length) % AUTO_SCENE_COLORS.length];
+}
+
+function normalizedSeedInteger(value, label = "Seed") {
+    try {
+        const seed = typeof value === "bigint" ? value : BigInt(value ?? 0);
+        if (seed < 0n || seed > MAX_SEED) throw new Error();
+        return seed;
+    } catch (_error) {
+        throw new Error(`${label} must be an unsigned 64-bit integer.`);
+    }
+}
+
+const SHA256_CONSTANTS = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,
+    0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,
+    0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,
+    0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,
+    0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
+    0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,
+    0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
+    0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,
+    0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+
+function rotateRight(value, bits) {
+    return (value >>> bits) | (value << (32 - bits));
+}
+
+function sha256Fallback(bytes) {
+    const length = Math.ceil((bytes.length + 9) / 64) * 64;
+    const padded = new Uint8Array(length);
+    padded.set(bytes);
+    padded[bytes.length] = 0x80;
+    const bitLength = BigInt(bytes.length) * 8n;
+    const view = new DataView(padded.buffer);
+    view.setUint32(length - 8, Number((bitLength >> 32n) & 0xffffffffn));
+    view.setUint32(length - 4, Number(bitLength & 0xffffffffn));
+    const state = new Uint32Array([
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a,
+        0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+    ]);
+    const words = new Uint32Array(64);
+    for (let offset = 0; offset < length; offset += 64) {
+        for (let index = 0; index < 16; index += 1) {
+            words[index] = view.getUint32(offset + index * 4);
+        }
+        for (let index = 16; index < 64; index += 1) {
+            const left = words[index - 15];
+            const right = words[index - 2];
+            const sigma0 = rotateRight(left, 7) ^ rotateRight(left, 18) ^ (left >>> 3);
+            const sigma1 = rotateRight(right, 17) ^ rotateRight(right, 19) ^ (right >>> 10);
+            words[index] = (words[index - 16] + sigma0
+                + words[index - 7] + sigma1) >>> 0;
+        }
+        let [a, b, c, d, e, f, g, h] = state;
+        for (let index = 0; index < 64; index += 1) {
+            const sum1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+            const choose = (e & f) ^ (~e & g);
+            const temporary1 = (h + sum1 + choose
+                + SHA256_CONSTANTS[index] + words[index]) >>> 0;
+            const sum0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+            const majority = (a & b) ^ (a & c) ^ (b & c);
+            const temporary2 = (sum0 + majority) >>> 0;
+            h = g;
+            g = f;
+            f = e;
+            e = (d + temporary1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (temporary1 + temporary2) >>> 0;
+        }
+        for (const [index, value] of [a, b, c, d, e, f, g, h].entries()) {
+            state[index] = (state[index] + value) >>> 0;
+        }
+    }
+    const digest = new Uint8Array(32);
+    const digestView = new DataView(digest.buffer);
+    state.forEach((value, index) => digestView.setUint32(index * 4, value));
+    return digest;
+}
+
+export async function derivedSceneSeed(
+    baseSeed, index, shotId, cryptoSource = globalThis.crypto,
+) {
+    const seedBase = normalizedSeedInteger(baseSeed, "Base seed");
+    const ordinal = Number(index);
+    if (!Number.isInteger(ordinal) || ordinal < 1) {
+        throw new Error("Scene index must be a positive integer.");
+    }
+    const payload = `${seedBase}:${ordinal}:${String(shotId)}`;
+    const encoded = new TextEncoder().encode(payload);
+    const digest = typeof cryptoSource?.subtle?.digest === "function"
+        ? new Uint8Array(await cryptoSource.subtle.digest("SHA-256", encoded))
+        : sha256Fallback(encoded);
+    const bytes = digest.subarray(0, 8);
+    let result = 0n;
+    for (const byte of bytes) result = (result << 8n) | BigInt(byte);
+    return result.toString();
+}
+
+export function randomSceneSeed(randomSource = globalThis.crypto) {
+    if (typeof randomSource?.getRandomValues !== "function") {
+        throw new Error("Secure browser randomness is unavailable.");
+    }
+    const words = new Uint32Array(2);
+    randomSource.getRandomValues(words);
+    return ((BigInt(words[0]) << 32n) | BigInt(words[1])).toString();
+}
+
+export function scenePromptSeedMode(shot = {}) {
+    const raw = shot?.prompt_seed_mode;
+    if (raw == null || String(raw).trim() === "") {
+        return Object.hasOwn(shot ?? {}, "prompt_seed") ? "fixed" : "inherit";
+    }
+    const mode = String(raw).trim().toLowerCase();
+    if (!SCENE_PROMPT_SEED_MODES.includes(mode)) {
+        throw new Error(
+            `Prompt seed mode must be one of ${SCENE_PROMPT_SEED_MODES.join(", ")}.`,
+        );
+    }
+    return mode;
+}
+
+export function setScenePromptSeedMode(
+    shot, requested, randomSource = globalThis.crypto,
+) {
+    const mode = String(requested ?? "inherit").trim().toLowerCase();
+    if (!SCENE_PROMPT_SEED_MODES.includes(mode)) {
+        throw new Error(
+            `Prompt seed mode must be one of ${SCENE_PROMPT_SEED_MODES.join(", ")}.`,
+        );
+    }
+    if (mode === "inherit") {
+        delete shot.prompt_seed_mode;
+        delete shot.prompt_seed;
+    } else if (mode === "randomize") {
+        shot.prompt_seed_mode = "randomize";
+        delete shot.prompt_seed;
+    } else {
+        shot.prompt_seed_mode = "fixed";
+        if (!Object.hasOwn(shot, "prompt_seed")) {
+            shot.prompt_seed = randomSceneSeed(randomSource);
+        } else {
+            shot.prompt_seed = normalizedSeedInteger(
+                shot.prompt_seed, "Prompt seed",
+            ).toString();
+        }
+    }
+    return mode;
+}
+
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+
+function protectSeedIntegers(source) {
+    // JSON.parse rounds integers above 2^53. The Python node accepts seed
+    // strings, so quote numeric `seed` values before parsing and preserve all
+    // uint64 digits exactly. This scanner only touches actual JSON object keys,
+    // never text that happens to contain `\"seed\": 123` inside a prompt.
+    let output = "";
+    let index = 0;
+    while (index < source.length) {
+        if (source[index] !== '"') {
+            output += source[index++];
+            continue;
+        }
+
+        const start = index;
+        index += 1;
+        while (index < source.length) {
+            if (source[index] === "\\") {
+                index += 2;
+                continue;
+            }
+            if (source[index] === '"') {
+                index += 1;
+                break;
+            }
+            index += 1;
+        }
+        const token = source.slice(start, index);
+        output += token;
+
+        let key;
+        try {
+            key = JSON.parse(token);
+        } catch (_error) {
+            continue;
+        }
+        if (key !== "seed" && key !== "prompt_seed") {
+            continue;
+        }
+
+        let cursor = index;
+        while (/\s/.test(source[cursor] || "")) cursor += 1;
+        if (source[cursor] !== ":") continue;
+        cursor += 1;
+        while (/\s/.test(source[cursor] || "")) cursor += 1;
+        const match = source.slice(cursor).match(/^-?\d+(?=\s*[,}])/);
+        if (!match) continue;
+
+        output += source.slice(index, cursor);
+        output += JSON.stringify(match[0]);
+        index = cursor + match[0].length;
+    }
+    return output;
+}
+
+export function promptValueToText(value, label = "prompt") {
+    if (Array.isArray(value)) {
+        if (!value.every((line) => typeof line === "string")) {
+            throw new Error(`${label} line arrays may contain only strings.`);
+        }
+        return value.join("\n");
+    }
+    if (value === undefined || value === null) return "";
+    return String(value);
+}
+
+export function promptTextToLines(value) {
+    return String(value ?? "").replace(/\r\n?/g, "\n").split("\n");
+}
+
+export function parsePlanJson(source) {
+    let raw;
+    try {
+        raw = JSON.parse(protectSeedIntegers(String(source ?? "")));
+    } catch (error) {
+        throw new Error(`Invalid plan JSON: ${error.message}`);
+    }
+    if (Array.isArray(raw)) raw = {shots: raw};
+    if (!raw || typeof raw !== "object") {
+        throw new Error("The plan must be an object or a bare list of scenes.");
+    }
+    if (!Array.isArray(raw.shots) || raw.shots.length === 0) {
+        throw new Error("The plan needs at least one scene in shots.");
+    }
+    if (raw.shots.length > MAX_SHOTS) {
+        throw new Error(`The plan supports at most ${MAX_SHOTS} scenes.`);
+    }
+
+    const plan = clone(raw);
+    const hasTopLevelDefaults = Object.hasOwn(plan, "duration_seconds")
+        || Object.hasOwn(plan, "steps");
+    if (hasTopLevelDefaults) {
+        const defaults = plan.defaults
+            && typeof plan.defaults === "object"
+            && !Array.isArray(plan.defaults)
+            ? {...plan.defaults} : {};
+        // Accept the common human-authored shorthand and serialize it back in
+        // the canonical shape. Explicit defaults.* values win when both forms
+        // are present.
+        if (!Object.hasOwn(defaults, "duration_seconds")
+            && Object.hasOwn(plan, "duration_seconds")) {
+            defaults.duration_seconds = plan.duration_seconds;
+        }
+        if (!Object.hasOwn(defaults, "steps") && Object.hasOwn(plan, "steps")) {
+            defaults.steps = plan.steps;
+        }
+        plan.defaults = defaults;
+        delete plan.duration_seconds;
+        delete plan.steps;
+    }
+    plan.shots = plan.shots.map((shot, offset) => {
+        if (typeof shot === "string") {
+            return {prompt: promptTextToLines(shot)};
+        }
+        if (!shot || typeof shot !== "object" || Array.isArray(shot)) {
+            throw new Error(`Scene ${offset + 1} must be an object or prompt string.`);
+        }
+        const normalized = {...shot};
+        normalized.prompt = promptTextToLines(
+            promptValueToText(shot.prompt, `Scene ${offset + 1} prompt`),
+        );
+        if (Object.hasOwn(normalized, "lora_route")) {
+            const route = sceneLoRARoute(normalized);
+            if (route === "base") delete normalized.lora_route;
+            else normalized.lora_route = route;
+        }
+        if (Object.hasOwn(normalized, "prompt_seed_mode")
+                || Object.hasOwn(normalized, "prompt_seed")) {
+            const mode = scenePromptSeedMode(normalized);
+            if (mode === "inherit") {
+                delete normalized.prompt_seed_mode;
+                delete normalized.prompt_seed;
+            } else if (mode === "randomize") {
+                normalized.prompt_seed_mode = "randomize";
+                delete normalized.prompt_seed;
+            } else {
+                if (!Object.hasOwn(normalized, "prompt_seed")) {
+                    throw new Error(
+                        `Scene ${offset + 1} fixed prompt seed needs prompt_seed.`,
+                    );
+                }
+                normalized.prompt_seed_mode = "fixed";
+                normalized.prompt_seed = normalizedSeedInteger(
+                    normalized.prompt_seed,
+                    `Scene ${offset + 1} prompt seed`,
+                ).toString();
+            }
+        }
+        return normalized;
+    });
+
+    const shotIds = plan.shots.map((shot, offset) => safeShotId(
+        shot?.id,
+        `clip_${String(offset + 1).padStart(4, "0")}`,
+    ));
+    const shotIdSet = new Set(shotIds);
+    if (Object.hasOwn(plan, "chapters")) {
+        if (!Array.isArray(plan.chapters)) {
+            throw new Error("chapters must be a list.");
+        }
+        if (plan.chapters.length > MAX_CHAPTERS) {
+            throw new Error(`The plan supports at most ${MAX_CHAPTERS} chapters.`);
+        }
+        const usedIds = new Set();
+        const usedStarts = new Set();
+        plan.chapters = plan.chapters.map((chapter, offset) => {
+            if (!chapter || typeof chapter !== "object" || Array.isArray(chapter)) {
+                throw new Error(`Chapter ${offset + 1} must be an object.`);
+            }
+            const fallbackId = `chapter_${String(offset + 1).padStart(2, "0")}`;
+            const id = safeChapterId(chapter.id, fallbackId);
+            if (usedIds.has(id)) throw new Error(`Duplicate chapter id: ${id}.`);
+            usedIds.add(id);
+            const startSceneId = safeShotId(
+                chapter.start_scene_id,
+                shotIds[Math.min(offset, shotIds.length - 1)],
+            );
+            if (!shotIdSet.has(startSceneId)) {
+                throw new Error(
+                    `Chapter ${offset + 1} starts at missing scene ${startSceneId}.`,
+                );
+            }
+            if (usedStarts.has(startSceneId)) {
+                throw new Error(`Only one chapter may start at scene ${startSceneId}.`);
+            }
+            usedStarts.add(startSceneId);
+            return {
+                id,
+                title: String(chapter.title ?? `Chapter ${offset + 1}`).trim()
+                    .slice(0, 160) || `Chapter ${offset + 1}`,
+                start_scene_id: startSceneId,
+                text: promptValueToText(chapter.text ?? chapter.notes ?? "", `Chapter ${offset + 1} text`),
+                ...(chapter.resolution != null
+                    ? {resolution:normalizeChapterResolution(chapter.resolution)} : {}),
+            };
+        }).sort((left, right) => (
+            shotIds.indexOf(left.start_scene_id) - shotIds.indexOf(right.start_scene_id)
+        ));
+        if (plan.chapters.length === 0) delete plan.chapters;
+    }
+
+    if (Object.hasOwn(plan, "prompt_prefix")) {
+        plan.prompt_prefix = promptTextToLines(
+            promptValueToText(plan.prompt_prefix, "prompt_prefix"),
+        );
+    } else if (Object.hasOwn(plan, "global_prompt")) {
+        plan.global_prompt = promptTextToLines(
+            promptValueToText(plan.global_prompt, "global_prompt"),
+        );
+    }
+    return plan;
+}
+
+export function planToJson(plan) {
+    return JSON.stringify(plan, null, 2);
+}
+
+export function sharedPrompt(plan) {
+    const key = Object.hasOwn(plan, "prompt_prefix")
+        ? "prompt_prefix"
+        : Object.hasOwn(plan, "global_prompt") ? "global_prompt" : "prompt_prefix";
+    return {key, text: promptValueToText(plan[key] ?? "", key)};
+}
+
+export function setSharedPrompt(plan, text) {
+    const current = sharedPrompt(plan);
+    plan[current.key] = promptTextToLines(text);
+}
+
+export function safeShotId(value, fallback) {
+    let text = String(value ?? "").trim().replace(/[^A-Za-z0-9._-]+/g, "_");
+    text = text.replace(/^[._-]+|[._-]+$/g, "");
+    return (text || fallback).slice(0, 96);
+}
+
+export function renamePlanShot(plan, index, requestedId) {
+    const shots = Array.isArray(plan?.shots) ? plan.shots : [];
+    const position = Number(index);
+    if (!Number.isInteger(position) || position < 0 || position >= shots.length) {
+        throw new Error("Scene rename target is outside the Plan.");
+    }
+    const shot = shots[position];
+    const fallback = `clip_${String(position + 1).padStart(4, "0")}`;
+    const previousId = safeShotId(shot?.id, fallback);
+    const nextId = safeShotId(requestedId, previousId);
+    const duplicate = shots.some((candidate, offset) => (
+        offset !== position && safeShotId(
+            candidate?.id,
+            `clip_${String(offset + 1).padStart(4, "0")}`,
+        ) === nextId
+    ));
+    if (duplicate) {
+        throw new Error(`Another scene already uses the ID “${nextId}”.`);
+    }
+    if (nextId === previousId) return {previousId, id:nextId, changed:false};
+
+    shot.id = nextId;
+    for (const chapter of Array.isArray(plan?.chapters) ? plan.chapters : []) {
+        if (String(chapter?.start_scene_id ?? "") === previousId) {
+            chapter.start_scene_id = nextId;
+        }
+    }
+    // Authored visual-context links use stable scene IDs. Numeric spellings
+    // deliberately remain scene indexes and must not be rewritten as IDs.
+    if (!/^\d+$/.test(previousId)) {
+        for (const candidate of shots) {
+            for (const field of [
+                "visual_context_source", "visual_context_lead_source",
+                "audio_context_source", "audio_context_lead_source",
+            ]) {
+                if (String(candidate?.[field] ?? "").trim() === previousId) {
+                    candidate[field] = nextId;
+                }
+            }
+            for (const block of Array.isArray(
+                candidate?.visual_context_blocks,
+            ) ? candidate.visual_context_blocks : []) {
+                if (String(block?.source ?? "").trim() === previousId) {
+                    block.source = nextId;
+                }
+            }
+        }
+    }
+    return {previousId, id:nextId, changed:true};
+}
+
+export function normalizeChapterResolution(value) {
+    if (value == null) return null;
+    if (typeof value !== "object" || Array.isArray(value)
+            || Object.keys(value).length !== 2
+            || !["width", "height"].every((key) => (
+                Number.isInteger(value[key]) && value[key] >= 32
+                && value[key] <= 16384 && value[key] % 32 === 0
+            ))) {
+        throw new Error("Chapter width and height must be multiples of 32 between 32 and 16384.");
+    }
+    return {width:value.width, height:value.height};
+}
+
+export function safeChapterId(value, fallback = "chapter") {
+    return safeShotId(value, fallback);
+}
+
+export function orderedChapters(plan) {
+    const shots = Array.isArray(plan?.shots) ? plan.shots : [];
+    const order = new Map(shots.map((shot, offset) => [
+        safeShotId(shot?.id, `clip_${String(offset + 1).padStart(4, "0")}`),
+        offset,
+    ]));
+    return (Array.isArray(plan?.chapters) ? plan.chapters : [])
+        .filter((chapter) => order.has(chapter?.start_scene_id))
+        .slice()
+        .sort((left, right) => (
+            order.get(left.start_scene_id) - order.get(right.start_scene_id)
+        ));
+}
+
+export function uniqueChapterId(chapters, requested = "chapter") {
+    const used = new Set((chapters ?? []).map((chapter, offset) => safeChapterId(
+        chapter?.id,
+        `chapter_${String(offset + 1).padStart(2, "0")}`,
+    )));
+    const base = safeChapterId(requested, "chapter");
+    if (!used.has(base)) return base;
+    for (let suffix = 2; suffix <= MAX_CHAPTERS + 1; suffix += 1) {
+        const candidate = `${base}_${suffix}`.slice(0, 96);
+        if (!used.has(candidate)) return candidate;
+    }
+    return `${base}_${Date.now()}`.slice(0, 96);
+}
+
+export function makeChapter(plan, startIndex = 0) {
+    const shots = Array.isArray(plan?.shots) ? plan.shots : [];
+    const index = Math.max(0, Math.min(shots.length - 1, Number(startIndex) || 0));
+    const startSceneId = safeShotId(
+        shots[index]?.id,
+        `clip_${String(index + 1).padStart(4, "0")}`,
+    );
+    const chapters = Array.isArray(plan.chapters) ? plan.chapters : [];
+    if (chapters.some((chapter) => chapter?.start_scene_id === startSceneId)) {
+        throw new Error(`A chapter already starts before scene ${index + 1}.`);
+    }
+    const ordinal = chapters.length + 1;
+    const chapter = {
+        id: uniqueChapterId(chapters, `chapter_${String(ordinal).padStart(2, "0")}`),
+        title: `Chapter ${ordinal}`,
+        start_scene_id: startSceneId,
+        text: "",
+    };
+    plan.chapters = [...chapters, chapter];
+    return chapter;
+}
+
+export function removePlanShot(plan, index) {
+    const shots = Array.isArray(plan?.shots) ? plan.shots : [];
+    if (index < 0 || index >= shots.length) return null;
+    const removedId = safeShotId(
+        shots[index]?.id,
+        `clip_${String(index + 1).padStart(4, "0")}`,
+    );
+    const [removed] = shots.splice(index, 1);
+    if (Array.isArray(plan.chapters)) {
+        const replacement = shots[index] ?? shots[index - 1] ?? null;
+        const replacementId = replacement ? safeShotId(
+            replacement.id,
+            `clip_${String(Math.max(1, index + 1)).padStart(4, "0")}`,
+        ) : null;
+        const occupied = new Set(plan.chapters
+            .filter((chapter) => chapter.start_scene_id !== removedId)
+            .map((chapter) => chapter.start_scene_id));
+        plan.chapters = plan.chapters.filter((chapter) => {
+            if (chapter.start_scene_id !== removedId) return true;
+            if (!replacementId || occupied.has(replacementId)) return false;
+            chapter.start_scene_id = replacementId;
+            occupied.add(replacementId);
+            return true;
+        });
+        if (plan.chapters.length === 0) delete plan.chapters;
+    }
+    return removed;
+}
+
+export function uniqueShotId(shots, requested = "scene") {
+    const used = new Set(shots.map((shot, offset) => safeShotId(
+        shot?.id,
+        `clip_${String(offset + 1).padStart(4, "0")}`,
+    )));
+    const base = safeShotId(requested, "scene");
+    if (!used.has(base)) return base;
+    for (let suffix = 2; suffix <= MAX_SHOTS + 1; suffix += 1) {
+        const tail = `_${suffix}`;
+        const candidate = `${base.slice(0, 96 - tail.length)}${tail}`;
+        if (!used.has(candidate)) return candidate;
+    }
+    return `${base}_${Date.now()}`.slice(0, 96);
+}
+
+export function makeShot(shots = []) {
+    const ordinal = shots.length + 1;
+    return {
+        id: uniqueShotId(shots, `scene_${String(ordinal).padStart(2, "0")}`),
+        prompt: ["Describe this scene."],
+    };
+}
+
+export function duplicateShot(shots, index) {
+    if (!Array.isArray(shots) || !Number.isInteger(index)
+            || index < 0 || index >= shots.length) {
+        throw new Error("Scene duplication target is outside the Plan.");
+    }
+    const original = [...shots];
+    const ids = original.map((shot, offset) => safeShotId(
+        shot.id, `clip_${String(offset + 1).padStart(4, "0")}`,
+    ));
+    const duplicated = clone(shots[index]);
+    duplicated.id = uniqueShotId(shots, `${safeShotId(
+        duplicated.id,
+        `scene_${String(index + 1).padStart(2, "0")}`,
+    )}_copy`);
+    // Pin legacy implicit identities before insertion shifts their positions.
+    // Existing ID-based links and delegated prompts must keep naming the same
+    // original scene, not the new occupant of its old index.
+    original.forEach((shot, offset) => {
+        if (!String(shot.id ?? "").trim()) shot.id = ids[offset];
+    });
+    shots.splice(index + 1, 0, duplicated);
+
+    const authored = value => value !== undefined && value !== null
+        && !(typeof value === "string" && !value.trim());
+    function remap(shot, oldIndex, newIndex) {
+        function source(holder, key, followsPrevious = false) {
+            const raw = holder[key];
+            const numeric = typeof raw === "number" || (
+                typeof raw === "string" && /^\d+$/.test(raw.trim())
+            );
+            let prior;
+            if (numeric && Number.isInteger(Number(raw))) prior = Number(raw) - 1;
+            else if (typeof raw === "string") {
+                if (["", "previous", "immediate"].includes(raw.trim().toLowerCase())) return;
+                prior = ids.indexOf(raw.trim());
+                if (prior !== ids.lastIndexOf(raw.trim())) return;
+            } else return;
+            // Do not silently repair invalid authored references.
+            if (prior < 0 || prior >= oldIndex || !Number.isInteger(prior)) return;
+            const shifted = prior + (prior > index ? 1 : 0);
+            const next = followsPrevious && prior === oldIndex - 1
+                ? newIndex - 1 : shifted;
+            if (numeric) {
+                if (next !== prior) holder[key] = typeof raw === "number" ? next + 1 : String(next + 1);
+            } else if (followsPrevious && prior === oldIndex - 1
+                    && next !== shifted) {
+                // Purely numeric IDs are interpreted as positions by the
+                // validator, so use a numeric position for those targets.
+                const id = safeShotId(
+                    shots[next].id, `clip_${String(next + 1).padStart(4, "0")}`,
+                );
+                holder[key] = /^\d+$/.test(String(id).trim()) ? next + 1 : id;
+            }
+        }
+        for (const kind of ["visual", "audio"]) {
+            // A plain predecessor tail follows the newly inserted scene.
+            // Explicit windows, composed context and deliberately older
+            // sources retain their original clip identities and frame ranges.
+            const linear = !authored(shot[`${kind}_context_start_frame`])
+                && !authored(shot[`${kind}_context_lead_source`])
+                && !Object.hasOwn(shot, `${kind}_context_blocks`);
+            source(shot, `${kind}_context_source`, linear);
+            source(shot, `${kind}_context_lead_source`);
+        }
+        if (Array.isArray(shot.visual_context_blocks)) {
+            for (const block of shot.visual_context_blocks) {
+                if (!block || typeof block !== "object" || Array.isArray(block)) continue;
+                source(block, "source", shot.visual_context_blocks.length === 1
+                    && !authored(block.start_frame));
+            }
+        }
+    }
+    original.forEach((shot, offset) => remap(
+        shot, offset, offset + (offset > index ? 1 : 0),
+    ));
+    remap(duplicated, index, index + 1);
+    return duplicated;
+}
+
+export function moveShot(shots, from, to) {
+    if (from === to || from < 0 || from >= shots.length || to < 0 || to >= shots.length) {
+        return;
+    }
+    const [shot] = shots.splice(from, 1);
+    shots.splice(to, 0, shot);
+}
+
+export function h3FrameLength(seconds) {
+    const numeric = Number(seconds);
+    if (!Number.isFinite(numeric) || numeric <= 0) {
+        throw new Error("Duration must be a finite positive number.");
+    }
+    const requested = Math.max(5, Math.ceil(numeric * FPS - 1e-9));
+    const length = requested + ((5 - (requested % 17)) % 17);
+    if (length > MAX_H3_FRAMES) {
+        throw new Error(
+            `Duration rounds to ${length} frames; H3's largest valid length is ${MAX_H3_FRAMES}.`,
+        );
+    }
+    return length;
+}
+
+export function shotLengthMode(shot) {
+    if (shot?.length !== undefined || shot?.frames !== undefined) return "frames";
+    if (shot?.duration_seconds !== undefined) return "seconds";
+    return "default";
+}
+
+export function setShotLengthMode(shot, mode, fallbackSeconds = 15) {
+    if (!shot || typeof shot !== "object" || Array.isArray(shot)) {
+        throw new Error("Scene length settings require a scene object.");
+    }
+    if (!["default", "seconds", "frames"].includes(mode)) {
+        throw new Error(`Unknown scene length mode “${mode}”.`);
+    }
+
+    const currentMode = shotLengthMode(shot);
+    if (currentMode === mode) return shot;
+
+    let currentSeconds;
+    if (currentMode === "frames") {
+        const frames = Number(shot.length ?? shot.frames);
+        currentSeconds = Number.isFinite(frames) && frames > 0
+            ? frames / FPS : Number(fallbackSeconds);
+    } else if (currentMode === "seconds") {
+        currentSeconds = Number(shot.duration_seconds);
+    } else {
+        currentSeconds = Number(fallbackSeconds);
+    }
+    if (!Number.isFinite(currentSeconds) || currentSeconds <= 0) {
+        currentSeconds = 15;
+    }
+
+    // Compute the replacement before deleting the active representation. If
+    // conversion fails (for example an out-of-range duration), the scene stays
+    // untouched and the editor can continue to report the original problem.
+    const replacement = mode === "frames" ? h3FrameLength(currentSeconds)
+        : mode === "seconds" ? currentSeconds : null;
+    delete shot.length;
+    delete shot.frames;
+    delete shot.duration_seconds;
+    if (mode === "frames") shot.length = replacement;
+    if (mode === "seconds") shot.duration_seconds = replacement;
+    return shot;
+}
+
+export function sceneContinuationMode(shot, planDefault = "guide") {
+    const rawFallback = String(planDefault ?? "guide");
+    const fallback = RETIRED_CONTINUATION_MODES[rawFallback] ?? rawFallback;
+    if (!CONTINUATION_MODES.includes(fallback)) {
+        throw new Error(`Unknown Plan continuation mode “${fallback}”.`);
+    }
+    const rawMode = shot?.continuation_mode ?? fallback;
+    const mode = RETIRED_CONTINUATION_MODES[rawMode] ?? rawMode;
+    if (!CONTINUATION_MODES.includes(mode)) {
+        throw new Error(`Unknown scene continuation mode “${String(mode)}”.`);
+    }
+    return mode;
+}
+
+export function sceneLoRARoute(shot) {
+    const route = String(shot?.lora_route ?? "base").trim().toLowerCase()
+        || "base";
+    if (!SCENE_LORA_ROUTES.includes(route)) {
+        throw new Error(
+            `Scene LoRA route must be one of ${SCENE_LORA_ROUTES.join(", ")}.`,
+        );
+    }
+    return route;
+}
+
+export function sceneContextLength(shot, planDefault = 22) {
+    const fallback = Number(planDefault);
+    if (!H3_CONTEXT_LENGTHS.includes(fallback)) {
+        throw new Error(`Unknown Plan context length “${String(planDefault)}”.`);
+    }
+    const value = shot?.context_length;
+    if (value === undefined || value === null
+            || (typeof value === "string" && !value.trim())) return fallback;
+    const resolved = Number(value);
+    if (typeof value === "boolean" || !Number.isInteger(resolved)
+            || (resolved !== 0 && !H3_CONTEXT_LENGTHS.includes(resolved))) {
+        throw new Error(
+            `Scene context length must be 0 or one of ${H3_CONTEXT_LENGTHS.join(", ")}.`,
+        );
+    }
+    return resolved;
+}
+
+function resolvePriorSceneSource(plan, index, raw, field, defaultPrevious) {
+    const shots = plan?.shots;
+    const target = Number(index);
+    if (!Array.isArray(shots) || !Number.isInteger(target)
+            || target < 1 || target > shots.length) {
+        throw new Error(`${field} has an invalid target scene.`);
+    }
+    if (target === 1) return null;
+    if (raw === undefined || raw === null
+            || (typeof raw === "string" && [
+                "", "previous", "immediate",
+            ].includes(raw.trim().toLowerCase()))) {
+        return defaultPrevious ? target - 1 : null;
+    }
+    if (typeof raw === "boolean") {
+        throw new Error(
+            `${field} must name an earlier scene ID or index.`,
+        );
+    }
+    let source = null;
+    const numeric = Number(raw);
+    if ((typeof raw === "number" || (typeof raw === "string"
+            && /^\d+$/.test(raw.trim()))) && Number.isInteger(numeric)) {
+        source = numeric;
+    } else if (typeof raw === "string") {
+        const wanted = raw.trim();
+        const matches = shots.map((shot, offset) => safeShotId(
+            shot?.id, `clip_${String(offset + 1).padStart(4, "0")}`,
+        ) === wanted ? offset + 1 : null).filter(Boolean);
+        if (matches.length === 1) source = matches[0];
+    }
+    if (source === null) {
+        throw new Error(
+            `${field} “${String(raw)}” does not match a scene ID or index.`,
+        );
+    }
+    if (source < 1 || source >= target) {
+        throw new Error(
+            `${field} for scene ${target} must point to an earlier scene.`,
+        );
+    }
+    return source;
+}
+
+export function sceneVisualContextSource(plan, index) {
+    return resolvePriorSceneSource(
+        plan, index, plan?.shots?.[Number(index) - 1]?.visual_context_source,
+        "Visual context source", true,
+    );
+}
+
+export function sceneVisualContextLeadSource(plan, index) {
+    return resolvePriorSceneSource(
+        plan, index,
+        plan?.shots?.[Number(index) - 1]?.visual_context_lead_source,
+        "Composed context lead source", false,
+    );
+}
+
+export function sceneVisualContextLeadFrames(shot, contextLength) {
+    const raw = shot?.visual_context_lead_frames;
+    if (raw === undefined || raw === null
+            || (typeof raw === "string" && !raw.trim())) return 0;
+    const resolved = Number(raw);
+    const allowed = visualContextLeadFrameOptions(contextLength);
+    if (typeof raw === "boolean" || !Number.isInteger(resolved)
+            || !allowed.includes(resolved)) {
+        throw new Error(
+            `Composed context lead frames must be one of ${allowed.join(", ")} and smaller than this scene's ${contextLength}-frame total.`,
+        );
+    }
+    return resolved;
+}
+
+export function visualContextBoundaryFrames(contextLength) {
+    const total = Number(contextLength);
+    if (!Number.isInteger(total) || total < 1) return Object.freeze([]);
+    const boundaries = [];
+    for (let frame = 1; frame < total; frame += 1) {
+        if (h3NativeFrameBoundaryStep(frame) !== null) boundaries.push(frame);
+    }
+    return Object.freeze(boundaries);
+}
+
+export function visualContextMaximumBlocks(contextLength) {
+    const total = Number(contextLength);
+    if (!Number.isInteger(total) || total < 1) return 0;
+    return visualContextBoundaryFrames(total).length + 1;
+}
+
+export function visualContextPartitionFromBoundaries(
+    contextLength, rawBoundaries,
+) {
+    const total = Number(contextLength);
+    const boundaries = Array.from(rawBoundaries ?? [], Number);
+    if (!Number.isInteger(total) || total < 1) {
+        throw new Error("Visual context partition requires a positive total.");
+    }
+    let previous = 0;
+    const frames = [];
+    const allowed = new Set(visualContextBoundaryFrames(total));
+    for (const boundary of boundaries) {
+        if (!Number.isInteger(boundary) || boundary <= previous
+                || boundary >= total || !allowed.has(boundary)) {
+            throw new Error(
+                `Visual context boundary ${String(boundary)} is not an ordered H3 latent boundary inside ${total} frames.`,
+            );
+        }
+        frames.push(boundary - previous);
+        previous = boundary;
+    }
+    frames.push(total - previous);
+    return Object.freeze(frames);
+}
+
+export function visualContextDefaultPartition(contextLength, blockCount) {
+    const total = Number(contextLength);
+    const count = Number(blockCount);
+    const candidates = visualContextBoundaryFrames(total);
+    if (!Number.isInteger(count) || count < 1
+            || count > candidates.length + 1) {
+        throw new Error(
+            `${total}-frame visual context supports between 1 and ${candidates.length + 1} ordered blocks.`,
+        );
+    }
+    if (count === 1) return Object.freeze([total]);
+    // Choose monotonic H3 boundaries nearest evenly spaced target positions.
+    // This gives a stable, balanced starting point without enumerating the
+    // combinatorial set of every possible N-way partition.
+    const selected = [];
+    let minimumIndex = 0;
+    for (let cut = 1; cut < count; cut += 1) {
+        const remainingCuts = count - cut - 1;
+        const maximumIndex = candidates.length - remainingCuts - 1;
+        const wanted = total * cut / count;
+        let chosen = minimumIndex;
+        for (let index = minimumIndex; index <= maximumIndex; index += 1) {
+            if (Math.abs(candidates[index] - wanted)
+                    < Math.abs(candidates[chosen] - wanted)) chosen = index;
+        }
+        selected.push(candidates[chosen]);
+        minimumIndex = chosen + 1;
+    }
+    return visualContextPartitionFromBoundaries(total, selected);
+}
+
+function visualContextBlockStartValue(
+    value, rawFrames, deliveredFrames, spanFrames, prefixFrames, label,
+) {
+    const holder = {};
+    if (value !== undefined && value !== null
+            && !(typeof value === "string" && !value.trim())) {
+        holder.visual_context_start_frame = value;
+    }
+    try {
+        return sceneVisualContextStartFrame(
+            holder, rawFrames, deliveredFrames, spanFrames, false,
+            prefixFrames,
+        );
+    } catch (error) {
+        throw new Error(`${label}: ${error.message}`);
+    }
+}
+
+export function sceneVisualContextBlocks(plan, index, contextLength) {
+    const shots = plan?.shots;
+    const target = Number(index);
+    const total = Number(contextLength);
+    if (!Array.isArray(shots) || !Number.isInteger(target)
+            || target < 1 || target > shots.length) {
+        throw new Error("Visual context blocks have an invalid target scene.");
+    }
+    if (!Number.isInteger(total) || total < 0) {
+        throw new Error("Visual context blocks require a valid context total.");
+    }
+    const shot = shots[target - 1] ?? {};
+    if (target === 1 || total === 0) {
+        if (Object.hasOwn(shot, "visual_context_blocks")) {
+            throw new Error(
+                "visual_context_blocks requires a scene after scene 1 with positive visual context.",
+            );
+        }
+        return Object.freeze([]);
+    }
+    if (Object.hasOwn(shot, "visual_context_blocks")) {
+        const legacyFields = [
+            "visual_context_source", "visual_context_start_frame",
+            "visual_context_lead_source", "visual_context_lead_frames",
+            "visual_context_lead_start_frame",
+        ].filter((field) => Object.hasOwn(shot, field));
+        if (legacyFields.length) {
+            throw new Error(
+                `visual_context_blocks cannot be combined with legacy fields: ${legacyFields.join(", ")}.`,
+            );
+        }
+        if (!Array.isArray(shot.visual_context_blocks)
+                || !shot.visual_context_blocks.length) {
+            throw new Error(
+                "visual_context_blocks must contain at least one ordered block.",
+            );
+        }
+        const blocks = [];
+        let consumed = 0;
+        for (let offset = 0; offset < shot.visual_context_blocks.length;
+            offset += 1) {
+            const raw = shot.visual_context_blocks[offset];
+            if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+                throw new Error(
+                    `Visual context block ${offset + 1} must be an object.`,
+                );
+            }
+            const frames = Number(raw.frames);
+            if (!Number.isInteger(frames) || frames < 1) {
+                throw new Error(
+                    `Visual context block ${offset + 1} frames must be a positive integer.`,
+                );
+            }
+            const source = resolvePriorSceneSource(
+                plan, target, raw.source,
+                `Visual context block ${offset + 1} source`, true,
+            );
+            const startValue = raw.start_frame;
+            if (startValue !== undefined && startValue !== null
+                    && (!(Number.isInteger(Number(startValue)))
+                        || Number(startValue) < 0)) {
+                throw new Error(
+                    `Visual context block ${offset + 1} start_frame must be a non-negative integer.`,
+                );
+            }
+            consumed += frames;
+            if (consumed < total
+                    && h3NativeFrameBoundaryStep(consumed) === null) {
+                throw new Error(
+                    `Visual context block ${offset + 1} ends at frame ${consumed}, which is not an H3 latent boundary.`,
+                );
+            }
+            blocks.push(Object.freeze({
+                source,
+                sourceId:safeShotId(
+                    shots[source - 1]?.id,
+                    `clip_${String(source).padStart(4, "0")}`,
+                ),
+                frames,
+                startFrame:startValue === undefined || startValue === null
+                    || (typeof startValue === "string" && !startValue.trim())
+                    ? null : Number(startValue),
+            }));
+        }
+        if (consumed !== total) {
+            throw new Error(
+                `Visual context blocks total ${consumed} frames; this scene requires ${total}.`,
+            );
+        }
+        if (total !== 1 && h3NativeFrameBoundaryStep(total) === null) {
+            throw new Error(
+                `${total}-frame visual context does not end on H3's latent lattice.`,
+            );
+        }
+        return Object.freeze(blocks);
+    }
+
+    // Released one/two-block plans remain byte-for-byte unchanged on disk.
+    // Expose them as a list only to the new planner/runtime adapter.
+    const recentSource = sceneVisualContextSource(plan, target);
+    const leadSource = sceneVisualContextLeadSource(plan, target);
+    const leadFrames = leadSource === null
+        ? 0 : sceneVisualContextLeadFrames(shot, total);
+    const result = [];
+    if (leadSource !== null) result.push(Object.freeze({
+        source:leadSource,
+        sourceId:safeShotId(
+            shots[leadSource - 1]?.id,
+            `clip_${String(leadSource).padStart(4, "0")}`,
+        ),
+        frames:leadFrames,
+        startFrame:Object.hasOwn(shot, "visual_context_lead_start_frame")
+            ? Number(shot.visual_context_lead_start_frame) : null,
+    }));
+    result.push(Object.freeze({
+        source:recentSource,
+        sourceId:safeShotId(
+            shots[recentSource - 1]?.id,
+            `clip_${String(recentSource).padStart(4, "0")}`,
+        ),
+        frames:total - leadFrames,
+        startFrame:Object.hasOwn(shot, "visual_context_start_frame")
+            ? Number(shot.visual_context_start_frame) : null,
+    }));
+    return Object.freeze(result);
+}
+
+export function h3NativeFrameBoundaryStep(frame) {
+    const resolved = Number(frame);
+    if (!Number.isInteger(resolved) || resolved < 0) return null;
+    if (resolved % 17 === 0) return 5 * (resolved / 17);
+    if (resolved >= 5 && (resolved - 5) % 17 === 0) {
+        return 2 + 5 * ((resolved - 5) / 17);
+    }
+    return null;
+}
+
+export function nativeContextWindowStarts(
+    rawFrames, deliveredFrames, spanFrames, prefixFrames = 0,
+) {
+    const raw = Number(rawFrames);
+    const delivered = Number(deliveredFrames);
+    const span = Number(spanFrames);
+    const prefix = Number(prefixFrames);
+    if (!Number.isInteger(raw) || !Number.isInteger(delivered)
+            || !Number.isInteger(span) || !Number.isInteger(prefix)
+            || raw < delivered || delivered < 1 || span < 1
+            || span > delivered || prefix < 0) return Object.freeze([]);
+    const latest = delivered - span;
+    if (span === 1 && prefix === 0) return Object.freeze([latest]);
+    const targetStart = h3NativeFrameBoundaryStep(prefix);
+    const targetEnd = h3NativeFrameBoundaryStep(prefix + span);
+    if (targetStart === null || targetEnd === null) return Object.freeze([]);
+    const expectedSteps = targetEnd - targetStart;
+    const trim = raw - delivered;
+    const starts = [];
+    for (let start = 0; start <= latest; start += 1) {
+        const sourceStart = h3NativeFrameBoundaryStep(trim + start);
+        const sourceEnd = h3NativeFrameBoundaryStep(trim + start + span);
+        if (sourceStart !== null && sourceEnd !== null
+                && sourceStart % 5 === targetStart % 5
+                && sourceEnd - sourceStart === expectedSteps) {
+            starts.push(start);
+        }
+    }
+    return Object.freeze(starts);
+}
+
+export function nearestNativeContextWindowStart(starts, requested) {
+    const options = Array.isArray(starts) ? starts : [];
+    if (!options.length) return null;
+    const value = Number(requested);
+    if (!Number.isFinite(value)) return options.at(-1);
+    return options.reduce((nearest, candidate) => (
+        Math.abs(candidate - value) < Math.abs(nearest - value)
+            ? candidate : nearest
+    ), options[0]);
+}
+
+export function sceneVisualContextStartFrame(
+    shot, rawFrames, deliveredFrames, spanFrames, lead = false,
+    prefixFrames = 0,
+) {
+    const field = lead
+        ? "visual_context_lead_start_frame"
+        : "visual_context_start_frame";
+    const rawFramesResolved = Number(rawFrames);
+    const delivered = Number(deliveredFrames);
+    const span = Number(spanFrames);
+    if (!Number.isInteger(rawFramesResolved) || rawFramesResolved < delivered
+            || !Number.isInteger(delivered) || delivered < 0
+            || !Number.isInteger(span) || span < 0) {
+        throw new Error(`${field} requires valid raw, delivered, and context frame counts.`);
+    }
+    if (span < 1) {
+        if (Object.hasOwn(shot ?? {}, field)) {
+            throw new Error(`${field} requires a positive visual context span.`);
+        }
+        return delivered;
+    }
+    const latest = delivered - span;
+    if (latest < 0) {
+        throw new Error(
+            `${field} requests ${span} frames from a source delivering only ${delivered}.`,
+        );
+    }
+    const starts = nativeContextWindowStarts(
+        rawFramesResolved, delivered, span, prefixFrames,
+    );
+    if (!starts.length) {
+        throw new Error(
+            `${field} has no native latent-aligned ${span}-frame window inside the source's ${rawFramesResolved} raw / ${delivered} delivered frames.`,
+        );
+    }
+    const authored = shot?.[field];
+    if (authored === undefined || authored === null
+            || (typeof authored === "string" && !authored.trim())) return starts.at(-1);
+    const resolved = Number(authored);
+    if (typeof authored === "boolean" || !Number.isInteger(resolved)
+            || resolved < 0 || resolved > latest) {
+        throw new Error(
+            `${field} must be between 0 and ${latest} so its ${span}-frame window fits inside the source's ${delivered} delivered frames.`,
+        );
+    }
+    if (!starts.includes(resolved)) {
+        const nearest = nearestNativeContextWindowStart(starts, resolved);
+        throw new Error(
+            `${field}=${resolved} is not on H3's native temporal latent lattice. Use ${nearest} (nearest aligned start).`,
+        );
+    }
+    return resolved;
+}
+
+export function visualContextLeadFrameOptions(contextLength) {
+    const total = Number(contextLength);
+    if (!Number.isInteger(total)) return Object.freeze([]);
+    const values = new Set();
+    for (const nativeRun of H3_CONTEXT_LENGTHS) {
+        if (nativeRun < 5 || nativeRun >= total) continue;
+        values.add(nativeRun);
+        const inverse = total - nativeRun;
+        if (inverse >= 5 && inverse < total) values.add(inverse);
+    }
+    return Object.freeze([...values].sort((left, right) => left - right));
+}
+
+export function visualContextCompositions() {
+    const compositions = [];
+    for (const total of H3_CONTEXT_LENGTHS) {
+        for (const lead of visualContextLeadFrameOptions(total)) {
+            compositions.push(Object.freeze({
+                total,
+                lead,
+                recent: total - lead,
+                value: `${total}:${lead}`,
+                label: `${total} total · ${lead} + ${total - lead}`,
+            }));
+        }
+    }
+    return Object.freeze(compositions);
+}
+
+export function sceneAudioContextLength(
+    shot, planDefault = 22, videoContextLength = 22,
+) {
+    const fallback = Number(planDefault);
+    if (!Number.isInteger(fallback) || fallback < 0 || fallback > 240) {
+        throw new Error("Plan audio context length must be between 0 and 240 frames.");
+    }
+    const value = shot?.audio_context_length;
+    if (value === undefined || value === null
+            || (typeof value === "string" && !value.trim())) {
+        return fallback || Number(videoContextLength);
+    }
+    const resolved = Number(value);
+    if (typeof value === "boolean" || !Number.isInteger(resolved)
+            || resolved < 0 || resolved > 240) {
+        throw new Error("Scene audio context length must be between 0 and 240 frames.");
+    }
+    return resolved;
+}
+
+export function sceneAudioContextUnlocked(shot) {
+    const value = shot?.audio_context_unlocked ?? false;
+    if (typeof value !== "boolean") {
+        throw new Error("audio_context_unlocked must be true or false.");
+    }
+    return value;
+}
+
+export function sceneAudioContextSource(plan, index) {
+    return resolvePriorSceneSource(
+        plan, index,
+        plan?.shots?.[Number(index) - 1]?.audio_context_source,
+        "Audio context source", true,
+    );
+}
+
+export function sceneAudioContextLeadSource(plan, index) {
+    return resolvePriorSceneSource(
+        plan, index,
+        plan?.shots?.[Number(index) - 1]?.audio_context_lead_source,
+        "Composed audio lead source", false,
+    );
+}
+
+export function audioContextLeadFrameOptions(contextLength) {
+    const total = Number(contextLength);
+    if (!Number.isInteger(total) || total < 2) return Object.freeze([]);
+    const expected = Math.round(total / FPS * 40);
+    return Object.freeze(Array.from({length:total - 1}, (_item, offset) => (
+        offset + 1
+    )).filter((lead) => (
+        Math.round(lead / FPS * 40)
+        + Math.round((total - lead) / FPS * 40) === expected
+    )));
+}
+
+export function sceneAudioContextLeadFrames(shot, contextLength) {
+    const raw = shot?.audio_context_lead_frames;
+    if (raw === undefined || raw === null
+            || (typeof raw === "string" && !raw.trim())) return 0;
+    const resolved = Number(raw);
+    const allowed = audioContextLeadFrameOptions(contextLength);
+    if (typeof raw === "boolean" || !Number.isInteger(resolved)
+            || !allowed.includes(resolved)) {
+        throw new Error(
+            `Composed audio lead frames must be an exact 40 Hz split between 1 and ${Math.max(0, Number(contextLength) - 1)}.`,
+        );
+    }
+    return resolved;
+}
+
+export function audioContextWindowStarts(
+    rawFrames, deliveredFrames, spanFrames,
+) {
+    const raw = Number(rawFrames);
+    const delivered = Number(deliveredFrames);
+    const span = Number(spanFrames);
+    if (!Number.isInteger(raw) || !Number.isInteger(delivered)
+            || !Number.isInteger(span) || raw < delivered || delivered < 1
+            || span < 1 || span > delivered) return Object.freeze([]);
+    const trim = raw - delivered;
+    const expected = Math.round(span / FPS * 40);
+    const starts = [];
+    for (let start = 0; start <= delivered - span; start += 1) {
+        const rawStart = trim + start;
+        if (Math.round((rawStart + span) / FPS * 40)
+                - Math.round(rawStart / FPS * 40) === expected) {
+            starts.push(start);
+        }
+    }
+    return Object.freeze(starts);
+}
+
+export function sceneAudioContextStartFrame(
+    shot, rawFrames, deliveredFrames, spanFrames, lead = false,
+) {
+    const field = lead
+        ? "audio_context_lead_start_frame" : "audio_context_start_frame";
+    const starts = audioContextWindowStarts(
+        rawFrames, deliveredFrames, spanFrames,
+    );
+    if (!starts.length) {
+        throw new Error(
+            `${field} has no exact ${spanFrames}-frame/40 Hz window in this source.`,
+        );
+    }
+    const authored = shot?.[field];
+    if (authored === undefined || authored === null
+            || (typeof authored === "string" && !authored.trim())) {
+        return starts.at(-1);
+    }
+    const resolved = Number(authored);
+    const latest = Number(deliveredFrames) - Number(spanFrames);
+    if (typeof authored === "boolean" || !Number.isInteger(resolved)
+            || resolved < 0 || resolved > latest) {
+        throw new Error(
+            `${field} must be between 0 and ${latest} so its ${spanFrames}-frame window fits.`,
+        );
+    }
+    if (!starts.includes(resolved)) {
+        const nearest = nearestNativeContextWindowStart(starts, resolved);
+        throw new Error(
+            `${field}=${resolved} does not preserve the exact 40 Hz duration. Use ${nearest} (nearest).`,
+        );
+    }
+    return resolved;
+}
+
+export function sceneVideoBlendFrames(
+    shot, planDefault = 0, videoContextLength = 22,
+) {
+    const fallback = Number(planDefault);
+    const context = Number(videoContextLength);
+    if (!Number.isInteger(fallback) || fallback < 0) {
+        throw new Error("Plan video blend frames must be a non-negative integer.");
+    }
+    if (!Number.isInteger(context) || context < 0) {
+        throw new Error("Scene video context must be a non-negative integer.");
+    }
+    const value = shot?.video_blend_frames;
+    if (value === undefined || value === null
+            || (typeof value === "string" && !value.trim())) {
+        return Math.min(fallback, context);
+    }
+    const resolved = Number(value);
+    if (typeof value === "boolean" || !Number.isInteger(resolved)
+            || resolved < 0 || resolved > context) {
+        throw new Error(
+            `Scene video blend frames must be between 0 and its context length (${context}).`,
+        );
+    }
+    return resolved;
+}
+
+export function validateH3Length(value) {
+    const length = Number(value);
+    if (!Number.isInteger(length) || length < 5 || length > MAX_H3_FRAMES || length % 17 !== 5) {
+        throw new Error(
+            `Exact length must be 5..${MAX_H3_FRAMES} frames with length % 17 == 5.`,
+        );
+    }
+    return length;
+}
+
+function sceneRawFrames(shot, defaultDuration) {
+    if (shot.length !== undefined && shot.length !== null && shot.length !== "") {
+        return validateH3Length(shot.length);
+    }
+    if (shot.frames !== undefined && shot.frames !== null && shot.frames !== "") {
+        return validateH3Length(shot.frames);
+    }
+    const duration = shot.duration_seconds ?? defaultDuration;
+    return h3FrameLength(duration);
+}
+
+function validateSeed(seed) {
+    if (seed === undefined || seed === null || seed === "") return;
+    let numeric;
+    try {
+        numeric = BigInt(String(seed));
+    } catch (_error) {
+        throw new Error("Seed must be an unsigned 64-bit integer.");
+    }
+    if (numeric < 0n || numeric > MAX_SEED) {
+        throw new Error("Seed is outside the unsigned 64-bit range.");
+    }
+}
+
+export function calculatePlanTiming(plan, settings = {}) {
+    const errors = [];
+    const rows = [];
+    const contextLength = Number(settings.contextLength ?? 22);
+    const audioContextLength = Number(settings.audioContextLength ?? 22);
+    const videoBlendFrames = Number(settings.videoBlendFrames ?? 0);
+    const encodeMode = settings.encodeMode ?? "video";
+    const anchorMode = settings.anchorMode ?? "head";
+    const planContinuationMode = settings.continuationMode ?? "guide";
+    const generatedContinuity = String(
+        settings.generatedContinuity ?? "on",
+    );
+    const sourceAudioTarget = String(settings.sourceAudioTarget ?? "off");
+    const nodeDefaultDuration = Number(settings.defaultDurationSeconds ?? 15);
+    const planDefaultDuration = Number(plan?.defaults?.duration_seconds ?? nodeDefaultDuration);
+    const defaultSteps = Number(plan?.defaults?.steps ?? settings.defaultSteps ?? 20);
+    const hasSharedPrompt = sharedPrompt(plan ?? {}).text.trim().length > 0;
+
+    if (!H3_CONTEXT_LENGTHS.includes(contextLength)) {
+        errors.push(`Context length must be one of ${H3_CONTEXT_LENGTHS.join(", ")}.`);
+    }
+    if (!Number.isInteger(audioContextLength)
+            || audioContextLength < 0 || audioContextLength > 240) {
+        errors.push("Audio context length must be between 0 and 240 frames.");
+    }
+    if (!Number.isInteger(videoBlendFrames) || videoBlendFrames < 0
+            || videoBlendFrames > contextLength) {
+        errors.push(
+            `Video blend frames must be between 0 and context length (${contextLength}).`,
+        );
+    }
+    if (!Number.isFinite(planDefaultDuration) || planDefaultDuration <= 0) {
+        errors.push("Default duration must be a finite positive number.");
+    }
+    if (!Number.isInteger(defaultSteps) || defaultSteps < 1 || defaultSteps > 10000) {
+        errors.push("Default steps must be between 1 and 10000.");
+    }
+
+    const ids = new Set();
+    let stitchedFrames = 0;
+    for (let offset = 0; offset < (plan?.shots?.length ?? 0); offset += 1) {
+        const shot = plan.shots[offset];
+        const index = offset + 1;
+        const fallback = `clip_${String(index).padStart(4, "0")}`;
+        const id = safeShotId(shot.id, fallback);
+        const rowErrors = [];
+        if (ids.has(id)) rowErrors.push(`Duplicate normalized scene id “${id}”.`);
+        ids.add(id);
+        if (!promptValueToText(shot.prompt, `Scene ${index} prompt`).trim()
+            && !hasSharedPrompt) {
+            rowErrors.push("Scene and shared prompts are both empty.");
+        }
+
+        const steps = Number(shot.steps ?? defaultSteps);
+        if (!Number.isInteger(steps) || steps < 1 || steps > 10000) {
+            rowErrors.push("Steps must be between 1 and 10000.");
+        }
+        try {
+            validateSeed(shot.seed);
+        } catch (error) {
+            rowErrors.push(error.message);
+        }
+
+        let loraRoute = "base";
+        try {
+            loraRoute = sceneLoRARoute(shot);
+        } catch (error) {
+            rowErrors.push(error.message);
+        }
+
+        let sceneContext = contextLength;
+        try {
+            sceneContext = sceneContextLength(shot, contextLength);
+        } catch (error) {
+            rowErrors.push(error.message);
+        }
+        if (index === 1 && (Object.hasOwn(
+            shot, "visual_context_start_frame",
+        ) || Object.hasOwn(shot, "visual_context_blocks"))) {
+            rowErrors.push(
+                "Scene 1 cannot select a saved-scene context window.",
+            );
+        }
+
+        let visualContextSource = index > 1 ? index - 1 : null;
+        let visualContextLeadSource = null;
+        let visualContextLeadFrames = 0;
+        let visualContextBlocks = [];
+        try {
+            visualContextBlocks = sceneVisualContextBlocks(
+                plan, index, sceneContext,
+            );
+            if (visualContextBlocks.length) {
+                visualContextSource = visualContextBlocks.at(-1).source;
+            }
+            if (visualContextBlocks.length === 2) {
+                visualContextLeadSource = visualContextBlocks[0].source;
+                visualContextLeadFrames = visualContextBlocks[0].frames;
+            }
+        } catch (error) {
+            rowErrors.push(error.message);
+        }
+
+        let sceneAudioContext = audioContextLength || sceneContext;
+        try {
+            sceneAudioContext = sceneAudioContextLength(
+                shot, audioContextLength, sceneContext,
+            );
+        } catch (error) {
+            rowErrors.push(error.message);
+        }
+
+        let sceneBlendFrames = Math.min(
+            Math.max(0, videoBlendFrames), Math.max(0, sceneContext),
+        );
+        try {
+            sceneBlendFrames = sceneVideoBlendFrames(
+                shot, videoBlendFrames, sceneContext,
+            );
+            if (sceneBlendFrames > 0 && anchorMode !== "head") {
+                rowErrors.push("Video blending requires head anchor mode.");
+            }
+            if (index > 1 && sceneBlendFrames > 0 && (
+                visualContextBlocks.length !== 1
+                || visualContextBlocks.some((block) => (
+                    block.source !== index - 1 || block.startFrame !== null
+                ))
+            )) {
+                rowErrors.push(
+                    "Non-linear, composed, or windowed visual context requires 0 assembly blend frames; the timeline still cuts from the immediately previous scene.",
+                );
+            }
+        } catch (error) {
+            rowErrors.push(error.message);
+        }
+
+        let continuationMode = "guide";
+        try {
+            continuationMode = sceneContinuationMode(
+                shot, planContinuationMode,
+            );
+            if (sceneContext > 0 && [
+                "masked_av", "tapered_av", "feathered_av",
+                "audio_feathered_av", "drift_control_av",
+                "color_stable_drift_av",
+            ].includes(
+                continuationMode,
+            )) {
+                const preservesGeneratedAudioPrefix = (
+                    generatedContinuity === "on"
+                    && sourceAudioTarget !== "locked"
+                    && sceneAudioContext > 0
+                );
+                if ([
+                    "masked_av", "feathered_av", "audio_feathered_av",
+                ].includes(continuationMode)
+                        && !VIDEO_ONLY_AV_CONTEXT_LENGTHS.includes(sceneContext)) {
+                    rowErrors.push(
+                        "Video-only AV continuation requires at least 5 context frames.",
+                    );
+                }
+                if (preservesGeneratedAudioPrefix
+                        && !AV_CONTEXT_LENGTHS.includes(sceneContext)) {
+                    rowErrors.push(
+                        "AV generated-audio continuity requires an exact shared video/audio boundary: 39, 90, 141, 192, or 243 context frames. Turn generated continuity off (or set scene audio context to 0) for a video-only AV test.",
+                    );
+                }
+                if (encodeMode !== "video") {
+                    rowErrors.push("AV mask continuation requires video encode mode.");
+                }
+                if (anchorMode !== "head") {
+                    rowErrors.push("AV mask continuation requires head anchor mode.");
+                }
+                if (continuationMode === "tapered_av" && sceneContext !== 39) {
+                    rowErrors.push(
+                        "Detail AV currently requires exactly 39 context frames.",
+                    );
+                }
+                if (["drift_control_av", "color_stable_drift_av"].includes(
+                    continuationMode,
+                ) && sceneContext !== 39) {
+                    rowErrors.push(
+                        "Drift-Control AV and Color-Stable Drift AV currently require exactly 39 context frames.",
+                    );
+                }
+            }
+            if (sceneContext > 0 && continuationMode === "latent_guide") {
+                if (sceneContext < 5) {
+                    rowErrors.push(
+                        "Latent Guide requires a context length of at least 5 frames.",
+                    );
+                }
+                if (encodeMode !== "video") {
+                    rowErrors.push("Latent Guide requires video encode mode.");
+                }
+            }
+        } catch (error) {
+            rowErrors.push(error.message);
+        }
+
+        let audioContextUnlocked = false;
+        let audioContextSource = index > 1 ? index - 1 : null;
+        let audioContextLeadSource = null;
+        let audioContextLeadFrames = 0;
+        const effectiveAudioSelectionSpan = [
+            "masked_av", "tapered_av", "feathered_av",
+            "audio_feathered_av", "drift_control_av",
+            "color_stable_drift_av",
+        ].includes(continuationMode) && sceneAudioContext > 0
+            ? sceneContext : sceneAudioContext;
+        try {
+            audioContextUnlocked = sceneAudioContextUnlocked(shot);
+            if (audioContextUnlocked) {
+                if (index === 1) {
+                    rowErrors.push(
+                        "Scene 1 cannot unlock saved-scene audio context.",
+                    );
+                }
+                if (sourceAudioTarget === "locked") {
+                    rowErrors.push(
+                        "Unlocked audio context cannot be combined with Lip-sync to source audio.",
+                    );
+                } else if (generatedContinuity !== "on") {
+                    rowErrors.push(
+                        "Unlocked audio context requires Generated continuity for this scene.",
+                    );
+                }
+                if (effectiveAudioSelectionSpan <= 0) {
+                    rowErrors.push(
+                        "Unlocked audio context requires a positive audio context length.",
+                    );
+                }
+                audioContextSource = sceneAudioContextSource(plan, index);
+                audioContextLeadSource = sceneAudioContextLeadSource(
+                    plan, index,
+                );
+                if (audioContextLeadSource !== null) {
+                    audioContextLeadFrames = sceneAudioContextLeadFrames(
+                        shot, effectiveAudioSelectionSpan,
+                    );
+                } else if (Object.hasOwn(
+                    shot, "audio_context_lead_frames",
+                )) {
+                    rowErrors.push(
+                        "Composed audio lead frames require an audio lead source.",
+                    );
+                } else if (Object.hasOwn(
+                    shot, "audio_context_lead_start_frame",
+                )) {
+                    rowErrors.push(
+                        "Composed audio lead start requires an audio lead source.",
+                    );
+                }
+            } else if ([
+                "audio_context_source", "audio_context_start_frame",
+                "audio_context_lead_source", "audio_context_lead_frames",
+                "audio_context_lead_start_frame",
+            ].some((field) => Object.hasOwn(shot, field))) {
+                rowErrors.push(
+                    "Independent audio fields require Audio context to be unlocked.",
+                );
+            }
+        } catch (error) {
+            rowErrors.push(error.message);
+        }
+
+        const contextSpatialProxy = String(
+            shot.context_spatial_proxy ?? "off",
+        ).trim().toLowerCase() || "off";
+        if (!CONTEXT_SPATIAL_PROXY_MODES.includes(contextSpatialProxy)) {
+            rowErrors.push(
+                `Unknown boundary spatial proxy “${contextSpatialProxy}”.`,
+            );
+        } else if (contextSpatialProxy !== "off") {
+            if (sceneContext <= 0) {
+                rowErrors.push(
+                    "Boundary spatial proxy requires positive video context.",
+                );
+            }
+            if (contextSpatialProxy === "rgb_5_6" && ![
+                "guide", "tone_carry_guide", "tapered_guide",
+            ].includes(continuationMode)) {
+                rowErrors.push(
+                    "Low-grid 5/6 boundary proxy requires Guide, Tone Carry Guide, or Detail Guide.",
+                );
+            }
+            if (contextSpatialProxy === "latent_5_6" && ![
+                "masked_av", "tapered_av", "feathered_av",
+                "audio_feathered_av", "drift_control_av",
+                "color_stable_drift_av",
+            ].includes(continuationMode)) {
+                rowErrors.push(
+                    "Latent 5/6 boundary proxy requires an AV continuation mode.",
+                );
+            }
+            if (index === 1) {
+                rowErrors.push(
+                    "Scene 1 cannot use a 5/6 boundary proxy because imported context has no sampled predecessor latent.",
+                );
+            }
+        }
+
+        let rawFrames = 0;
+        try {
+            rawFrames = sceneRawFrames(shot, planDefaultDuration);
+        } catch (error) {
+            rowErrors.push(error.message);
+        }
+
+        let deliveredFrames = rawFrames;
+        let generationStartFrame = stitchedFrames;
+        if (index > 1 && anchorMode === "head") {
+            if (sceneContext > 0 && rawFrames <= sceneContext) {
+                rowErrors.push(
+                    `${rawFrames} raw frames are not longer than the ${sceneContext}-frame overlap.`,
+                );
+            }
+            deliveredFrames = Math.max(0, rawFrames - sceneContext);
+            generationStartFrame = stitchedFrames - sceneContext;
+        }
+
+        rows.push({
+            index,
+            id,
+            rawFrames,
+            rawSeconds: rawFrames / FPS,
+            deliveredFrames,
+            deliveredSeconds: deliveredFrames / FPS,
+            generationStartFrame,
+            contextLength: sceneContext,
+            visualContextSource,
+            visualContextSourceId: visualContextSource === null ? null
+                : safeShotId(
+                    plan.shots[visualContextSource - 1]?.id,
+                    `clip_${String(visualContextSource).padStart(4, "0")}`,
+                ),
+            visualContextLeadSource,
+            visualContextLeadSourceId: visualContextLeadSource === null ? null
+                : safeShotId(
+                    plan.shots[visualContextLeadSource - 1]?.id,
+                    `clip_${String(visualContextLeadSource).padStart(4, "0")}`,
+                ),
+            visualContextLeadFrames,
+            visualContextStartFrame:null,
+            visualContextLeadStartFrame:null,
+            visualContextBlocks,
+            audioContextUnlocked,
+            audioContextSource,
+            audioContextSourceId: audioContextSource === null ? null
+                : safeShotId(
+                    plan.shots[audioContextSource - 1]?.id,
+                    `clip_${String(audioContextSource).padStart(4, "0")}`,
+                ),
+            audioContextLeadSource,
+            audioContextLeadSourceId: audioContextLeadSource === null ? null
+                : safeShotId(
+                    plan.shots[audioContextLeadSource - 1]?.id,
+                    `clip_${String(audioContextLeadSource).padStart(4, "0")}`,
+                ),
+            audioContextLeadFrames,
+            audioContextStartFrame:null,
+            audioContextLeadStartFrame:null,
+            videoBlendFrames: sceneBlendFrames,
+            audioContextLength: [
+                "masked_av", "tapered_av", "feathered_av",
+                "audio_feathered_av", "drift_control_av",
+                "color_stable_drift_av",
+            ].includes(
+                continuationMode,
+            )
+                ? ((generatedContinuity === "on"
+                    && sourceAudioTarget !== "locked"
+                    && sceneAudioContext > 0) ? sceneContext : 0)
+                : sceneAudioContext,
+            preservesGeneratedAudioPrefix: (
+                generatedContinuity === "on"
+                && sourceAudioTarget !== "locked"
+                && sceneAudioContext > 0
+            ),
+            continuationMode,
+            contextSpatialProxy,
+            loraRoute,
+            errors: rowErrors,
+        });
+        stitchedFrames += deliveredFrames;
+    }
+
+    for (let offset = 1; offset < rows.length; offset += 1) {
+        const target = rows[offset];
+        let prefixFrames = 0;
+        target.visualContextBlocks = target.visualContextBlocks.map(
+            (block, blockOffset) => {
+                const source = rows[block.source - 1] ?? null;
+                let startFrame = block.startFrame;
+                if (!source) {
+                    target.errors.push(
+                        `Visual context block ${blockOffset + 1} has no source scene.`,
+                    );
+                } else if (source.deliveredFrames < block.frames) {
+                    target.errors.push(
+                        `Visual context block ${blockOffset + 1} source scene ${source.index} delivers fewer than ${block.frames} required frames.`,
+                    );
+                } else {
+                    try {
+                        startFrame = visualContextBlockStartValue(
+                            block.startFrame, source.rawFrames,
+                            source.deliveredFrames, block.frames,
+                            prefixFrames,
+                            `Visual context block ${blockOffset + 1}`,
+                        );
+                    } catch (error) {
+                        target.errors.push(error.message);
+                    }
+                }
+                const resolved = Object.freeze({...block, startFrame});
+                prefixFrames += block.frames;
+                return resolved;
+            },
+        );
+        const source = target.visualContextBlocks.at(-1) ?? null;
+        target.visualContextStartFrame = source?.startFrame ?? null;
+        const lead = target.visualContextBlocks.length === 2
+            ? target.visualContextBlocks[0] : null;
+        target.visualContextLeadStartFrame = lead?.startFrame ?? null;
+        if (target.audioContextUnlocked) {
+            const audioSource = target.audioContextSource === null ? null
+                : rows[target.audioContextSource - 1];
+            const recentAudioFrames = target.audioContextLength
+                - target.audioContextLeadFrames;
+            if (audioSource && audioSource.deliveredFrames < recentAudioFrames) {
+                target.errors.push(
+                    `Selected audio source scene ${audioSource.index} delivers fewer than ${recentAudioFrames} required frames.`,
+                );
+            }
+            if (audioSource) {
+                try {
+                    target.audioContextStartFrame = sceneAudioContextStartFrame(
+                        plan.shots[offset], audioSource.rawFrames,
+                        audioSource.deliveredFrames, recentAudioFrames, false,
+                    );
+                } catch (error) {
+                    target.errors.push(error.message);
+                }
+            }
+            const audioLead = target.audioContextLeadSource === null ? null
+                : rows[target.audioContextLeadSource - 1];
+            if (audioLead
+                    && audioLead.deliveredFrames < target.audioContextLeadFrames) {
+                target.errors.push(
+                    `Selected composed-audio lead scene ${audioLead.index} delivers fewer than ${target.audioContextLeadFrames} required frames.`,
+                );
+            }
+            if (audioLead) {
+                try {
+                    target.audioContextLeadStartFrame = sceneAudioContextStartFrame(
+                        plan.shots[offset], audioLead.rawFrames,
+                        audioLead.deliveredFrames,
+                        target.audioContextLeadFrames, true,
+                    );
+                } catch (error) {
+                    target.errors.push(error.message);
+                }
+            }
+        }
+    }
+    for (const row of rows) {
+        for (const error of row.errors) errors.push(`Scene ${row.index}: ${error}`);
+    }
+
+    return {
+        shots: rows,
+        totalFrames: stitchedFrames,
+        totalSeconds: stitchedFrames / FPS,
+        errors,
+    };
+}
+
+export function formatClock(seconds) {
+    if (!Number.isFinite(seconds) || seconds < 0) return "—";
+    const wholeMinutes = Math.floor(seconds / 60);
+    const remainder = seconds - wholeMinutes * 60;
+    return wholeMinutes
+        ? `${wholeMinutes}:${remainder.toFixed(3).padStart(6, "0")}`
+        : `${remainder.toFixed(3)}s`;
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_plan_editor.js b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_plan_editor.js
new file mode 100644
index 0000000000000000000000000000000000000000..acb2489de71016be74844f66a329e99dab6faa55
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_plan_editor.js
@@ -0,0 +1,2100 @@
+import {app} from "/scripts/app.js";
+import {api} from "/scripts/api.js";
+import {
+    H3_CONTEXT_LENGTHS,
+    MAX_SHOTS,
+    automaticSceneColor,
+    calculatePlanTiming,
+    derivedSceneSeed,
+    duplicateShot,
+    formatClock,
+    makeShot,
+    moveShot,
+    removePlanShot,
+    parsePlanJson,
+    planToJson,
+    promptTextToLines,
+    promptValueToText,
+    randomSceneSeed,
+    safeShotId,
+    sceneContextLength,
+    sceneContinuationMode,
+    sceneLoRARoute,
+    sceneVisualContextSource,
+    sceneVisualContextLeadFrames,
+    sceneVisualContextLeadSource,
+    scenePromptSeedMode,
+    sceneVideoBlendFrames,
+    setScenePromptSeedMode,
+    setShotLengthMode,
+    setSharedPrompt,
+    shotLengthMode,
+    sharedPrompt,
+    visualContextCompositions,
+} from "./h3_chain_plan_core.mjs?v=0.6.5";
+import {availableReferenceRecords} from "./h3_reference_preview_core.mjs?v=0.6.2";
+import {
+    applySceneAudioOverride,
+    applySceneLipSync,
+    sceneLipSyncMode,
+    applySceneTransitionPreset,
+    primaryTransitionOptions,
+    sceneAudioOverride,
+    sceneAudioPolicy,
+    sceneTransitionPreset,
+    transitionPresetLabel,
+} from "./h3_policy_core.mjs?v=0.6.6";
+import {
+    resolveAudioContextLength,
+    resolveAudioPolicy,
+    resolveTransitionPolicy,
+} from "./h3_socket_presentation_core.mjs?v=0.6.6";
+import {
+    availableLoRARoutes,
+    loraRouteLabel,
+} from "./h3_lora_scheduler_core.mjs?v=0.6.2";
+import {
+    MODERN_PLAN_NODE as MODERN_NODE_NAME,
+    MODERN_PLAN_WIDGET_NAMES as MODERN_BACKING_WIDGETS,
+    upgradeLegacyPlanNode,
+} from "./h3_plan_upgrade_core.mjs?v=0.6.2";
+
+// This scene editor is an original implementation. Its quick @ reference and
+// # dialogue interactions are inspired by nkxx188/ComfyUI-MiniMaxH3-Easy,
+// distributed under the MIT License. See THIRD_PARTY_NOTICES.md.
+
+const EXTENSION = "minimax_h3_context_loop.chain_plan_editor";
+const NODE_NAME = "MiniMaxH3ChainPlan";
+const NODE_NAMES = new Set([NODE_NAME, MODERN_NODE_NAME]);
+const MIN_WIDTH = 700;
+const EDITOR_HEIGHT = 650;
+const SCENE_COLOR_PROPERTY = "h3_chain_scene_colors";
+const LAYOUT_PROPERTY = "h3_chain_plan_layout";
+
+function injectStyles() {
+    if (document.getElementById("h3-chain-plan-editor-style")) return;
+    const style = document.createElement("style");
+    style.id = "h3-chain-plan-editor-style";
+    style.textContent = `
+        .h3c-editor {
+            --h3c-bg: color-mix(in srgb, var(--comfy-menu-bg, #202124) 90%, #111827);
+            --h3c-panel: color-mix(in srgb, var(--comfy-input-bg, #111827) 84%, #24304a);
+            --h3c-border: color-mix(in srgb, var(--border-color, #555) 70%, #7c8db5);
+            --h3c-text: var(--input-text, #e8eaf0);
+            --h3c-muted: color-mix(in srgb, var(--h3c-text) 58%, transparent);
+            --h3c-accent: #7fa8ff;
+            box-sizing: border-box;
+            width: 100%;
+            height: 100%;
+            max-height: 100%;
+            min-height: 0;
+            overflow: auto;
+            contain: layout paint;
+            padding: 10px;
+            border: 1px solid var(--h3c-border);
+            border-radius: 8px;
+            background: var(--h3c-bg);
+            color: var(--h3c-text);
+            font: 12px/1.35 system-ui, sans-serif;
+            scrollbar-gutter: stable;
+        }
+        .h3c-editor *, .h3c-editor *::before, .h3c-editor *::after { box-sizing: border-box; }
+        .h3c-editor input, .h3c-editor textarea, .h3c-editor select, .h3c-editor button {
+            color: var(--h3c-text);
+            font: inherit;
+        }
+        .h3c-editor input, .h3c-editor textarea, .h3c-editor select {
+            width: 100%;
+            min-width: 0;
+            padding: 6px 7px;
+            border: 1px solid var(--h3c-border);
+            border-radius: 5px;
+            background: var(--comfy-input-bg, #15171d);
+        }
+        .h3c-editor textarea { resize: vertical; line-height: 1.45; }
+        .h3c-editor button {
+            padding: 5px 8px;
+            border: 1px solid var(--h3c-border);
+            border-radius: 5px;
+            background: var(--comfy-input-bg, #252832);
+            cursor: pointer;
+            white-space: nowrap;
+        }
+        .h3c-editor button:hover { border-color: var(--h3c-accent); }
+        .h3c-editor button:disabled { cursor: not-allowed; opacity: .4; }
+        .h3c-header, .h3c-toolbar, .h3c-card-head, .h3c-prompt-tools,
+        .h3c-json-actions, .h3c-footer { display: flex; align-items: center; gap: 6px; }
+        .h3c-header { justify-content: space-between; margin-bottom: 8px; }
+        .h3c-header-actions { display:flex; align-items:center; justify-content:flex-end;
+            gap:7px; min-width:0; }
+        .h3c-open-output { display:inline-flex; align-items:center; gap:5px;
+            padding:4px 7px !important; }
+        .h3c-folder-icon { width:15px; height:15px; flex:none; fill:none;
+            stroke:currentColor; stroke-width:1.8; stroke-linecap:round;
+            stroke-linejoin:round; }
+        .h3c-title { font-size: 15px; font-weight: 700; }
+        .h3c-summary { color: var(--h3c-muted); text-align: right; }
+        .h3c-external-plan {
+            margin-bottom: 8px;
+            padding: 7px 9px;
+            border: 1px solid color-mix(in srgb, var(--h3c-accent) 65%, var(--h3c-border));
+            border-radius: 6px;
+            background: color-mix(in srgb, var(--h3c-accent) 12%, var(--h3c-panel));
+            color: var(--h3c-text);
+        }
+        .h3c-external-plan strong { color: var(--h3c-accent); }
+        .h3c-section {
+            margin-bottom: 9px;
+            padding: 9px;
+            border: 1px solid var(--h3c-border);
+            border-radius: 7px;
+            background: var(--h3c-panel);
+        }
+        .h3c-settings { display:none; }
+        .h3c-settings.h3c-open { display:block; }
+        .h3c-settings-head { display:flex; align-items:center; gap:8px;
+            margin-bottom:8px; }
+        .h3c-settings-head strong { font-size:13px; }
+        .h3c-policy-status { margin-left:auto; color:var(--h3c-muted); }
+        .h3c-policy-status.h3c-missing { color:#ffb4b8; }
+        .h3c-settings-grid { display:grid; grid-template-columns:repeat(2,minmax(0,1fr));
+            gap:8px; }
+        .h3c-settings-group { min-width:0; padding:8px; border:1px solid var(--h3c-border);
+            border-radius:6px; background:var(--h3c-bg); }
+        .h3c-settings-group-title { margin-bottom:7px; color:var(--h3c-accent);
+            font-weight:700; }
+        .h3c-settings-fields { display:grid; grid-template-columns:repeat(2,minmax(0,1fr));
+            gap:7px; }
+        .h3c-settings-fields .h3c-wide { grid-column:1 / -1; }
+        .h3c-managed-note { margin-top:6px; color:var(--h3c-muted); }
+        .h3c-label { display: block; margin-bottom: 4px; color: var(--h3c-muted); font-weight: 650; }
+        .h3c-help { margin-top: 4px; color: var(--h3c-muted); }
+        .h3c-prefix { min-height: 88px; }
+        .h3c-toolbar { position: sticky; top: -10px; z-index: 4; padding: 7px 0; background: var(--h3c-bg); }
+        .h3c-toolbar .h3c-spacer { flex: 1; }
+        .h3c-card {
+            --h3c-scene-color: var(--h3c-accent);
+            margin-bottom: 9px;
+            padding: 8px;
+            border: 1px solid color-mix(in srgb, var(--h3c-scene-color) 58%, var(--h3c-border));
+            border-left: 4px solid var(--h3c-scene-color);
+            border-radius: 7px;
+            background:
+                linear-gradient(90deg, color-mix(in srgb, var(--h3c-scene-color) 7%, transparent), transparent 140px),
+                var(--h3c-panel);
+        }
+        .h3c-card.h3c-invalid { border-left-color: #ff6b72; }
+        .h3c-card.h3c-drag-over { outline: 2px solid var(--h3c-accent); }
+        .h3c-card-head { margin-bottom: 7px; }
+        .h3c-drag { cursor: grab; user-select: none; padding: 4px 3px; color: var(--h3c-muted); }
+        .h3c-index { min-width: 58px; font-weight: 700; }
+        .h3c-color {
+            width: 23px !important;
+            min-width: 23px !important;
+            height: 23px;
+            padding: 1px !important;
+            border-radius: 50% !important;
+            cursor: pointer;
+        }
+        .h3c-color::-webkit-color-swatch-wrapper { padding: 1px; }
+        .h3c-color::-webkit-color-swatch { border: 0; border-radius: 50%; }
+        .h3c-color::-moz-color-swatch { border: 0; border-radius: 50%; }
+        .h3c-id { flex: 1; }
+        .h3c-timing { color: var(--h3c-muted); white-space: nowrap; }
+        .h3c-length-row { display: grid; grid-template-columns: 115px minmax(120px, 1fr) 190px; gap: 7px; align-items: center; margin-bottom: 7px; }
+        .h3c-prompt { min-height: 112px; }
+        .h3c-prompt-tools { position: relative; margin: 5px 0 2px; }
+        .h3c-prompt-tools .h3c-hint { color: var(--h3c-muted); margin-left: auto; }
+        .h3c-ref-menu {
+            display: none;
+            flex-wrap: wrap;
+            gap: 4px;
+            margin-top: 6px;
+            padding: 6px;
+            border: 1px solid var(--h3c-border);
+            border-radius: 6px;
+            background: var(--h3c-bg);
+        }
+        .h3c-ref-menu.h3c-open { display: flex; }
+        .h3c-ref-menu button { padding: 3px 6px; color: var(--h3c-accent); }
+        .h3c-seed-control { display:grid; grid-template-columns:minmax(210px,1fr) auto auto;
+            align-items:center; gap:6px; }
+        .h3c-seed-status { grid-column:1 / -1; color:var(--h3c-muted);
+            overflow-wrap:anywhere; }
+        .h3c-boundary-fields { display:grid; grid-template-columns:minmax(220px,1fr)
+            minmax(180px,.7fr); gap:7px; margin-top:8px; }
+        .h3c-audio-fields { display:grid; grid-template-columns:repeat(3,minmax(150px,1fr));
+            gap:7px; margin-top:8px; }
+        .h3c-advanced-fields { display: none; grid-template-columns:repeat(4, minmax(140px, 1fr)); gap: 7px; margin-top: 8px; }
+        .h3c-editor.h3c-show-advanced .h3c-advanced-fields { display: grid; }
+        .h3c-errors { display: none; margin: 7px 0; padding: 7px; border-radius: 5px; color: #ffb4b8; background: #5d202866; white-space: pre-wrap; }
+        .h3c-errors.h3c-open { display: block; }
+        .h3c-json-panel { display: none; }
+        .h3c-json-panel.h3c-open { display: block; }
+        .h3c-json { min-height: 260px; font-family: ui-monospace, SFMono-Regular, Consolas, monospace !important; }
+        .h3c-json-actions { margin-top: 6px; }
+        .h3c-json-status { color: var(--h3c-muted); }
+        .h3c-footer { justify-content: space-between; padding-top: 4px; color: var(--h3c-muted); }
+        .h3c-footer a { color: var(--h3c-accent); }
+        @media (max-width: 650px) {
+            .h3c-length-row, .h3c-advanced-fields,
+            .h3c-seed-control, .h3c-boundary-fields, .h3c-audio-fields,
+            .h3c-settings-grid, .h3c-settings-fields {
+                grid-template-columns: 1fr; }
+            .h3c-settings-fields .h3c-wide { grid-column:1; }
+            .h3c-seed-status { grid-column:1; }
+            .h3c-card-head { flex-wrap: wrap; }
+            .h3c-timing { width: 100%; }
+        }
+    `;
+    document.head.appendChild(style);
+}
+
+function element(tag, className, text) {
+    const item = document.createElement(tag);
+    if (className) item.className = className;
+    if (text !== undefined) item.textContent = text;
+    return item;
+}
+
+function button(label, title, action) {
+    const item = element("button", "", label);
+    item.type = "button";
+    if (title) item.title = title;
+    item.addEventListener("click", action);
+    return item;
+}
+
+function folderOpenIcon() {
+    const namespace = "http://www.w3.org/2000/svg";
+    const icon = document.createElementNS(namespace, "svg");
+    icon.classList.add("h3c-folder-icon");
+    icon.setAttribute("viewBox", "0 0 24 24");
+    icon.setAttribute("aria-hidden", "true");
+    const folder = document.createElementNS(namespace, "path");
+    folder.setAttribute(
+        "d",
+        "M3.5 8.5V6.25A1.75 1.75 0 0 1 5.25 4.5h4.1l2.1 2.25h7.3a1.75 1.75 0 0 1 1.75 1.75v1",
+    );
+    const opening = document.createElementNS(namespace, "path");
+    opening.setAttribute(
+        "d",
+        "M4.5 9.5h15.35a1.35 1.35 0 0 1 1.3 1.72l-2.05 7.1a1.6 1.6 0 0 1-1.54 1.18H5.4a1.6 1.6 0 0 1-1.57-1.3L2.9 13.15A3.1 3.1 0 0 1 4.5 9.5Z",
+    );
+    icon.append(folder, opening);
+    return icon;
+}
+
+function setOutputButtonLabel(item, label, showIcon = false) {
+    item.replaceChildren();
+    if (showIcon) item.append(folderOpenIcon());
+    item.append(document.createTextNode(label));
+}
+
+function field(label, control) {
+    const wrap = element("label", "");
+    wrap.append(element("span", "h3c-label", label), control);
+    return wrap;
+}
+
+function numberInput(value, options = {}) {
+    const input = element("input");
+    input.type = "number";
+    input.value = value ?? "";
+    for (const [key, setting] of Object.entries(options)) input[key] = setting;
+    return input;
+}
+
+function selectInput(value, choices) {
+    const select = element("select");
+    for (const [choice, label] of choices) {
+        const option = element("option", "", label);
+        option.value = choice;
+        select.append(option);
+    }
+    select.value = String(value ?? "");
+    return select;
+}
+
+function widgetValue(node, name, fallback) {
+    const widget = node.widgets?.find((item) => item.name === name);
+    return widget?.value ?? fallback;
+}
+
+function inputConnected(node, name) {
+    const input = node.inputs?.find((item) => item.name === name);
+    return input?.link !== null && input?.link !== undefined;
+}
+
+function setWidgetValue(node, name, value) {
+    const widget = node.widgets?.find((item) => item.name === name);
+    if (!widget || Object.is(widget.value, value)) return;
+    widget.value = value;
+    widget.callback?.(value);
+    node.graph?.setDirtyCanvas?.(true, true);
+    app.graph?.setDirtyCanvas?.(true, true);
+}
+
+function collapseWidget(widget) {
+    widget._h3OriginalType ??= widget.type;
+    widget._h3OriginalComputeSize ??= widget.computeSize;
+    widget._h3OriginalDraw ??= widget.draw;
+    widget.hidden = true;
+    widget.type = "hidden";
+    widget.computeSize = () => [0, -4];
+    // Modern and legacy canvas paths do not agree on whether a hidden widget
+    // may still draw. This field is internal editor state; preserve its value
+    // for serialization while ensuring it can never cover native settings.
+    widget.draw = () => {};
+
+    // Multiline STRING widgets are real DOM textareas in current ComfyUI.
+    // Collapsing only the LiteGraph geometry leaves that textarea floating at
+    // its previous coordinates, over the scene editor. Hide both possible DOM
+    // handles while retaining widget.value for workflow serialization.
+    const elements = new Set([widget.inputEl, widget.element]);
+    for (const item of elements) {
+        if (!item?.style) continue;
+        item.style.setProperty("display", "none", "important");
+        item.style.setProperty("pointer-events", "none", "important");
+        item.setAttribute?.("aria-hidden", "true");
+    }
+
+    // Current ComfyUI places DOM widgets in a separate Vue-owned wrapper.
+    // Its widget object is markRaw, so changing `hidden` can leave that empty
+    // wrapper pointer-active until a later renderer transition. Unregister
+    // only the DOM surface: this widget deliberately remains in node.widgets
+    // with its value and callback intact for workflow serialization.
+    if (widget.element && widget.id && typeof widget.onRemove === "function") {
+        widget.onRemove();
+    }
+}
+
+function collapseModernBackingWidgets(node) {
+    if ((node.comfyClass ?? node.type) !== MODERN_NODE_NAME) return;
+    for (const name of MODERN_BACKING_WIDGETS) {
+        const widget = node.widgets?.find((item) => item.name === name);
+        if (widget) collapseWidget(widget);
+    }
+}
+
+function setProjectAssetManagedWidget(widget, managed) {
+    if (!widget) return;
+    widget._h3ProjectAssetOriginal ??= {
+        hidden: widget.hidden,
+        type: widget.type,
+        computeSize: widget.computeSize,
+        draw: widget.draw,
+        disabled: widget.disabled,
+    };
+    if (widget._h3ProjectAssetManaged === managed) return;
+    widget._h3ProjectAssetManaged = managed;
+    const original = widget._h3ProjectAssetOriginal;
+    if (managed) {
+        widget.hidden = true;
+        widget.type = "hidden";
+        widget.computeSize = () => [0, -4];
+        widget.draw = () => {};
+        widget.disabled = true;
+    } else {
+        widget.hidden = original.hidden;
+        widget.type = original.type;
+        widget.computeSize = original.computeSize;
+        widget.draw = original.draw;
+        widget.disabled = original.disabled;
+    }
+    for (const item of new Set([widget.inputEl, widget.element])) {
+        if (!item?.style) continue;
+        if (managed) {
+            item.style.setProperty("display", "none", "important");
+            item.style.setProperty("pointer-events", "none", "important");
+            item.setAttribute?.("aria-hidden", "true");
+        } else {
+            item.style.removeProperty("display");
+            item.style.removeProperty("pointer-events");
+            item.removeAttribute?.("aria-hidden");
+        }
+    }
+}
+
+function colorOverrides(node) {
+    node.properties ??= {};
+    const current = node.properties[SCENE_COLOR_PROPERTY];
+    if (!current || typeof current !== "object" || Array.isArray(current)) {
+        node.properties[SCENE_COLOR_PROPERTY] = {};
+    }
+    return node.properties[SCENE_COLOR_PROPERTY];
+}
+
+function planLayout(node) {
+    node.properties ??= {};
+    const current = node.properties[LAYOUT_PROPERTY];
+    if (!current || typeof current !== "object" || Array.isArray(current)) {
+        node.properties[LAYOUT_PROPERTY] = {};
+    }
+    const layout = node.properties[LAYOUT_PROPERTY];
+    if (!layout.promptHeights || typeof layout.promptHeights !== "object"
+            || Array.isArray(layout.promptHeights)) {
+        layout.promptHeights = {};
+    }
+    return layout;
+}
+
+function sceneColorKey(shot, index) {
+    return safeShotId(shot?.id, `clip_${String(index + 1).padStart(4, "0")}`);
+}
+
+function sceneColor(node, shot, index) {
+    const override = colorOverrides(node)[sceneColorKey(shot, index)];
+    return /^#[0-9a-f]{6}$/i.test(String(override || ""))
+        ? String(override).toLowerCase()
+        : automaticSceneColor(index);
+}
+
+function insertText(textarea, text, selectionOffset = text.length) {
+    const start = textarea.selectionStart ?? textarea.value.length;
+    const end = textarea.selectionEnd ?? start;
+    textarea.setRangeText(text, start, end, "end");
+    const caret = start + selectionOffset;
+    textarea.setSelectionRange(caret, caret);
+    textarea.dispatchEvent(new Event("input", {bubbles: true}));
+    textarea.focus();
+}
+
+function insertDialogue(textarea) {
+    const start = textarea.selectionStart ?? textarea.value.length;
+    const end = textarea.selectionEnd ?? start;
+    const selected = textarea.value.slice(start, end);
+    const markup = `<d>${selected}</d>`;
+    const offset = selected ? markup.length : 3;
+    insertText(textarea, markup, offset);
+}
+
+function downloadJson(value, filename) {
+    const blob = new Blob([value], {type: "application/json"});
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = filename;
+    link.click();
+    setTimeout(() => URL.revokeObjectURL(url), 0);
+}
+
+function replaceWithModernPlan(node) {
+    const createNode = globalThis.LiteGraph?.createNode;
+    const result = upgradeLegacyPlanNode(node, {
+        createNode,
+        confirmUpgrade: () => (
+            typeof globalThis.confirm !== "function" || globalThis.confirm(
+                "Replace this Plan with MiniMax H3 Plan (Modern)?\n\n" +
+                "Scenes, supported settings, position, and links are preserved. " +
+                "Legacy fallback settings are intentionally not copied.",
+            )
+        ),
+    });
+    if (result.ok) {
+        app.canvas?.selectNode?.(result.node);
+        return;
+    }
+    if (result.reason === "cancelled") return;
+    const messages = {
+        policy_required:
+            "Connect MiniMax H3 Generation Profile to this Plan before upgrading. " +
+            "The Modern Plan has no legacy continuity or audio fallbacks, so the " +
+            "original node was kept unchanged.",
+        modern_unregistered:
+            "MiniMax H3 Plan (Modern) is not registered. Restart ComfyUI after " +
+            "updating the node pack.",
+        create_unavailable:
+            "ComfyUI could not create the Modern Plan node.",
+    };
+    globalThis.alert?.(messages[result.reason] ?? "The Plan could not be upgraded.");
+}
+
+function mountEditor(node) {
+    if (node._h3ChainEditor || typeof node.addDOMWidget !== "function") return;
+    const planWidget = node.widgets?.find((widget) => widget.name === "plan_json");
+    if (!planWidget) return;
+    const modern = (node.comfyClass ?? node.type) === MODERN_NODE_NAME;
+
+    injectStyles();
+    const root = element("div", "h3c-editor");
+    root.title = "Build an ordered MiniMax H3 scene plan. Hover individual controls for wiring, timing, and formatting guidance.";
+    for (const eventName of [
+        "pointerdown", "pointerup", "mousedown", "mouseup", "click", "dblclick",
+    ]) {
+        root.addEventListener(eventName, (event) => event.stopPropagation());
+    }
+    root.addEventListener("wheel", (event) => event.stopPropagation());
+    const savedLayout = planLayout(node);
+    const state = {
+        plan: null,
+        advanced: Boolean(savedLayout.advanced),
+        jsonOpen: Boolean(savedLayout.jsonOpen),
+        settingsOpen: modern && savedLayout.settingsOpen !== false,
+        lastWidgetValue: "",
+        syncing: false,
+        draggedIndex: null,
+        resizeObservers: [],
+        seedRefreshers: [],
+    };
+    node._h3ChainEditor = state;
+
+    collapseWidget(planWidget);
+    collapseModernBackingWidgets(node);
+
+    const domWidget = node.addDOMWidget("h3_chain_scene_editor", "h3-chain-editor", root, {
+        serialize: false,
+        hideOnZoom: false,
+        getMinHeight: () => EDITOR_HEIGHT,
+    });
+    domWidget.serialize = false;
+
+    function graphDirty() {
+        node.graph?.setDirtyCanvas?.(true, true);
+        app.graph?.setDirtyCanvas?.(true, true);
+    }
+
+    function savePanelState() {
+        const layout = planLayout(node);
+        layout.advanced = state.advanced;
+        layout.jsonOpen = state.jsonOpen;
+        layout.settingsOpen = state.settingsOpen;
+        graphDirty();
+    }
+
+    function disconnectResizeObservers() {
+        for (const observer of state.resizeObservers) observer.disconnect?.();
+        state.resizeObservers = [];
+    }
+
+    function bindTextareaHeight(textarea, key, minimum) {
+        const heights = planLayout(node).promptHeights;
+        const saved = Number(heights[key]);
+        if (Number.isFinite(saved) && saved >= minimum) {
+            textarea.style.height = `${Math.round(saved)}px`;
+        }
+        if (typeof ResizeObserver !== "function") return;
+        let initialized = false;
+        const observer = new ResizeObserver(() => {
+            if (!textarea.isConnected) return;
+            const next = Math.round(textarea.offsetHeight);
+            if (!Number.isFinite(next) || next < minimum) return;
+            if (!initialized) {
+                initialized = true;
+                return;
+            }
+            const current = planLayout(node).promptHeights;
+            if (Number(current[key]) === next) return;
+            current[key] = next;
+            node.properties[LAYOUT_PROPERTY] = {
+                ...planLayout(node), promptHeights: {...current},
+            };
+            graphDirty();
+        });
+        observer.observe(textarea);
+        state.resizeObservers.push(observer);
+    }
+
+    function saveSceneColor(key, value) {
+        const colors = colorOverrides(node);
+        if (value) colors[key] = value.toLowerCase();
+        else delete colors[key];
+        node.properties[SCENE_COLOR_PROPERTY] = {...colors};
+        graphDirty();
+    }
+
+    function applyResponsiveSize() {
+        collapseWidget(planWidget);
+        collapseModernBackingWidgets(node);
+        const width = Math.max(Number(node.size?.[0]) || MIN_WIDTH, MIN_WIDTH);
+        // Preserve the workflow/user-selected height. The DOM widget receives
+        // all free vertical space above its minimum, so taller nodes reveal
+        // more scene cards and shorter nodes scroll internally.
+        const height = Math.max(Number(node.size?.[1]) || 0, EDITOR_HEIGHT + 120);
+        // Call even when dimensions are unchanged so ComfyUI recomputes the
+        // DOM widget's free-space allocation after plan_json was collapsed.
+        node.setSize?.([width, height]);
+        graphDirty();
+    }
+
+    function scheduleResponsiveSize() {
+        // Workflow configuration restores serialized dimensions after
+        // onNodeCreated. Reallocate the DOM viewport once layout has settled.
+        requestAnimationFrame(() => requestAnimationFrame(applyResponsiveSize));
+        setTimeout(applyResponsiveSize, 150);
+    }
+
+    function syncProjectAssetManagedWidgets() {
+        const managed = inputConnected(node, "project_assets");
+        setProjectAssetManagedWidget(
+            node.widgets?.find((item) => item.name === "run_name"), managed,
+        );
+        setProjectAssetManagedWidget(
+            node.widgets?.find((item) => item.name === "generation_fingerprint"),
+            managed,
+        );
+        root.classList.toggle("h3c-project-assets-managed", managed);
+        root.title = managed
+            ? "Run name and reference fingerprint are managed by the connected Project Assets node."
+            : "Build an ordered MiniMax H3 scene plan. Hover individual controls for wiring, timing, and formatting guidance.";
+    }
+
+    function currentSettings() {
+        const transition = resolveTransitionPolicy(node);
+        const audioPolicy = resolveAudioPolicy(node);
+        return {
+            contextLength: transition.known
+                ? transition.contextLength
+                : widgetValue(node, "context_length", 22),
+            audioContextLength: resolveAudioContextLength(node),
+            videoBlendFrames: widgetValue(node, "video_blend_frames", 0),
+            encodeMode: widgetValue(node, "encode_mode", "video"),
+            anchorMode: widgetValue(node, "anchor_mode", "head"),
+            continuationMode: transition.known
+                ? transition.continuationMode
+                : widgetValue(node, "continuation_mode", "guide"),
+            generatedContinuity: audioPolicy.known
+                ? audioPolicy.generatedContinuity : "on",
+            sourceAudioTarget: audioPolicy.known
+                ? audioPolicy.sourceAudioTarget ?? "off" : "off",
+            transitionPreset: transition.known ? transition.preset : "custom",
+            audioPolicy,
+            defaultDurationSeconds: widgetValue(node, "default_duration_seconds", 15),
+            defaultSteps: widgetValue(node, "default_steps", 20),
+        };
+    }
+
+    function timing() {
+        return calculatePlanTiming(state.plan, currentSettings());
+    }
+
+    function syncPlan() {
+        if (!state.plan) return;
+        const value = planToJson(state.plan);
+        state.syncing = true;
+        planWidget.value = value;
+        state.lastWidgetValue = value;
+        state.syncing = false;
+        const jsonArea = root.querySelector(".h3c-json");
+        if (jsonArea && document.activeElement !== jsonArea) jsonArea.value = value;
+        updateTiming();
+        graphDirty();
+    }
+
+    function updateTiming() {
+        if (!state.plan) return;
+        const result = timing();
+        const summary = root.querySelector(".h3c-summary");
+        if (summary) {
+            summary.textContent = `${result.shots.length} scenes · ${result.totalFrames} delivered frames · ${formatClock(result.totalSeconds)}`;
+        }
+        for (const row of result.shots) {
+            const card = root.querySelector(`.h3c-card[data-index="${row.index - 1}"]`);
+            if (!card) continue;
+            const label = card.querySelector(".h3c-timing");
+            if (label) {
+                label.textContent = `${row.rawFrames || "—"} raw / ${row.deliveredFrames || "—"} delivered · ${formatClock(row.deliveredSeconds)}${row.loraRoute === "base" ? "" : ` · LoRA ${row.loraRoute.toUpperCase()}`}`;
+                label.title = row.errors.join("\n") ||
+                    `Generation starts at delivered frame ${row.generationStartFrame}. ` +
+                    `The incoming assembly boundary blends ${row.videoBlendFrames} frame(s).`;
+            }
+            card.classList.toggle("h3c-invalid", row.errors.length > 0);
+        }
+        const errors = root.querySelector(".h3c-errors");
+        if (errors) {
+            errors.textContent = result.errors.join("\n");
+            errors.classList.toggle("h3c-open", result.errors.length > 0);
+        }
+    }
+
+    function promptTools(textarea, scene = null) {
+        const wrap = element("div", "h3c-prompt-tools");
+        const references = button("@ Reference", "Insert a MiniMax reference tag", () => {
+            const opening = !menu.classList.contains("h3c-open");
+            if (opening) renderReferenceMenu();
+            menu.classList.toggle("h3c-open", opening);
+        });
+        const dialogue = button("# Dialogue", "Wrap the selection in <d> dialogue tags", () => {
+            insertDialogue(textarea);
+        });
+        const hint = element("span", "h3c-hint", "Shortcuts: @ reference · # dialogue");
+        const menu = element("div", "h3c-ref-menu");
+        function renderReferenceMenu() {
+            menu.replaceChildren();
+            const requestedScene = scene ?? 1;
+            const referenceData = availableReferenceRecords(
+                node, requestedScene, {
+                    includeInactive: true,
+                    prompt: [
+                        scene == null ? "" : sharedPrompt(state.plan).text.trim(),
+                        textarea.value.trim(),
+                    ].filter(Boolean).join("\n\n"),
+                },
+            );
+            const {mode} = referenceData;
+            const records = mode === "tagged" || scene == null
+                ? referenceData.records
+                : referenceData.records.filter((record) => record.active);
+            if (!records.length) {
+                menu.append(element(
+                    "span", "h3c-help",
+                    scene == null
+                        ? "No references connected to a downstream Ref2VA/I2V node."
+                        : `No connected references are active in scene ${scene}.`,
+                ));
+                return;
+            }
+            menu.append(element(
+                "span", "h3c-help",
+                mode === "tagged"
+                    ? "Connected prompt-driven references. Insert an @tag to activate that asset in this scene; it compiles to a native H3 label."
+                    : mode === "scheduled"
+                    ? "Connected scheduled references only. @aliases are optional authoring shortcuts that compile to native labels; the scheduler inserts no prompt text."
+                    : "Connected core references only. These use native <Picture/Video/Audio N> labels; @aliases are not required.",
+            ));
+            for (const record of records) {
+                const aliasMode = mode === "scheduled" || mode === "tagged";
+                const mapping = aliasMode && record.label
+                    ? ` → ${record.label}` : "";
+                menu.append(button(
+                    `${record.token}${mapping}`,
+                    aliasMode
+                        ? `Insert ${record.token}. It ${mode === "tagged" ? "activates this reference and " : ""}compiles to ${record.label ?? "a scene-local native label"}.`
+                        : `Insert ${record.token} for the connected core reference.`,
+                    () => {
+                        insertText(textarea, record.token);
+                        menu.classList.remove("h3c-open");
+                    },
+                ));
+            }
+        }
+        textarea.addEventListener("keydown", (event) => {
+            if (event.ctrlKey || event.metaKey || event.altKey) return;
+            if (event.key === "@") {
+                event.preventDefault();
+                renderReferenceMenu();
+                menu.classList.add("h3c-open");
+                references.focus();
+            } else if (event.key === "#") {
+                event.preventDefault();
+                insertDialogue(textarea);
+            }
+        });
+        wrap.append(references, dialogue, hint);
+        const group = element("div");
+        group.append(wrap, menu);
+        return group;
+    }
+
+    function renderCard(shot, index) {
+        const card = element("section", "h3c-card");
+        card.dataset.index = String(index);
+        card.style.setProperty("--h3c-scene-color", sceneColor(node, shot, index));
+        card.addEventListener("dragover", (event) => {
+            event.preventDefault();
+            card.classList.add("h3c-drag-over");
+        });
+        card.addEventListener("dragleave", () => card.classList.remove("h3c-drag-over"));
+        card.addEventListener("drop", (event) => {
+            event.preventDefault();
+            card.classList.remove("h3c-drag-over");
+            if (state.draggedIndex === null || state.draggedIndex === index) return;
+            moveShot(state.plan.shots, state.draggedIndex, index);
+            state.draggedIndex = null;
+            syncPlan();
+            render();
+        });
+
+        const head = element("div", "h3c-card-head");
+        const drag = element("span", "h3c-drag", "⠿");
+        drag.title = "Drag to reorder";
+        drag.draggable = true;
+        drag.addEventListener("dragstart", (event) => {
+            state.draggedIndex = index;
+            event.dataTransfer.effectAllowed = "move";
+            event.dataTransfer.setData("text/plain", String(index));
+        });
+        drag.addEventListener("dragend", () => {
+            state.draggedIndex = null;
+            root.querySelectorAll(".h3c-drag-over").forEach((item) => item.classList.remove("h3c-drag-over"));
+        });
+        const ordinal = element("span", "h3c-index", `Scene ${index + 1}`);
+        const color = element("input", "h3c-color");
+        color.type = "color";
+        color.value = sceneColor(node, shot, index);
+        color.title = "Scene border color. Double-click to restore the automatic color.";
+        color.setAttribute("aria-label", `Scene ${index + 1} border color`);
+        color.addEventListener("input", () => {
+            saveSceneColor(sceneColorKey(shot, index), color.value);
+            card.style.setProperty("--h3c-scene-color", color.value);
+        });
+        color.addEventListener("dblclick", (event) => {
+            event.preventDefault();
+            saveSceneColor(sceneColorKey(shot, index), null);
+            color.value = automaticSceneColor(index);
+            card.style.setProperty("--h3c-scene-color", color.value);
+        });
+        const id = element("input", "h3c-id");
+        id.type = "text";
+        id.placeholder = `clip_${String(index + 1).padStart(4, "0")}`;
+        id.value = shot.id ?? "";
+        id.title = "Stable scene ID used in checkpoint filenames and resume validation. Keep it unique and avoid changing it after rendering.";
+        id.addEventListener("input", () => {
+            const previousKey = sceneColorKey(shot, index);
+            const previousId = safeShotId(
+                shot.id, `clip_${String(index + 1).padStart(4, "0")}`,
+            );
+            if (id.value) shot.id = id.value;
+            else delete shot.id;
+            const nextId = safeShotId(
+                shot.id, `clip_${String(index + 1).padStart(4, "0")}`,
+            );
+            for (const chapter of state.plan.chapters ?? []) {
+                if (chapter.start_scene_id === previousId) {
+                    chapter.start_scene_id = nextId;
+                }
+            }
+            const nextKey = sceneColorKey(shot, index);
+            const colors = colorOverrides(node);
+            if (previousKey !== nextKey && colors[previousKey]) {
+                colors[nextKey] = colors[previousKey];
+                delete colors[previousKey];
+                node.properties[SCENE_COLOR_PROPERTY] = {...colors};
+            }
+            const heights = planLayout(node).promptHeights;
+            const previousPromptKey = `scene:${previousKey}`;
+            const nextPromptKey = `scene:${nextKey}`;
+            if (previousPromptKey !== nextPromptKey && heights[previousPromptKey]) {
+                heights[nextPromptKey] = heights[previousPromptKey];
+                delete heights[previousPromptKey];
+            }
+            syncPlan();
+            void refreshSeedStatus();
+        });
+        const timingLabel = element("span", "h3c-timing");
+        const up = button("↑", "Move scene up", () => {
+            moveShot(state.plan.shots, index, index - 1);
+            syncPlan();
+            render();
+        });
+        up.disabled = index === 0;
+        const down = button("↓", "Move scene down", () => {
+            moveShot(state.plan.shots, index, index + 1);
+            syncPlan();
+            render();
+        });
+        down.disabled = index === state.plan.shots.length - 1;
+        const copy = button("Duplicate", "Duplicate this scene", () => {
+            if (state.plan.shots.length >= MAX_SHOTS) return;
+            duplicateShot(state.plan.shots, index);
+            syncPlan();
+            render();
+        });
+        const remove = button("Delete", "Delete this scene", () => {
+            if (state.plan.shots.length <= 1) return;
+            if (!window.confirm(`Delete scene ${index + 1}?`)) return;
+            saveSceneColor(sceneColorKey(shot, index), null);
+            removePlanShot(state.plan, index);
+            syncPlan();
+            render();
+        });
+        remove.disabled = state.plan.shots.length <= 1;
+        head.append(drag, color, ordinal, id, timingLabel, up, down, copy, remove);
+
+        const lengthRow = element("div", "h3c-length-row");
+        const mode = element("select");
+        mode.title = "Choose whether this scene inherits the plan duration, requests seconds that are rounded up, or specifies an exact H3-valid frame count.";
+        for (const [value, label] of [["default", "Plan default"], ["seconds", "Seconds"], ["frames", "Exact frames"]]) {
+            const option = element("option", "", label);
+            option.value = value;
+            mode.append(option);
+        }
+        mode.value = shotLengthMode(shot);
+        const value = numberInput("", {min: "0.01", step: "0.01"});
+        const lengthHelp = element("span", "h3c-help");
+        function refreshLengthControl() {
+            const selected = shotLengthMode(shot);
+            mode.value = selected;
+            value.disabled = selected === "default";
+            if (selected === "seconds") {
+                value.min = "0.01";
+                value.max = String(3592 / 24);
+                value.step = "0.01";
+                value.value = shot.duration_seconds ?? "";
+                lengthHelp.textContent = "Rounded up to 17k+5.";
+                value.title = "Requested seconds. The backend rounds up to the next H3-valid 17k+5 frame length at 24 fps.";
+            } else if (selected === "frames") {
+                value.min = "5";
+                value.max = "3592";
+                value.step = "17";
+                value.value = shot.length ?? shot.frames ?? "";
+                lengthHelp.textContent = "Must satisfy length % 17 = 5.";
+                value.title = "Exact raw generation frames. Valid values satisfy frames % 17 = 5 and range from 5 to 3592.";
+            } else {
+                value.value = "";
+                lengthHelp.textContent = "Uses the Plan node default.";
+                value.title = "Disabled because this scene inherits the Plan node default duration.";
+            }
+        }
+        mode.addEventListener("change", () => {
+            const fallback = widgetValue(node, "default_duration_seconds", 15);
+            setShotLengthMode(shot, mode.value, fallback);
+            refreshLengthControl();
+            syncPlan();
+        });
+        value.addEventListener("input", () => {
+            if (!value.value) return;
+            if (mode.value === "seconds") shot.duration_seconds = Number(value.value);
+            if (mode.value === "frames") {
+                shot.length = Number(value.value);
+                delete shot.frames;
+            }
+            syncPlan();
+        });
+        refreshLengthControl();
+        lengthRow.append(mode, value, lengthHelp);
+
+        const prompt = element("textarea", "h3c-prompt");
+        prompt.value = promptValueToText(shot.prompt, `Scene ${index + 1} prompt`);
+        prompt.placeholder = "Optional with a shared prompt; otherwise describe this scene…";
+        prompt.title = "Scene-specific action, camera, performance, dialogue, and ending continuity. The shared prompt is automatically prepended; at least one of the two must contain text.";
+        prompt.spellcheck = true;
+        prompt.addEventListener("input", () => {
+            shot.prompt = promptTextToLines(prompt.value);
+            syncPlan();
+        });
+        bindTextareaHeight(
+            prompt, `scene:${sceneColorKey(shot, index)}`, 112,
+        );
+
+        const promptSeedControl = element("div", "h3c-seed-control");
+        const promptSeedMode = element("select");
+        for (const [value, label] of [
+            ["inherit", "Stable derived"],
+            ["fixed", "Fixed scene seed"],
+            ["randomize", "Randomize each queue"],
+        ]) {
+            const option = element("option", "", label);
+            option.value = value;
+            promptSeedMode.append(option);
+        }
+        const promptSeed = element("input");
+        promptSeed.type = "text";
+        promptSeed.inputMode = "numeric";
+        promptSeed.placeholder = "Scene prompt seed";
+        promptSeed.title = "Unsigned 64-bit seed used only to choose this scene's {one|two} prompt alternatives. It never changes the sampler seed.";
+        const newPromptSeed = button(
+            "New random",
+            "Create and store a new fixed alternative-choice seed for only this scene",
+            () => {
+                shot.prompt_seed_mode = "fixed";
+                shot.prompt_seed = randomSceneSeed();
+                refreshPromptSeedControl();
+                syncPlan();
+            },
+        );
+        function refreshPromptSeedControl() {
+            const selected = scenePromptSeedMode(shot);
+            promptSeedMode.value = selected;
+            promptSeed.disabled = selected !== "fixed";
+            newPromptSeed.disabled = selected !== "fixed";
+            promptSeed.value = selected === "fixed" ? (shot.prompt_seed ?? "") : "";
+            if (selected === "inherit") {
+                promptSeed.title = "This scene derives a stable alternative-choice seed from its scene index and ID.";
+            } else if (selected === "randomize") {
+                promptSeed.title = "A fresh alternative-choice seed is generated whenever this Plan is queued. The exact resolved seed is still saved with the scene checkpoint.";
+            } else {
+                promptSeed.title = "Unsigned 64-bit seed used only to choose this scene's {one|two} prompt alternatives. It never changes the sampler seed.";
+            }
+        }
+        promptSeedMode.addEventListener("change", () => {
+            setScenePromptSeedMode(shot, promptSeedMode.value);
+            refreshPromptSeedControl();
+            syncPlan();
+        });
+        promptSeed.addEventListener("change", () => {
+            if (promptSeed.value.trim()) shot.prompt_seed = promptSeed.value.trim();
+            else shot.prompt_seed = randomSceneSeed();
+            setScenePromptSeedMode(shot, "fixed");
+            refreshPromptSeedControl();
+            syncPlan();
+        });
+        promptSeedControl.append(promptSeedMode, promptSeed, newPromptSeed);
+        refreshPromptSeedControl();
+
+        const seedControl = element("div", "h3c-seed-control");
+        const seed = element("input");
+        seed.type = "text";
+        seed.inputMode = "numeric";
+        seed.placeholder = "Blank = stable derived seed";
+        seed.value = shot.seed ?? "";
+        seed.title = "Explicit unsigned 64-bit seed for this scene. Leave blank to use the displayed stable seed derived from base_seed, scene index, and scene ID.";
+        const seedStatus = element("span", "h3c-seed-status");
+        async function refreshSeedStatus() {
+            const explicit = seed.value.trim();
+            useDerivedSeed.disabled = !explicit;
+            if (explicit) {
+                seedStatus.textContent = `Explicit seed: ${explicit}`;
+                seedStatus.title = "This exact seed is stored in plan_json.";
+                return;
+            }
+            const baseSeed = widgetValue(node, "base_seed", 0);
+            const shotId = safeShotId(
+                shot.id, `clip_${String(index + 1).padStart(4, "0")}`,
+            );
+            const request = `${baseSeed}:${index + 1}:${shotId}`;
+            seedStatus.dataset.request = request;
+            seedStatus.textContent = "Resolving stable derived seed…";
+            try {
+                const resolved = await derivedSceneSeed(baseSeed, index + 1, shotId);
+                if (seedStatus.isConnected && !seed.value.trim()
+                        && seedStatus.dataset.request === request) {
+                    seedStatus.textContent = `Derived seed: ${resolved}`;
+                    seedStatus.title = `Stable result of base_seed ${baseSeed}, scene ${index + 1}, and ID ${shotId}. It will repeat until one of those values changes.`;
+                }
+            } catch (error) {
+                seedStatus.textContent = error.message;
+            }
+        }
+        seed.addEventListener("input", () => {
+            if (seed.value.trim()) shot.seed = seed.value.trim();
+            else delete shot.seed;
+            syncPlan();
+            void refreshSeedStatus();
+        });
+        const randomizeSeed = button("New random", "Create and store a new explicit uint64 seed for only this scene", () => {
+            seed.value = randomSceneSeed();
+            shot.seed = seed.value;
+            syncPlan();
+            void refreshSeedStatus();
+        });
+        const useDerivedSeed = button("Use derived", "Remove this scene's explicit override and return to its stable base_seed-derived value", () => {
+            seed.value = "";
+            delete shot.seed;
+            syncPlan();
+            void refreshSeedStatus();
+        });
+        useDerivedSeed.disabled = !seed.value.trim();
+        seedControl.append(seed, randomizeSeed, useDerivedSeed, seedStatus);
+        state.seedRefreshers.push(refreshSeedStatus);
+        void refreshSeedStatus();
+
+        const loraRoute = element("select", "h3c-lora-route");
+        const selectedLoRARoute = sceneLoRARoute(shot);
+        for (const route of availableLoRARoutes(
+            node.graph ?? app.graph, [node], selectedLoRARoute,
+        )) {
+            const option = element("option", "", loraRouteLabel(route));
+            option.value = route;
+            loraRoute.append(option);
+        }
+        loraRoute.value = selectedLoRARoute;
+        loraRoute.title = "Select Base or a connected A-Z MODEL branch on MiniMax H3 Scene LoRA Scheduler. Connecting the scheduler's last empty route reveals the next one automatically; the scheduler routes already-patched models and does not load a LoRA itself.";
+        loraRoute.addEventListener("change", () => {
+            if (loraRoute.value === "base") delete shot.lora_route;
+            else shot.lora_route = loraRoute.value;
+            sceneLoRARoute(shot);
+            syncPlan();
+        });
+
+        const advanced = element("div", "h3c-advanced-fields");
+        const steps = numberInput(shot.steps ?? "", {min: "1", max: "10000", step: "1"});
+        steps.placeholder = String(widgetValue(node, "default_steps", 20));
+        steps.title = "Optional sampler-step override for only this scene. Leave blank to inherit the Plan node default.";
+        steps.addEventListener("input", () => {
+            if (steps.value) shot.steps = Number(steps.value);
+            else delete shot.steps;
+            syncPlan();
+        });
+        const context = element("select", "h3c-context");
+        const resolvedPlanSettings = currentSettings();
+        const planContextLength = Number(resolvedPlanSettings.contextLength);
+        function normalizeVisualLeadSpan() {
+            if (!Object.hasOwn(shot, "visual_context_lead_source")) return;
+            const resolved = sceneContextLength(shot, planContextLength);
+            const allowed = visualContextCompositions()
+                .filter((choice) => choice.total === resolved)
+                .map((choice) => choice.lead);
+            if (!allowed.length) {
+                delete shot.visual_context_lead_source;
+                delete shot.visual_context_lead_frames;
+                delete shot.visual_context_lead_start_frame;
+                return;
+            }
+            try {
+                sceneVisualContextLeadFrames(shot, resolved);
+            } catch (_error) {
+                shot.visual_context_lead_frames = allowed[0];
+            }
+        }
+        const incomingTransition = element("select", "h3c-incoming-transition");
+        const inheritedPreset = resolvedPlanSettings.transitionPreset;
+        const inheritOption = element(
+            "option", "",
+            `Inherit Chain Policy · ${transitionPresetLabel(inheritedPreset)}`,
+        );
+        inheritOption.value = "inherit";
+        incomingTransition.append(inheritOption);
+        for (const preset of primaryTransitionOptions()) {
+            const option = element(
+                "option", "",
+                `${preset.label} · ${preset.description}`,
+            );
+            option.value = preset.name;
+            incomingTransition.append(option);
+        }
+        function refreshIncomingTransition() {
+            const selected = sceneTransitionPreset(
+                shot, resolvedPlanSettings.continuationMode,
+                resolvedPlanSettings.contextLength,
+                resolvedPlanSettings.audioContextLength,
+            );
+            let custom = incomingTransition.querySelector(
+                'option[value="custom"]',
+            );
+            if (selected === "custom" && !custom) {
+                custom = element(
+                    "option", "", transitionPresetLabel("custom"),
+                );
+                custom.value = "custom";
+                incomingTransition.append(custom);
+            }
+            incomingTransition.value = selected;
+        }
+        refreshIncomingTransition();
+        incomingTransition.title = "One semantic boundary choice. Inherit uses "
+            + "the connected Chain Policy. Choosing a preset writes its tested "
+            + "visual implementation/context pair and returns generated-audio "
+            + "context to automatic behavior. Custom means this scene still "
+            + "contains raw Advanced boundary overrides below.";
+        incomingTransition.addEventListener("change", () => {
+            if (incomingTransition.value === "custom") return;
+            applySceneTransitionPreset(shot, incomingTransition.value);
+            const nextContext = sceneContextLength(shot, planContextLength);
+            if (Object.hasOwn(shot, "video_blend_frames")
+                    && Number(shot.video_blend_frames) > nextContext) {
+                shot.video_blend_frames = nextContext;
+            }
+            normalizeVisualLeadSpan();
+            delete shot.visual_context_start_frame;
+            delete shot.visual_context_lead_start_frame;
+            syncPlan();
+            render();
+        });
+        for (const [value, label] of [
+            ["", `Plan default · ${planContextLength}`],
+            ["0", "0 · new visual"],
+            ...H3_CONTEXT_LENGTHS.map((value) => [String(value), `${value} frames`]),
+        ]) {
+            const option = element("option", "", label);
+            option.value = value;
+            context.append(option);
+        }
+        context.value = Object.hasOwn(shot, "context_length")
+            && shot.context_length !== null ? String(shot.context_length) : "";
+        context.title = index === 0
+            ? "Video context entering this scene. Blank inherits the Plan default. Zero makes scene 1 visually independent even when Existing Video Context is connected; the original may still be prepended during assembly."
+            : "Video frames carried from the preceding scene into this one. Blank inherits the Plan default; zero creates a visually new scene. Audio context is controlled separately.";
+        context.addEventListener("change", () => {
+            if (context.value === "") delete shot.context_length;
+            else shot.context_length = Number(context.value);
+            sceneContextLength(shot, planContextLength);
+            normalizeVisualLeadSpan();
+            delete shot.visual_context_start_frame;
+            delete shot.visual_context_lead_start_frame;
+            refreshBlendControl();
+            refreshIncomingTransition();
+            syncPlan();
+            render();
+        });
+        const visualSource = element("select", "h3c-visual-source");
+        if (index === 0) {
+            const option = element(
+                "option", "", "Existing Video Context (if connected)",
+            );
+            option.value = "";
+            visualSource.append(option);
+            visualSource.disabled = true;
+        } else {
+            const previous = element(
+                "option", "",
+                `Previous scene · ${index} ${safeShotId(
+                    state.plan.shots[index - 1]?.id,
+                    `clip_${String(index).padStart(4, "0")}`,
+                )}`,
+            );
+            previous.value = "";
+            visualSource.append(previous);
+            for (let sourceOffset = 0;
+                sourceOffset < index - 1; sourceOffset += 1) {
+                const sourceId = safeShotId(
+                    state.plan.shots[sourceOffset]?.id,
+                    `clip_${String(sourceOffset + 1).padStart(4, "0")}`,
+                );
+                const option = element(
+                    "option", "",
+                    `Scene ${sourceOffset + 1} · ${sourceId}`,
+                );
+                option.value = sourceId;
+                visualSource.append(option);
+            }
+            const rawSource = shot.visual_context_source;
+            if (rawSource === undefined || rawSource === null
+                    || ["", "previous", "immediate"].includes(
+                        String(rawSource).trim().toLowerCase())) {
+                visualSource.value = "";
+            } else {
+                try {
+                    const resolved = sceneVisualContextSource(
+                        state.plan, index + 1,
+                    );
+                    visualSource.value = resolved === index ? ""
+                        : safeShotId(
+                            state.plan.shots[resolved - 1]?.id,
+                            `clip_${String(resolved).padStart(4, "0")}`,
+                        );
+                } catch (_error) {
+                    const invalid = element(
+                        "option", "",
+                        `Invalid · ${String(rawSource)}`,
+                    );
+                    invalid.value = String(rawSource);
+                    visualSource.append(invalid);
+                    visualSource.value = String(rawSource);
+                }
+            }
+        }
+        visualSource.title = index === 0
+            ? "Scene 1 visual context comes from Existing Video Context."
+            : "Choose which earlier saved scene supplies the video/RGB context. Generated-audio continuity always comes from the immediately previous timeline scene. A non-linear source is a hard cut in final assembly.";
+        visualSource.addEventListener("change", () => {
+            if (!visualSource.value) {
+                delete shot.visual_context_source;
+            } else {
+                shot.visual_context_source = visualSource.value;
+                shot.video_blend_frames = 0;
+            }
+            delete shot.visual_context_start_frame;
+            refreshBlendControl();
+            syncPlan();
+            render();
+        });
+        const visualLeadSource = element("select", "h3c-visual-lead-source");
+        const noLead = element("option", "", "Off · one context block");
+        noLead.value = "";
+        visualLeadSource.append(noLead);
+        const recentSourceIndex = index === 0 ? null
+            : sceneVisualContextSource(state.plan, index + 1);
+        if (recentSourceIndex !== null) {
+            for (let sourceOffset = 0;
+                sourceOffset < index; sourceOffset += 1) {
+                const sourceId = safeShotId(
+                    state.plan.shots[sourceOffset]?.id,
+                    `clip_${String(sourceOffset + 1).padStart(4, "0")}`,
+                );
+                const sameSource = sourceOffset + 1 === recentSourceIndex;
+                const sourceLabel = `Scene ${sourceOffset + 1} · ${sourceId}`
+                    + (sameSource ? " · same scene, separate window" : "");
+                const option = element(
+                    "option", "", sourceLabel,
+                );
+                option.value = sourceId;
+                visualLeadSource.append(option);
+            }
+        }
+        visualLeadSource.disabled = index === 0;
+        try {
+            const resolvedLead = sceneVisualContextLeadSource(
+                state.plan, index + 1,
+            );
+            visualLeadSource.value = resolvedLead === null ? ""
+                : safeShotId(
+                    state.plan.shots[resolvedLead - 1]?.id,
+                    `clip_${String(resolvedLead).padStart(4, "0")}`,
+                );
+        } catch (_error) {
+            visualLeadSource.value = "";
+        }
+        visualLeadSource.title = "Optional first block in one composed visual context. It may use a different scene or a second independently positioned window from the same scene. Visual context source supplies the block nearest generation; audio remains one continuous tail from the immediate timeline scene.";
+
+        const visualLeadFrames = element("select", "h3c-visual-lead-frames");
+        const resolvedVisualContext = sceneContextLength(
+            shot, planContextLength,
+        );
+        const compositionChoices = visualContextCompositions();
+        const defaultComposition = compositionChoices.find(
+            (choice) => choice.total === resolvedVisualContext,
+        ) ?? compositionChoices[0];
+        visualLeadSource.disabled = visualLeadSource.disabled
+            || !compositionChoices.length;
+        for (const total of H3_CONTEXT_LENGTHS) {
+            const groupChoices = compositionChoices.filter(
+                (choice) => choice.total === total,
+            );
+            if (!groupChoices.length) continue;
+            const group = element("optgroup", "");
+            group.label = `${total} total frames`;
+            for (const choice of groupChoices) {
+                const option = element("option", "", choice.label);
+                option.value = choice.value;
+                group.append(option);
+            }
+            visualLeadFrames.append(group);
+        }
+        visualLeadFrames.disabled = !visualLeadSource.value
+            || !compositionChoices.length;
+        if (visualLeadSource.value) {
+            try {
+                const lead = sceneVisualContextLeadFrames(
+                    shot, resolvedVisualContext,
+                );
+                visualLeadFrames.value = `${resolvedVisualContext}:${lead}`;
+            } catch (_error) {
+                visualLeadFrames.value = defaultComposition?.value ?? "";
+            }
+        } else {
+            visualLeadFrames.value = defaultComposition?.value ?? "";
+        }
+        visualLeadFrames.title = "Select the total H3 context and its ordered two-block split. Both blocks may use the same scene with independent floating windows. For example, 39 total includes 5+34, 17+22, and their reverse orientations.";
+        function applyVisualComposition() {
+            const [totalRaw, leadRaw] = visualLeadFrames.value.split(":");
+            const total = Number(totalRaw);
+            const lead = Number(leadRaw);
+            if (!Number.isInteger(total) || !Number.isInteger(lead)) return;
+            shot.context_length = total;
+            shot.visual_context_lead_frames = lead;
+            sceneVisualContextLeadFrames(shot, total);
+            shot.video_blend_frames = 0;
+        }
+        visualLeadSource.addEventListener("change", () => {
+            if (!visualLeadSource.value) {
+                delete shot.visual_context_lead_source;
+                delete shot.visual_context_lead_frames;
+                delete shot.visual_context_lead_start_frame;
+            } else {
+                shot.visual_context_lead_source = visualLeadSource.value;
+                applyVisualComposition();
+            }
+            delete shot.visual_context_start_frame;
+            delete shot.visual_context_lead_start_frame;
+            refreshBlendControl();
+            syncPlan();
+            render();
+        });
+        visualLeadFrames.addEventListener("change", () => {
+            if (visualLeadSource.value) {
+                applyVisualComposition();
+            }
+            delete shot.visual_context_start_frame;
+            delete shot.visual_context_lead_start_frame;
+            refreshBlendControl();
+            syncPlan();
+            render();
+        });
+        const audioContext = numberInput(shot.audio_context_length ?? "", {
+            min: "0", max: "240", step: "1",
+        });
+        const planAudioContextLength = Number(
+            resolvedPlanSettings.audioContextLength,
+        );
+        audioContext.placeholder = planAudioContextLength
+            ? String(planAudioContextLength)
+            : `Follow video · ${planContextLength}`;
+        audioContext.title = "Generated-audio context entering this scene. Blank inherits the Plan audio default (whose 0 follows video context). An explicit 0 carries no prior generated sound. A positive value can continue audio when video context is 0. AV mask modes ignore this override and keep audio synchronized to the video prefix; source_track uses its exact timeline slice instead.";
+        audioContext.addEventListener("input", () => {
+            if (audioContext.value === "") delete shot.audio_context_length;
+            else shot.audio_context_length = Number(audioContext.value);
+            refreshIncomingTransition();
+            syncPlan();
+        });
+        const blendFrames = numberInput(shot.video_blend_frames ?? "", {
+            min: "0", max: String(planContextLength), step: "1",
+        });
+        const planBlendFrames = Number(resolvedPlanSettings.videoBlendFrames);
+        function refreshBlendControl() {
+            const resolvedContext = sceneContextLength(shot, planContextLength);
+            blendFrames.max = String(resolvedContext);
+            blendFrames.placeholder = String(Math.min(
+                planBlendFrames, resolvedContext,
+            ));
+        }
+        refreshBlendControl();
+        blendFrames.title = index === 0
+            ? "Visible assembly blend entering scene 1 when Existing Video Context supplies a predecessor. Blank inherits the Plan default, capped to this scene's video context. This is assembly-only and does not alter sampling."
+            : "Visible assembly blend at the boundary from the previous scene into this scene. Blank inherits the Plan default, capped to this scene's video context. Zero keeps a hard cut. This is assembly-only and does not alter sampling.";
+        blendFrames.addEventListener("input", () => {
+            if (blendFrames.value === "") delete shot.video_blend_frames;
+            else shot.video_blend_frames = Number(blendFrames.value);
+            sceneVideoBlendFrames(
+                shot, planBlendFrames,
+                sceneContextLength(shot, planContextLength),
+            );
+            syncPlan();
+        });
+        const continuation = element("select", "h3c-continuation");
+        const planContinuationMode = resolvedPlanSettings.continuationMode;
+        for (const [value, label] of [
+            ["", `Plan default · ${planContinuationMode}`],
+            ["guide", "Guide · new shot"],
+            ["tone_carry_guide", "Tone Carry Guide · corrected RGB context"],
+            ["latent_guide", "Latent Guide · direct generated latent"],
+            ["tapered_guide", "Detail Guide · color injection"],
+            ["tapered_av", "Detail AV · experimental latent taper"],
+            ["drift_control_av", "Drift-Control AV · schedule-matched mask"],
+            ["color_stable_drift_av", "Color-Stable Drift AV · tapered scene-one latent delta"],
+            ["masked_av", "Masked AV · same shot"],
+            ["feathered_av", "Feathered AV · experimental dual-stream feather"],
+            ["audio_feathered_av", "Audio Feather AV · hard picture, soft sound"],
+        ]) {
+            const option = element("option", "", label);
+            option.value = value;
+            continuation.append(option);
+        }
+        continuation.value = Object.hasOwn(shot, "continuation_mode")
+            ? sceneContinuationMode(shot, planContinuationMode) : "";
+        continuation.title = index === 0
+            ? "Continuation into this scene. Scene 1 uses it only when Existing Video Context supplies a predecessor. Guide re-encodes RGB; Latent Guide directly reuses a generated predecessor latent and falls back to RGB for imported context; Detail Guide adds a tapered chroma treatment; Detail AV applies a disposable video-only latent taper; Drift-Control AV applies a scheduler-matched video mask with a clean seam and needs the Chain Context MODEL path; Color-Stable Drift AV additionally carries a weak scene-one color correction as a tapered VAE delta on the copied video latent only; Masked AV protects an exact prefix; experimental Feathered AV softens both streams; Audio-Feathered AV keeps the picture exact and softens only the final audio ticks."
+            : "Continuation from the preceding scene. Guide re-encodes RGB into persistent conditioning; Latent Guide supplies the saved sampled-latent tail as persistent conditioning; Detail Guide applies luma-preserving tapered chroma injection; Detail AV applies a disposable video-only latent taper; Drift-Control AV applies a scheduler-matched video mask with a clean seam and needs the Chain Context MODEL path; Color-Stable Drift AV additionally carries a weak scene-one color correction as a tapered VAE delta on the copied video latent only; Masked AV protects an exact prefix; experimental Feathered AV softens both streams; Audio-Feathered AV keeps the picture exact and softens only the final audio ticks.";
+        continuation.addEventListener("change", () => {
+            if (continuation.value) {
+                shot.continuation_mode = continuation.value;
+            } else {
+                delete shot.continuation_mode;
+            }
+            // Resolve once here so malformed externally supplied values cannot
+            // be introduced through the compact editor control.
+            sceneContinuationMode(shot, planContinuationMode);
+            refreshIncomingTransition();
+            syncPlan();
+        });
+        const spatialProxy = element("select", "h3c-spatial-proxy");
+        for (const [value, label] of [
+            ["", "Off · native context"],
+            ["rgb_5_6", "Low-grid 5/6 proxy · Guide"],
+            ["latent_5_6", "Latent 5/6 proxy · AV"],
+        ]) {
+            const option = element("option", "", label);
+            option.value = value;
+            spatialProxy.append(option);
+        }
+        spatialProxy.value = shot.context_spatial_proxy ?? "";
+        spatialProxy.title = "Scheduled only on the boundary entering scenes 2+. Low-grid 5/6 reduces and VAE-decodes the complete saved predecessor video latent at the proxy canvas, takes its delivered tail, then Motion Context restores those Guide frames to the target; 1376×768 uses 1152×640 (48×86 → 40×72 latent). This exact low-grid decode costs extra preparation time and peak memory. Latent 5/6 applies a cheaper latent down/up filter only to the copied AV video prefix. Audio, generated output, checkpoints, and assembly remain native size.";
+        spatialProxy.addEventListener("change", () => {
+            if (spatialProxy.value) {
+                shot.context_spatial_proxy = spatialProxy.value;
+            } else {
+                delete shot.context_spatial_proxy;
+            }
+            syncPlan();
+        });
+        const boundary = element("div", "h3c-boundary-fields");
+        boundary.append(
+            field("Incoming transition", incomingTransition),
+            field("Final assembly crossfade frames", blendFrames),
+        );
+        const planAudioPolicy = resolvedPlanSettings.audioPolicy;
+        const effectiveAudioPolicy = sceneAudioPolicy(shot, planAudioPolicy);
+        const lipSync = element("select");
+        for (const [value, label] of [
+            ["inherit", `Inherit · ${planAudioPolicy.sourceAudioTarget === "locked" ? "On" : "Off"}`],
+            ["on", "On · vocals drive this scene"],
+            ["off", "Off · no source-audio guidance"],
+            ["custom", "Custom · advanced audio controls"],
+        ]) {
+            const option = element("option", "", label);
+            option.value = value; option.disabled = value === "custom";
+            lipSync.append(option);
+        }
+        lipSync.value = sceneLipSyncMode(shot);
+        lipSync.title = "On locks grouped vocals (or a legacy single track). Off "
+            + "disables source locking, reference, and audio carry without changing "
+            + "the final soundtrack. Inherit resets these three audio overrides.";
+        lipSync.addEventListener("change", () => {
+            applySceneLipSync(shot, lipSync.value);
+            syncPlan();
+            render();
+        });
+        function audioOverrideSelect(key, inherited, choices, title) {
+            const select = element("select", "h3c-audio-override");
+            const inheritedOption = element(
+                "option", "", `Inherit Chain Policy · ${inherited}`,
+            );
+            inheritedOption.value = "inherit";
+            select.append(inheritedOption);
+            for (const [value, label] of choices) {
+                const option = element("option", "", label);
+                option.value = value;
+                select.append(option);
+            }
+            select.value = sceneAudioOverride(shot, key);
+            select.title = title;
+            select.addEventListener("change", () => {
+                applySceneAudioOverride(shot, key, select.value);
+                lipSync.value = sceneLipSyncMode(shot);
+                syncPlan();
+            });
+            return select;
+        }
+        const sourceReference = audioOverrideSelect(
+            "source_reference",
+            planAudioPolicy.sourceReference ?? effectiveAudioPolicy.sourceReference,
+            [["on", "On · use this source-track window as Ref2VA audio"],
+             ["off", "Off · no source audio reference"]],
+            "Controls only this scene's loose source-audio Ref2VA reference. "
+                + "It does not choose final soundtrack. Lock source audio wins "
+                + "over this switch.",
+        );
+        const generatedContinuity = audioOverrideSelect(
+            "generated_continuity",
+            planAudioPolicy.generatedContinuity
+                ?? effectiveAudioPolicy.generatedContinuity,
+            [["on", "On · continue prior generated audio"],
+             ["off", "Off · generate an independent audio stream"]],
+            "Controls whether this scene carries the predecessor's generated "
+                + "audio latent. Lock source audio wins over this switch.",
+        );
+        const inheritedLock = (planAudioPolicy.sourceAudioTarget ?? "off")
+            === "locked" ? "on" : "off";
+        const lockSourceAudio = audioOverrideSelect(
+            "source_audio_target", inheritedLock,
+            [["locked", "On · protect this exact source window"],
+             ["off", "Off · leave target audio denoisable"]],
+            "Locks only this scene's exact source waveform into the H3 target "
+                + "audio latent. While on, loose source reference and generated "
+                + "continuity are effectively off. Final soundtrack remains "
+                + "the global Chain Policy choice.",
+        );
+        const audioFields = element("div", "h3c-audio-fields");
+        audioFields.append(
+            field("Lip-sync", lipSync),
+            field("Source reference", sourceReference),
+            field("Generated continuity", generatedContinuity),
+            field("Lock source audio", lockSourceAudio),
+        );
+        advanced.append(
+            field("Steps (blank = default)", steps),
+            field("Advanced visual context", context),
+            field("Visual context source", visualSource),
+            field("Context block 1 source", visualLeadSource),
+            field("Composed total / split", visualLeadFrames),
+            field("Advanced audio context", audioContext),
+            field("Advanced implementation", continuation),
+            field("Boundary spatial proxy", spatialProxy),
+        );
+        card.append(
+            head,
+            lengthRow,
+            field("Scene prompt (optional with shared prompt)", prompt),
+            promptTools(prompt, index + 1),
+            field("Prompt alternatives", promptSeedControl),
+            field("Scene seed", seedControl),
+            field("Scene LoRA route", loraRoute),
+            boundary,
+            audioFields,
+            advanced,
+        );
+        return card;
+    }
+
+    function renderModernSettings() {
+        if (!modern) return null;
+        const managed = inputConnected(node, "project_assets");
+        const panel = element(
+            "section",
+            `h3c-section h3c-settings${state.settingsOpen ? " h3c-open" : ""}`,
+        );
+        const heading = element("div", "h3c-settings-head");
+        const profileConnected = inputConnected(node, "chain_policy");
+        const policyStatus = element(
+            "span",
+            `h3c-policy-status${profileConnected ? "" : " h3c-missing"}`,
+            profileConnected
+                ? "Generation Profile connected"
+                : "Generation Profile required",
+        );
+        heading.append(
+            element("strong", "", "Plan settings"),
+            element(
+                "span", "h3c-help",
+                "Continuity and audio live in Generation Profile.",
+            ),
+            policyStatus,
+        );
+
+        function group(title, ...fields) {
+            const wrap = element("div", "h3c-settings-group");
+            wrap.append(element("div", "h3c-settings-group-title", title));
+            const grid = element("div", "h3c-settings-fields");
+            grid.append(...fields);
+            wrap.append(grid);
+            return wrap;
+        }
+
+        function textSetting(name, label, options = {}) {
+            const control = element("input");
+            control.type = "text";
+            if (options.numeric) control.inputMode = "numeric";
+            control.value = String(widgetValue(node, name, options.fallback ?? ""));
+            control.disabled = Boolean(options.disabled);
+            control.title = options.title ?? "";
+            control.addEventListener("change", () => {
+                let value = control.value;
+                if (options.numeric) {
+                    value = value.trim();
+                    if (!/^\d+$/.test(value)) {
+                        control.value = String(widgetValue(
+                            node, name, options.fallback ?? "0"));
+                        return;
+                    }
+                }
+                setWidgetValue(node, name, value);
+                updateTiming();
+            });
+            const wrapped = field(label, control);
+            if (options.wide) wrapped.classList.add("h3c-wide");
+            return wrapped;
+        }
+
+        function numberSetting(name, label, options) {
+            const control = numberInput(widgetValue(node, name, options.fallback), {
+                min: options.min,
+                max: options.max,
+                step: options.step,
+            });
+            control.title = options.title ?? "";
+            control.addEventListener("change", () => {
+                if (!control.validity.valid || control.value === "") {
+                    control.value = String(widgetValue(
+                        node, name, options.fallback));
+                    return;
+                }
+                setWidgetValue(node, name, Number(control.value));
+                updateTiming();
+            });
+            return field(label, control);
+        }
+
+        function choiceSetting(name, label, choices, title) {
+            const control = selectInput(widgetValue(node, name, choices[0][0]), choices);
+            control.title = title;
+            control.addEventListener("change", () => {
+                setWidgetValue(node, name, control.value);
+                updateTiming();
+            });
+            return field(label, control);
+        }
+
+        const run = textSetting("run_name", "Run name", {
+            fallback: "h3_chain", disabled: managed,
+            title: managed
+                ? "Managed by the connected Project Asset Carousel."
+                : "Folder and checkpoint identity for this production.",
+        });
+        const fingerprint = textSetting(
+            "generation_fingerprint", "Generation fingerprint", {
+                fallback: "", disabled: managed, wide: true,
+                title: managed
+                    ? "Project Assets contributes the active reference lineage."
+                    : "Change this when model, VAE, LoRA, CFG, sampler, scheduler, or global references change.",
+            },
+        );
+        const project = group("Project", run, fingerprint);
+        if (managed) {
+            project.append(element(
+                "div", "h3c-managed-note",
+                "Run identity and reference lineage are managed by Project Assets.",
+            ));
+        }
+
+        const canvas = group(
+            "Canvas & context fitting",
+            numberSetting("width", "Width", {
+                fallback:960, min:32, max:4096, step:32,
+                title:"Generation width; must be a multiple of 32.",
+            }),
+            numberSetting("height", "Height", {
+                fallback:544, min:32, max:4096, step:32,
+                title:"Generation height; must be a multiple of 32.",
+            }),
+            choiceSetting("encode_mode", "Context encoding", [
+                ["video", "Video · preserve motion"],
+                ["frames", "Frames · still anchors"],
+            ], "How carried picture context is encoded."),
+            choiceSetting("crop", "Context fit", [
+                ["disabled", "Resize to canvas"],
+                ["center", "Preserve ratio + center crop"],
+            ], "How saved picture context is fitted to the Plan canvas."),
+        );
+        const defaults = group(
+            "Generation defaults",
+            numberSetting("default_duration_seconds", "Default seconds", {
+                fallback:15, min:0.1, max:15.0833333333, step:0.01,
+                title:"Used only when a scene has no explicit duration or frame length.",
+            }),
+            numberSetting("default_steps", "Default steps", {
+                fallback:20, min:1, max:10000, step:1,
+                title:"Used only when a scene has no sampler-step override.",
+            }),
+            textSetting("base_seed", "Base seed", {
+                fallback:"0", numeric:true, wide:true,
+                title:"Stable uint64 base used to derive one seed per scene.",
+            }),
+        );
+        const delivery = group(
+            "Delivery",
+            numberSetting("segment_crf", "Scene MP4 quality (CRF)", {
+                fallback:18, min:0, max:51, step:1,
+                title:"Lower is higher quality; 18 is visually high quality.",
+            }),
+            numberSetting("video_blend_frames", "Default crossfade frames", {
+                fallback:0, min:0, max:243, step:1,
+                title:"Default final-assembly picture blend entering a scene; 0 is a hard cut.",
+            }),
+        );
+        const grid = element("div", "h3c-settings-grid");
+        grid.append(project, canvas, defaults, delivery);
+        panel.append(heading, grid);
+        return panel;
+    }
+
+    function render() {
+        if (!state.plan) return;
+        disconnectResizeObservers();
+        state.seedRefreshers = [];
+        const scrollTop = root.scrollTop;
+        root.replaceChildren();
+        root.classList.toggle("h3c-show-advanced", state.advanced);
+
+        const externalPlanConnected = inputConnected(node, "plan_json_input");
+        const header = element("div", "h3c-header");
+        const openOutput = button(
+            "Output",
+            "Open this Plan's output/h3_chains/<run_name> folder on the ComfyUI host. " +
+            "If the host has no desktop session, its path is copied instead.",
+            async () => {
+                const runName = String(widgetValue(node, "run_name", "")).trim();
+                openOutput.disabled = true;
+                setOutputButtonLabel(openOutput, "Opening…");
+                try {
+                    const response = await api.fetchApi(
+                        "/minimax_h3_context_loop/open-run-folder",
+                        {
+                            method: "POST",
+                            headers: {"Content-Type": "application/json"},
+                            body: JSON.stringify({run_name: runName}),
+                        },
+                    );
+                    const payload = await response.json();
+                    if (!response.ok) throw new Error(payload.error || `HTTP ${response.status}`);
+                    openOutput.title = payload.path;
+                    if (payload.opened) {
+                        setOutputButtonLabel(openOutput, "Opened ✓");
+                    } else {
+                        try {
+                            await navigator.clipboard.writeText(payload.path);
+                            setOutputButtonLabel(openOutput, "Path copied");
+                        } catch (_error) {
+                            setOutputButtonLabel(openOutput, "See tooltip");
+                        }
+                        if (payload.error) openOutput.title += `\n${payload.error}`;
+                    }
+                } catch (error) {
+                    setOutputButtonLabel(openOutput, "Open failed");
+                    openOutput.title = String(error?.message || error);
+                } finally {
+                    setTimeout(() => {
+                        setOutputButtonLabel(openOutput, "Output", true);
+                        openOutput.disabled = false;
+                    }, 2200);
+                }
+            },
+        );
+        openOutput.classList.add("h3c-open-output");
+        openOutput.setAttribute("aria-label", "Open project output folder");
+        setOutputButtonLabel(openOutput, "Output", true);
+        const headerActions = element("div", "h3c-header-actions");
+        if (modern) {
+            headerActions.append(button(
+                state.settingsOpen ? "Hide settings" : "Settings",
+                "Show or hide the organized Plan settings",
+                () => {
+                    state.settingsOpen = !state.settingsOpen;
+                    savePanelState();
+                    render();
+                },
+            ));
+        }
+        headerActions.append(openOutput, element("div", "h3c-summary"));
+        header.append(element(
+            "div", "h3c-title",
+            modern ? "MiniMax H3 Modern Plan" : "MiniMax H3 Scene Plan",
+        ), headerActions);
+        const settingsPanel = renderModernSettings();
+
+        const externalNotice = element("div", "h3c-external-plan");
+        externalNotice.append(
+            element("strong", "", "External plan input connected. "),
+            document.createTextNode(
+                "A non-empty upstream string controls execution. The editor below " +
+                "shows and edits the local fallback used only when that string is empty " +
+                "or disconnected.",
+            ),
+        );
+
+        const prefix = element("textarea", "h3c-prefix");
+        prefix.value = sharedPrompt(state.plan).text;
+        prefix.placeholder = "Identity, wardrobe, style and continuity rules shared by every scene…";
+        prefix.title = "Text automatically prepended to every scene prompt. Put identity, wardrobe, reference definitions, audio rules, style, and global continuity here instead of repeating them.";
+        prefix.spellcheck = true;
+        prefix.addEventListener("input", () => {
+            setSharedPrompt(state.plan, prefix.value);
+            syncPlan();
+        });
+        bindTextareaHeight(prefix, "shared", 88);
+        const prefixSection = element("section", "h3c-section");
+        prefixSection.append(
+            field("Shared prompt — automatically prepended to every scene", prefix),
+            promptTools(prefix, null),
+        );
+
+        const toolbar = element("div", "h3c-toolbar");
+        const add = button("+ Add scene", "Append a new scene", () => {
+            if (state.plan.shots.length >= MAX_SHOTS) return;
+            state.plan.shots.push(makeShot(state.plan.shots));
+            syncPlan();
+            render();
+        });
+        add.disabled = state.plan.shots.length >= MAX_SHOTS;
+        const advanced = button(state.advanced ? "Hide advanced" : "Show advanced", "Show or hide per-scene sampler-step and continuation overrides", () => {
+            state.advanced = !state.advanced;
+            savePanelState();
+            render();
+        });
+        const json = button(state.jsonOpen ? "Hide raw JSON" : "Raw JSON", "Expand the raw plan JSON for direct editing, import, or export", () => {
+            state.jsonOpen = !state.jsonOpen;
+            savePanelState();
+            render();
+        });
+        toolbar.append(add, advanced, element("span", "h3c-spacer"), json);
+
+        const errors = element("div", "h3c-errors");
+        const cards = element("div", "h3c-cards");
+        state.plan.shots.forEach((shot, index) => cards.append(renderCard(shot, index)));
+
+        const jsonPanel = element("section", `h3c-section h3c-json-panel${state.jsonOpen ? " h3c-open" : ""}`);
+        const jsonArea = element("textarea", "h3c-json");
+        jsonArea.value = planToJson(state.plan);
+        jsonArea.spellcheck = false;
+        jsonArea.title = "Canonical plan JSON. Apply JSON replaces the visual editor contents after validation; saving the workflow also serializes this value.";
+        bindTextareaHeight(jsonArea, "json", 260);
+        const jsonStatus = element("span", "h3c-json-status", "Raw JSON escape hatch");
+        const apply = button("Apply JSON", "Validate and load this JSON into the scene editor", () => {
+            try {
+                state.plan = parsePlanJson(jsonArea.value);
+                jsonStatus.textContent = "JSON applied";
+                syncPlan();
+                render();
+            } catch (error) {
+                jsonStatus.textContent = error.message;
+            }
+        });
+        const copyJson = button("Copy", "Copy plan JSON", async () => {
+            try {
+                await navigator.clipboard.writeText(jsonArea.value);
+                jsonStatus.textContent = "Copied";
+            } catch (_error) {
+                jsonArea.select();
+                document.execCommand("copy");
+                jsonStatus.textContent = "Copied";
+            }
+        });
+        const saveJson = button("Save .json", "Download this plan as JSON", () => {
+            const runName = String(widgetValue(node, "run_name", "h3_chain"));
+            downloadJson(jsonArea.value, `${runName || "h3_chain"}_plan.json`);
+        });
+        const loadInput = element("input");
+        loadInput.type = "file";
+        loadInput.accept = ".json,application/json";
+        loadInput.hidden = true;
+        loadInput.addEventListener("change", async () => {
+            const file = loadInput.files?.[0];
+            if (!file) return;
+            jsonArea.value = await file.text();
+            apply.click();
+            loadInput.value = "";
+        });
+        const loadJson = button("Load .json", "Load a plan JSON file", () => loadInput.click());
+        const jsonActions = element("div", "h3c-json-actions");
+        jsonActions.append(apply, copyJson, saveJson, loadJson, loadInput, jsonStatus);
+        jsonPanel.append(jsonArea, jsonActions);
+
+        const footer = element("div", "h3c-footer");
+        footer.append(
+            element(
+                "span",
+                "",
+                externalPlanConnected
+                    ? "Edits are serialized into fallback plan_json; non-empty external JSON takes precedence."
+                    : "Edits are serialized into plan_json; connect plan_json_input for an external override.",
+            ),
+            Object.assign(element("a", "", "UI inspiration: nkxx188"), {
+                href: "https://github.com/nkxx188/ComfyUI-MiniMaxH3-Easy",
+                target: "_blank",
+                rel: "noreferrer",
+            }),
+        );
+
+        root.append(
+            header,
+            ...(settingsPanel ? [settingsPanel] : []),
+            ...(externalPlanConnected ? [externalNotice] : []),
+            prefixSection,
+            toolbar,
+            errors,
+            cards,
+            jsonPanel,
+            footer,
+        );
+        updateTiming();
+        requestAnimationFrame(() => { root.scrollTop = scrollTop; });
+        graphDirty();
+    }
+
+    function loadFromWidget(force = false) {
+        const value = String(planWidget.value ?? "");
+        if (!force && value === state.lastWidgetValue) return;
+        try {
+            state.plan = parsePlanJson(value);
+            state.lastWidgetValue = value;
+            render();
+        } catch (error) {
+            root.replaceChildren();
+            const failure = element("div", "h3c-errors h3c-open", error.message);
+            const raw = element("textarea", "h3c-json");
+            raw.value = value;
+            const retry = button("Apply repaired JSON", "Parse this JSON and open the scene editor", () => {
+                planWidget.value = raw.value;
+                state.lastWidgetValue = "";
+                loadFromWidget(true);
+            });
+            root.append(failure, raw, retry);
+        }
+    }
+
+    const originalCallback = planWidget.callback;
+    planWidget.callback = function (...args) {
+        const result = originalCallback?.apply(this, args);
+        if (!state.syncing) setTimeout(() => loadFromWidget(), 0);
+        return result;
+    };
+
+    for (const name of [
+        "context_length", "audio_context_length", "encode_mode", "anchor_mode", "continuation_mode",
+        "default_duration_seconds", "default_steps", "base_seed",
+        "video_blend_frames",
+    ]) {
+        const widget = node.widgets?.find((item) => item.name === name);
+        if (!widget || widget._h3TimingWrapped) continue;
+        const callback = widget.callback;
+        widget.callback = function (...args) {
+            const result = callback?.apply(this, args);
+            setTimeout(() => updateTiming(), 0);
+            if (name === "base_seed") {
+                setTimeout(() => {
+                    for (const refresh of state.seedRefreshers) void refresh();
+                }, 0);
+            }
+            if (name === "continuation_mode") {
+                setTimeout(() => render(), 0);
+            }
+            return result;
+        };
+        widget._h3TimingWrapped = true;
+    }
+
+    node._h3ChainEditorRefresh = () => {
+        collapseWidget(planWidget);
+        collapseModernBackingWidgets(node);
+        syncProjectAssetManagedWidgets();
+        const layout = planLayout(node);
+        state.advanced = Boolean(layout.advanced);
+        state.jsonOpen = Boolean(layout.jsonOpen);
+        state.settingsOpen = modern && layout.settingsOpen !== false;
+        loadFromWidget(true);
+        scheduleResponsiveSize();
+    };
+    node._h3ChainEditorConnectionRefresh = () => {
+        syncProjectAssetManagedWidgets();
+        scheduleResponsiveSize();
+        render();
+    };
+    node._h3ChainEditorFit = applyResponsiveSize;
+    syncProjectAssetManagedWidgets();
+    loadFromWidget(true);
+    scheduleResponsiveSize();
+    const onLoRARoutesChanged = () => render();
+    document.addEventListener("h3-lora-routes-changed", onLoRARoutesChanged);
+    const removed = node.onRemoved;
+    node.onRemoved = function () {
+        disconnectResizeObservers();
+        document.removeEventListener(
+            "h3-lora-routes-changed", onLoRARoutesChanged);
+        return removed?.apply(this, arguments);
+    };
+}
+
+app.registerExtension({
+    name: EXTENSION,
+    async beforeRegisterNodeDef(nodeType, nodeData) {
+        if (!NODE_NAMES.has(nodeData.name)) return;
+
+        const onNodeCreated = nodeType.prototype.onNodeCreated;
+        nodeType.prototype.onNodeCreated = function () {
+            const result = onNodeCreated?.apply(this, arguments);
+            setTimeout(() => mountEditor(this), 0);
+            return result;
+        };
+
+        const onConfigure = nodeType.prototype.onConfigure;
+        nodeType.prototype.onConfigure = function () {
+            const result = onConfigure?.apply(this, arguments);
+            setTimeout(() => this._h3ChainEditorRefresh?.(), 0);
+            return result;
+        };
+
+        const onGraphConfigured = nodeType.prototype.onGraphConfigured;
+        nodeType.prototype.onGraphConfigured = function () {
+            const result = onGraphConfigured?.apply(this, arguments);
+            setTimeout(() => this._h3ChainEditorRefresh?.(), 0);
+            return result;
+        };
+
+        const onAdded = nodeType.prototype.onAdded;
+        nodeType.prototype.onAdded = function () {
+            const result = onAdded?.apply(this, arguments);
+            // ComfyUI registers DOM widgets again when an existing node is
+            // removed and re-added. Retire the hidden plan_json surface again.
+            setTimeout(() => this._h3ChainEditorRefresh?.(), 0);
+            return result;
+        };
+
+        const onConnectionsChange = nodeType.prototype.onConnectionsChange;
+        nodeType.prototype.onConnectionsChange = function () {
+            const result = onConnectionsChange?.apply(this, arguments);
+            setTimeout(() => this._h3ChainEditorConnectionRefresh?.(), 0);
+            return result;
+        };
+
+        if (nodeData.name === NODE_NAME) {
+            const getExtraMenuOptions = nodeType.prototype.getExtraMenuOptions;
+            nodeType.prototype.getExtraMenuOptions = function (_, options) {
+                const result = getExtraMenuOptions?.apply(this, arguments);
+                options.push({
+                    content: "Upgrade to Modern Plan…",
+                    callback: () => replaceWithModernPlan(this),
+                });
+                return result;
+            };
+        }
+    },
+});
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_plan_studio.js b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_plan_studio.js
new file mode 100644
index 0000000000000000000000000000000000000000..ac817e357a0261e835ef95316b84f2faaaa708b9
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_plan_studio.js
@@ -0,0 +1,6296 @@
+import {app} from "/scripts/app.js";
+import {api} from "/scripts/api.js";
+import {
+    CONTINUATION_MODES,
+    FPS,
+    H3_CONTEXT_LENGTHS,
+    MAX_H3_FRAMES,
+    MAX_SEED,
+    MAX_SHOTS,
+    automaticSceneColor,
+    audioContextLeadFrameOptions,
+    audioContextWindowStarts,
+    calculatePlanTiming,
+    duplicateShot,
+    formatClock,
+    makeChapter,
+    makeShot,
+    moveShot,
+    nativeContextWindowStarts,
+    normalizeChapterResolution,
+    nearestNativeContextWindowStart,
+    parsePlanJson,
+    planToJson,
+    orderedChapters,
+    promptTextToLines,
+    promptValueToText,
+    randomSceneSeed,
+    removePlanShot,
+    safeShotId,
+    sceneAudioContextLeadFrames,
+    sceneAudioContextLeadSource,
+    sceneAudioContextSource,
+    sceneAudioContextStartFrame,
+    sceneAudioContextUnlocked,
+    sceneContextLength,
+    sceneContinuationMode,
+    sceneLoRARoute,
+    scenePromptSeedMode,
+    renamePlanShot,
+    sceneVisualContextBlocks,
+    sceneVisualContextLeadFrames,
+    sceneVideoBlendFrames,
+    setScenePromptSeedMode,
+    setSharedPrompt,
+    setShotLengthMode,
+    sharedPrompt,
+    shotLengthMode,
+    visualContextCompositions,
+    visualContextBoundaryFrames,
+    visualContextDefaultPartition,
+    visualContextMaximumBlocks,
+    visualContextPartitionFromBoundaries,
+} from "./h3_chain_plan_core.mjs?v=0.6.5";
+import {
+    promptRevisionHelp,
+    promptRevisionLabel,
+    promptRevisionNavigation,
+} from "./h3_prompt_history_core.mjs?v=0.6.2";
+import {
+    availableReferenceRecords,
+    convertTaggedPictureReference,
+    taggedPictureReferenceMode,
+    taggedPictureReferenceToken,
+} from "./h3_reference_preview_core.mjs?v=0.6.2";
+import {
+    applySceneAudioOverride,
+    applySceneLipSync,
+    sceneLipSyncMode,
+    applySceneTransitionPreset,
+    primaryTransitionOptions,
+    sceneAudioOverride,
+    sceneAudioPolicy,
+    sceneTransitionPreset,
+    transitionPresetLabel,
+} from "./h3_policy_core.mjs?v=0.6.6";
+import {
+    resolveAudioContextLength,
+    resolveAudioPolicy,
+    resolveTransitionPolicy,
+} from "./h3_socket_presentation_core.mjs?v=0.6.6";
+import {
+    availableLoRARoutes,
+    loraRouteLabel,
+} from "./h3_lora_scheduler_core.mjs?v=0.6.2";
+import {
+    h3StudioGridMarkers,
+    locateStudioTimelineSegment,
+    matchingStudioCheckpoint,
+    matchingStudioSourceAudio,
+    matchingStudioSourceScene,
+    parseStudioTimecode,
+    remapStudioEditorialSceneId,
+    studioCheckpointSignature,
+    restoreStudioCheckpointCache,
+    studioCheckpointCacheSnapshot,
+    studioContextWindowLayout,
+    studioContextWindowStartAtRatio,
+    parseTimedLyrics,
+    studioEditorialSceneStartSeconds,
+    studioLatentSafeOutFrames,
+    studioNearestLatentSafeOutFrame,
+    studioNearestH3FrameLength,
+    studioPlayerSegmentClock,
+    studioSourceAudioSecond,
+    studioSourceSecond,
+    studioTimelineLayout,
+    studioTimelinePixelAtSecond,
+    studioTimelineScrollAnchorSeconds,
+    studioTimelineScrollLeftForAnchor,
+    studioTimelineSegments,
+    studioTimelineTotalSeconds,
+    studioRulerTicks,
+    studioWaveformIntervalSamples,
+    timedLyricAtSecond,
+} from "./h3_chain_plan_studio_core.mjs?v=0.6.4";
+import * as promptCompanionSync from "./h3_prompt_companion_sync.mjs?v=0.6.2";
+
+const {
+    connectedPromptEditors,
+    publishCompanionScene,
+} = promptCompanionSync;
+const planHasNonPromptChanges =
+    typeof promptCompanionSync.planHasNonPromptChanges === "function"
+        ? promptCompanionSync.planHasNonPromptChanges
+        : () => true;
+function publishCompanionPrompt(...args) {
+    return promptCompanionSync.publishCompanionPrompt?.(...args) ?? 0;
+}
+
+const NODE_NAME = "MiniMaxH3ChainPlanStudio";
+const PLAN_NAME = "MiniMaxH3ChainPlan";
+const MODERN_PLAN_NAME = "MiniMaxH3ChainPlanModern";
+const PLAN_NAMES = new Set([PLAN_NAME, MODERN_PLAN_NAME]);
+const ACTIVE_PROPERTY = "h3_plan_studio_active_scene";
+const ACTIVE_CHAPTER_PROPERTY = "h3_plan_studio_active_chapter";
+const VIEW_PROPERTY = "h3_plan_studio_view";
+const TIMELINE_ZOOM_PROPERTY = "h3_plan_studio_timeline_zoom";
+const SOURCE_AUDIO_MUTES_PROPERTY = "h3_plan_studio_source_audio_mutes";
+const GENERATED_VOLUME_PROPERTY = "h3_plan_studio_generated_volume";
+const SOURCE_VOLUME_PROPERTY = "h3_plan_studio_source_volume";
+const MOTION_VOLUME_PROPERTY = "h3_plan_studio_motion_volume";
+const CHECKPOINT_CACHE_PROPERTY = "h3_plan_studio_checkpoint_cache_v1";
+const MIN_WIDTH = 820;
+const MIN_HEIGHT = 690;
+const PLAN_SETTING_WIDGETS = Object.freeze([
+    "plan_json", "run_name", "generation_fingerprint", "width", "height",
+    "context_length", "encode_mode", "anchor_mode", "crop", "audio_mode",
+    "audio_context_length", "default_duration_seconds", "default_steps",
+    "base_seed", "segment_crf", "video_blend_frames", "continuation_mode",
+]);
+
+function monitorVolume(value, fallback = 1) {
+    const number = Number(value);
+    return Number.isFinite(number)
+        ? Math.max(0, Math.min(1, number)) : fallback;
+}
+
+function normalizedTimelineZoom(value) {
+    const number = Number(value);
+    return Number.isFinite(number) ? Math.max(1, Math.min(6, number)) : 1;
+}
+
+function injectStyles() {
+    if (document.getElementById("h3-plan-studio-style")) return;
+    const style = document.createElement("style");
+    style.id = "h3-plan-studio-style";
+    style.textContent = `
+        .h3studio {
+            --hs-bg:color-mix(in srgb,var(--comfy-menu-bg,#202124) 92%,#101827);
+            --hs-panel:color-mix(in srgb,var(--comfy-input-bg,#111827) 84%,#263552);
+            --hs-border:color-mix(in srgb,var(--border-color,#555) 68%,#7891bf);
+            --hs-text:var(--input-text,#eef1f7);
+            /* Follow the foreground palette for contrast in both themes,
+               including changes made while this Studio is already open. */
+            --hs-muted:color-mix(in srgb,var(--hs-text) 82%,var(--hs-panel));
+            --hs-accent:color-mix(in srgb,var(--hs-text) 70%,#3979da);
+            --hs-selected:color-mix(in srgb,var(--hs-accent) 18%,var(--hs-panel));
+            --hs-success:color-mix(in srgb,var(--hs-text) 70%,#219653);
+            --hs-warning:color-mix(in srgb,var(--hs-text) 75%,#c88a26);
+            --hs-danger:color-mix(in srgb,var(--hs-text) 70%,#e53935);
+            --hs-alternate:color-mix(in srgb,var(--hs-text) 75%,#8c54d8);
+            /* Video surfaces stay dark, regardless of the surrounding form. */
+            --hs-media-text:#eef1f7; --hs-media-muted:#dce5f7;
+            box-sizing:border-box; width:100%; height:100%; min-height:540px;
+            display:flex; flex-direction:column; gap:8px; overflow:hidden; padding:10px;
+            border:1px solid var(--hs-border); border-radius:8px; background:var(--hs-bg);
+            color:var(--hs-text); font:12px/1.35 system-ui,sans-serif;
+        }
+        .h3studio *, .h3studio *::before, .h3studio *::after { box-sizing:border-box; }
+        .h3studio button,.h3studio input,.h3studio select,.h3studio textarea {
+            color:var(--hs-text); font:inherit; border:1px solid var(--hs-border);
+            border-radius:5px; background:var(--comfy-input-bg,#15171d);
+        }
+        .h3studio button { padding:5px 8px; cursor:pointer; white-space:nowrap; }
+        .h3studio button:hover,.h3studio button.h3studio-active { border-color:var(--hs-accent); }
+        .h3studio button.h3studio-active { color:var(--hs-text); background:var(--hs-selected); }
+        .h3studio button:disabled { opacity:.4; cursor:not-allowed; }
+        .h3studio input,.h3studio select,.h3studio textarea { width:100%; min-width:0; padding:6px 7px; }
+        .h3studio textarea { resize:vertical; line-height:1.5; }
+        .h3studio-head,.h3studio-toolbar,.h3studio-statusline,.h3studio-scene-head,
+        .h3studio-form,.h3studio-history,.h3studio-json-actions,.h3studio-player-controls {
+            display:flex; align-items:center; gap:6px;
+        }
+        .h3studio-head { justify-content:space-between; }
+        .h3studio-title { color:var(--hs-accent); font-size:15px; font-weight:750; }
+        .h3studio-run { min-width:0; color:var(--hs-muted); overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+        .h3studio-toolbar { flex-wrap:wrap; }
+        .h3studio-spacer { flex:1; }
+        .h3studio-statusline { color:var(--hs-muted); flex-wrap:wrap; min-height:18px; }
+        .h3studio-statusline strong { color:var(--hs-text); }
+        .h3studio-timeline-shell { flex:0 0 auto; padding:7px; border:1px solid var(--hs-border);
+            border-radius:7px; background:var(--hs-panel); }
+        .h3studio-timeline-tools { display:flex; align-items:center; gap:5px; min-height:28px; color:var(--hs-muted); }
+        .h3studio-timeline-tools strong { color:var(--hs-text); }
+        .h3studio-timeline-zoom { width:118px !important; padding:0 !important; }
+        .h3studio-timeline-grid { display:grid; grid-template-columns:78px minmax(0,1fr); gap:5px; min-width:0; }
+        .h3studio-timeline-labels,.h3studio-timeline-content { display:grid;
+            grid-template-rows:30px 76px 76px 34px 30px; row-gap:4px; align-items:stretch; }
+        .h3studio-timeline-labels { color:var(--hs-muted); font-size:9px; font-weight:750;
+            letter-spacing:.06em; text-align:right; }
+        .h3studio-timeline-labels span { display:flex; align-items:center; justify-content:flex-end; }
+        .h3studio-timeline-viewport { min-width:0; overflow-x:auto; overflow-y:hidden; padding-bottom:2px; }
+        .h3studio-timeline-content { min-width:100%; }
+        .h3studio-ruler { position:relative; height:30px; width:100%; border-bottom:1px solid var(--hs-border);
+            color:var(--hs-muted); font-size:10px; overflow:visible; cursor:crosshair; touch-action:none; }
+        .h3studio-ruler-tick { position:absolute; bottom:0; width:1px; height:7px; background:var(--hs-border); pointer-events:none; }
+        .h3studio-ruler-tick.h3studio-major { height:13px; background:color-mix(in srgb,var(--hs-text) 55%,transparent); }
+        .h3studio-ruler-tick span { position:absolute; left:3px; bottom:12px; white-space:nowrap; font-variant-numeric:tabular-nums; }
+        .h3studio-ruler-hover { position:absolute; z-index:12; top:1px; padding:2px 5px; border-radius:4px;
+            color:#fff; background:rgba(7,9,14,.88); pointer-events:none; font-variant-numeric:tabular-nums; transform:translateX(-50%); }
+        .h3studio-timeline { position:relative; display:flex; gap:0; width:100%; min-width:0; min-height:0; overflow:hidden; }
+        .h3studio-generated-timeline { overflow:visible; }
+        .h3studio-chapter-marker { position:absolute; z-index:8; top:-2px; bottom:0; width:0;
+            padding:0 !important; border:0 !important; border-left:2px solid var(--hs-warning) !important;
+            border-radius:0 !important; background:transparent !important; overflow:visible; }
+        .h3studio-chapter-marker span { position:absolute; top:3px; left:4px; max-width:112px;
+            overflow:hidden; text-overflow:ellipsis; white-space:nowrap; padding:2px 6px;
+            border:1px solid var(--hs-warning); border-radius:999px; color:var(--hs-warning);
+            background:var(--hs-bg); font-size:9px; font-weight:750; }
+        .h3studio-chapter-marker.h3studio-selected span { color:var(--hs-text); border-color:var(--hs-warning);
+            box-shadow:0 0 0 1px var(--hs-warning) inset; }
+        .h3studio-card { --scene:#84aaff; position:relative; isolation:isolate;
+            flex:0 0 var(--h3-scene-width,138px); min-width:0;
+            height:70px; overflow:hidden; padding:0 !important; text-align:left; border:1px solid var(--scene) !important;
+            border-radius:5px; color:var(--hs-text); cursor:grab; font:inherit; user-select:none; touch-action:none;
+            background:color-mix(in srgb,var(--scene) 13%,var(--comfy-input-bg,#15171d)) !important; }
+        .h3studio-card.h3studio-moving { cursor:grabbing; }
+        .h3studio-card.h3studio-selected { box-shadow:0 0 0 2px var(--scene) inset; }
+        .h3studio-card.h3studio-alternate-selected::before { content:"ALT"; position:absolute;
+            z-index:4; right:17px; top:4px; padding:1px 4px; border:1px solid #b493f0;
+            border-radius:3px; color:#eadfff; background:rgba(45,25,78,.88); font-size:8px; font-weight:800; }
+        .h3studio-card video, .h3studio-card-thumbnail { position:absolute; inset:0; width:100%; height:100%; object-fit:cover;
+            opacity:.58; z-index:-1; background:#08090c; pointer-events:none; }
+        .h3studio-card::after { content:""; position:absolute; inset:0; z-index:-1;
+            background:linear-gradient(180deg,transparent 10%,rgba(5,7,12,.88)); }
+        .h3studio-card-copy { position:absolute; inset:auto 7px 6px; overflow:hidden; color:var(--hs-media-text); }
+        .h3studio-drag-handle { position:absolute; z-index:3; left:4px; top:4px; padding:1px 4px;
+            border-radius:3px; color:#fff; background:rgba(5,7,12,.72); cursor:grab; user-select:none; }
+        .h3studio-drag-handle:active { cursor:grabbing; }
+        .h3studio-lock-handle { position:absolute; z-index:4; left:29px; top:4px; width:22px; height:19px;
+            padding:0 !important; border:1px solid rgba(255,255,255,.24) !important; border-radius:3px; color:#fff;
+            background:rgba(5,7,12,.72) !important; cursor:pointer; user-select:none; }
+        .h3studio-lock-handle.h3studio-is-locked { color:#ffd995;
+            border-color:#c59745 !important; }
+        .h3studio-lock-icon { position:relative; display:block; width:12px; height:13px; margin:auto; }
+        .h3studio-lock-icon::after { content:""; position:absolute; left:2px; bottom:1px; width:8px; height:7px;
+            box-sizing:border-box; border:1.5px solid currentColor; border-radius:2px; }
+        .h3studio-lock-icon::before { content:""; position:absolute; left:3.5px; top:0; width:5px; height:7px;
+            box-sizing:border-box; border:1.5px solid currentColor; border-bottom:0; border-radius:5px 5px 0 0; }
+        .h3studio-lock-handle:not(.h3studio-is-locked) .h3studio-lock-icon::before {
+            left:7px; transform:rotate(24deg); transform-origin:left bottom; }
+        .h3studio-resize-handle { position:absolute; z-index:5; top:0; right:0; width:8px; height:100%;
+            border-right:2px solid color-mix(in srgb,var(--scene) 78%,#fff); cursor:ew-resize;
+            touch-action:none; opacity:.72; }
+        .h3studio-resize-handle:hover, .h3studio-resize-handle:active { width:12px; opacity:1;
+            background:linear-gradient(90deg,transparent,color-mix(in srgb,var(--scene) 28%,transparent)); }
+        .h3studio-resize-handle.h3studio-latent-trim { border-right-color:#62e1d1;
+            background:linear-gradient(90deg,transparent,rgba(98,225,209,.16)); }
+        .h3studio-resize-handle.h3studio-latent-trim::before { content:""; position:absolute;
+            right:1px; top:50%; width:0; height:0; transform:translateY(-50%);
+            border-top:5px solid transparent; border-bottom:5px solid transparent;
+            border-right:5px solid #62e1d1; }
+        .h3studio-card.h3studio-locked { border-style:dashed !important; cursor:pointer; }
+        .h3studio-card.h3studio-locked .h3studio-drag-handle,
+        .h3studio-card.h3studio-locked .h3studio-resize-handle { cursor:not-allowed; opacity:.38; }
+        .h3studio-card-title { display:block; font-weight:750; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+        .h3studio-card-meta { display:block; color:var(--hs-media-muted); font-size:10px; }
+        .h3studio-render-dot { position:absolute; right:6px; top:6px; width:8px; height:8px; border-radius:50%;
+            background:#687080; box-shadow:0 0 0 1px #111; }
+        .h3studio-rendered .h3studio-render-dot { background:#62d58b; }
+        .h3studio-continuation-stale .h3studio-render-dot { background:#f1a44c; }
+        .h3studio-source-card { border-style:dashed !important; }
+        .h3studio-source-card .h3studio-render-dot { background:#b58cff; }
+        .h3studio-source-empty { display:flex; align-items:center; padding:0 10px; color:var(--hs-muted);
+            min-height:48px; border:1px dashed var(--hs-border); border-radius:5px; }
+        .h3studio-audio-timeline { min-height:34px; }
+        .h3studio-audio-card { --scene:#84aaff; position:relative;
+            flex:0 0 var(--h3-scene-width,138px); min-width:0;
+            height:34px; overflow:hidden; border:1px solid color-mix(in srgb,var(--scene) 65%,var(--hs-border));
+            border-radius:5px; background:color-mix(in srgb,var(--scene) 8%,var(--comfy-input-bg,#15171d)); cursor:pointer; }
+        .h3studio-audio-card.h3studio-selected { box-shadow:0 0 0 1px var(--scene) inset; }
+        .h3studio-audio-card.h3studio-audio-muted { opacity:.48; }
+        .h3studio-waveform { position:absolute; inset:3px 34px 3px 4px; width:calc(100% - 38px); height:28px; }
+        .h3studio-audio-mute { position:absolute; z-index:2; right:3px; top:3px; width:28px; height:26px;
+            padding:0 !important; display:grid; place-items:center; font-size:13px; }
+        .h3studio-playhead { position:absolute; z-index:20; top:0; width:1px; height:262px;
+            background:#ff626a; box-shadow:0 0 0 1px rgba(82,12,17,.28); pointer-events:none; }
+        .h3studio-gap { flex:0 0 var(--h3-scene-width,0); min-width:0; height:100%; overflow:hidden;
+            color:#b7bdc8; background:#030405; border:1px dashed #697080; cursor:pointer; }
+        .h3studio-gap-copy { display:flex; height:100%; align-items:center; justify-content:center;
+            padding:4px; text-align:center; font-size:10px; white-space:nowrap; overflow:hidden; }
+        .h3studio-gap-spacer { flex:0 0 var(--h3-scene-width,0); min-width:0; height:100%;
+            background:repeating-linear-gradient(135deg,rgba(160,170,188,.07) 0 4px,transparent 4px 8px); }
+        .h3studio-subtitle-timeline { position:relative; min-height:30px; }
+        .h3studio-subtitle-cue { position:absolute; top:2px; bottom:2px; overflow:hidden; padding:4px 6px;
+            border:1px solid var(--hs-alternate); border-radius:4px; color:var(--hs-alternate);
+            background:color-mix(in srgb,var(--hs-alternate) 10%,var(--hs-panel));
+            font-size:9px; text-overflow:ellipsis; white-space:nowrap; }
+        .h3studio-panel { flex:1 1 auto; min-height:0; overflow:auto; padding:9px;
+            border:1px solid var(--hs-border); border-radius:7px; background:var(--hs-panel); }
+        .h3studio-scene-head { margin-bottom:7px; }
+        .h3studio-grid-markers { display:flex; align-items:center; gap:5px; flex-wrap:wrap; margin-left:auto; }
+        .h3studio-grid-marker { padding:2px 6px; border:1px solid var(--hs-border); border-radius:999px;
+            color:var(--hs-muted); background:color-mix(in srgb,var(--hs-panel) 82%,transparent); font-size:9px; }
+        .h3studio-grid-marker.h3studio-grid-exact { color:var(--hs-success); border-color:var(--hs-success); }
+        .h3studio-grid-marker.h3studio-grid-warning { color:var(--hs-warning); border-color:var(--hs-warning); }
+        .h3studio-grid-marker.h3studio-grid-experimental { border-style:dashed; }
+        .h3studio-scene-label { color:var(--hs-muted); }
+        /* Reflow against the node's width, not the browser viewport. Each cell
+           must also fit the multi-part seed and editorial controls. */
+        .h3studio-form { align-items:end; display:grid; gap:8px;
+            grid-template-columns:repeat(auto-fit,minmax(min(100%,300px),1fr)); margin-bottom:8px; }
+        .h3studio-audio-overrides { display:grid; grid-template-columns:repeat(3,minmax(160px,1fr));
+            gap:7px; margin:0 0 8px; align-items:end; }
+        .h3studio-field { display:flex; min-width:0; flex-direction:column; gap:3px; color:var(--hs-muted); }
+        .h3studio-alternate { margin:0 0 9px; padding:9px; border:1px solid var(--hs-alternate);
+            border-radius:7px; background:color-mix(in srgb,var(--hs-panel) 94%,var(--hs-alternate)); }
+        .h3studio-alternate-title { display:flex; align-items:center; gap:7px; margin-bottom:4px; }
+        .h3studio-alternate-enable { display:flex; align-items:center; gap:5px; margin:8px 0;
+            color:var(--hs-text); }
+        .h3studio-alternate-enable input { width:auto; }
+        .h3studio-alternate-grid { display:grid; grid-template-columns:minmax(260px,1fr) 180px;
+            gap:8px; margin-top:7px; align-items:end; }
+        .h3studio-alternate-prompt { min-height:105px; }
+        .h3studio-alternate-diff { margin:6px 0; color:var(--hs-alternate); font:11px/1.4 ui-monospace,SFMono-Regular,Consolas,monospace;
+            white-space:pre-wrap; overflow-wrap:anywhere; }
+        .h3studio-plan-settings { display:grid; grid-template-columns:repeat(3,minmax(170px,1fr));
+            gap:9px; align-items:end; }
+        .h3studio-plan-settings-section { grid-column:1 / -1; margin-top:5px; padding-top:7px;
+            border-top:1px solid var(--hs-border); color:var(--hs-accent); font-weight:750; }
+        .h3studio-plan-defaults-help { grid-column:1 / -1; color:var(--hs-muted); font-size:10px; }
+        .h3studio-length { display:grid; min-width:0; grid-template-columns:minmax(0,1fr) auto; gap:5px; }
+        .h3studio-duration { grid-template-columns:minmax(0,1fr) minmax(0,1fr); }
+        .h3studio-prompt-seed { display:grid; min-width:0;
+            grid-template-columns:minmax(0,160px) minmax(0,1fr) auto; gap:5px; }
+        .h3studio-context-pair { display:grid; grid-template-columns:1fr 1fr; gap:5px; }
+        .h3studio-prompt { min-height:250px; width:100%; font:15px/1.55 ui-monospace,SFMono-Regular,Consolas,monospace !important; }
+        .h3studio-prompt-tools { display:flex; align-items:center; gap:6px; margin:7px 0; flex-wrap:wrap; }
+        .h3studio-prompt-delegated { margin-top:10px; padding:12px; border:1px dashed var(--hs-border);
+            border-radius:7px; color:var(--hs-muted); background:var(--hs-bg); }
+        .h3studio-prompt-delegated strong { display:block; margin-bottom:4px; color:var(--hs-text); }
+        .h3studio-hint,.h3studio-message { color:var(--hs-muted); }
+        .h3studio-history { justify-content:center; min-height:26px; }
+        .h3studio-history-count { min-width:44px; text-align:center; font-variant-numeric:tabular-nums; }
+        .h3studio-history-meta { max-width:300px; color:var(--hs-muted); overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+        .h3studio-error { color:var(--hs-danger); white-space:pre-wrap; }
+        .h3studio-shared { min-height:260px; font:15px/1.55 ui-monospace,SFMono-Regular,Consolas,monospace !important; }
+        .h3studio-defaults { display:grid; grid-template-columns:1fr 1fr; gap:8px; margin-top:8px; max-width:390px; }
+        .h3studio-chapter-settings { display:flex; flex-wrap:wrap; align-items:flex-end; gap:8px; margin-top:8px; }
+        .h3studio-chapter-settings > .h3studio-field { flex:1 1 180px; min-width:0; }
+        .h3studio-chapter-resolution { display:flex; flex:2 1 344px; flex-wrap:wrap; align-items:flex-end; gap:8px; min-width:0; }
+        .h3studio-chapter-resolution > .h3studio-field { flex:1 1 72px; min-width:0; }
+        .h3studio-chapter-resolution > .h3studio-field:first-child { flex:2 1 160px; }
+        .h3studio-json { min-height:360px; font:13px/1.45 ui-monospace,SFMono-Regular,Consolas,monospace !important; }
+        .h3studio-json-actions { margin-top:7px; }
+        .h3studio-player { display:flex; flex-direction:column; gap:7px; height:100%; min-height:330px; }
+        .h3studio-compare-stage { position:relative; flex:1 1 auto; min-height:260px; overflow:hidden;
+            background:#050608; border-radius:6px; }
+        .h3studio-compare-stage video { position:absolute; inset:0; width:100%; height:100%; background:#050608; object-fit:contain; }
+        .h3studio-handoff-frame { position:absolute; inset:0; width:100%; height:100%; opacity:1;
+            pointer-events:none; transition:opacity .16s ease-out; }
+        .h3studio-handoff-frame.h3studio-handoff-release { opacity:0; }
+        .h3studio-source-layer { position:absolute; inset:0; overflow:hidden; pointer-events:none; }
+        .h3studio-source-layer video { width:100%; height:100%; }
+        .h3studio-wipe-line { position:absolute; top:0; bottom:0; width:2px; background:#d2b8ff;
+            box-shadow:0 0 0 1px rgba(0,0,0,.45); pointer-events:none; }
+        .h3studio-compare-label { position:absolute; top:7px; z-index:2; padding:3px 6px; border-radius:4px;
+            background:rgba(5,7,12,.7); color:#fff; font-size:10px; pointer-events:none; }
+        .h3studio-compare-label-generated { right:7px; }
+        .h3studio-compare-label-source { left:7px; }
+        .h3studio-subtitle-overlay { position:absolute; z-index:5; left:7%; right:7%; bottom:7%;
+            padding:6px 10px; color:#fff; background:rgba(0,0,0,.72); border-radius:5px;
+            text-align:center; font-size:clamp(15px,2.1vw,25px); font-weight:700; line-height:1.3;
+            text-shadow:0 1px 2px #000; white-space:pre-wrap; pointer-events:none; }
+        .h3studio-subtitle-settings { display:grid; grid-template-columns:minmax(220px,1fr) 160px 160px;
+            gap:9px; align-items:end; }
+        .h3studio-subtitle-list { display:flex; flex-direction:column; gap:4px; margin-top:10px; }
+        .h3studio-subtitle-row { display:grid; grid-template-columns:150px minmax(0,1fr); gap:8px;
+            padding:5px 7px; border-bottom:1px solid var(--hs-border); }
+        .h3studio-player-controls input[type=range] { flex:1; padding:0; }
+        .h3studio-context-selector { display:flex; flex-direction:column; gap:9px; }
+        .h3studio-context-tabs { display:flex; align-items:center; gap:6px; flex-wrap:wrap; }
+        .h3studio-context-tabs button.h3studio-context-tab-active { border-color:var(--hs-accent);
+            color:var(--hs-text); background:var(--hs-selected); }
+        .h3studio-context-tabs .h3studio-context-lock { margin-left:auto; }
+        .h3studio-context-audio-settings { display:grid;
+            grid-template-columns:repeat(3,minmax(170px,1fr)); gap:7px; align-items:end; }
+        .h3studio-context-builder-settings { display:grid;
+            grid-template-columns:repeat(auto-fit,minmax(180px,1fr)); gap:7px; align-items:end;
+            padding:8px; border:1px solid var(--hs-border); border-radius:7px; }
+        .h3studio-context-cuts { display:flex; flex-wrap:wrap; gap:6px; align-items:end; }
+        .h3studio-context-cuts label { min-width:130px; flex:1 1 130px; }
+        .h3studio-context-audio { width:100%; margin:4px 0 7px; }
+        .h3studio-context-help { color:var(--hs-muted); }
+        .h3studio-context-blocks { display:grid; grid-template-columns:repeat(auto-fit,minmax(300px,1fr)); gap:9px; }
+        .h3studio-context-block { min-width:0; padding:8px; border:1px solid var(--hs-border);
+            border-radius:7px; background:var(--hs-bg); }
+        .h3studio-context-block-head { display:flex; align-items:baseline; justify-content:space-between;
+            gap:8px; margin-bottom:7px; }
+        .h3studio-context-block-head span { color:var(--hs-muted); overflow:hidden;
+            text-overflow:ellipsis; white-space:nowrap; }
+        .h3studio-context-video { display:block; width:100%; min-height:180px; max-height:330px;
+            object-fit:contain; background:#050608; border-radius:6px; }
+        .h3studio-context-empty { display:grid; place-items:center; width:100%; min-height:180px;
+            padding:18px; color:var(--hs-media-muted); text-align:center; border:1px dashed var(--hs-border);
+            border-radius:6px; background:#050608; }
+        .h3studio-context-range { display:flex; flex-direction:column; gap:5px; margin-top:7px; }
+        .h3studio-context-movie-track { position:relative; width:100%; height:38px; overflow:hidden;
+            border:1px solid var(--hs-border); border-radius:6px; cursor:pointer; touch-action:none;
+            background:repeating-linear-gradient(90deg,#151922 0,#151922 11px,#0e1118 11px,#0e1118 13px); }
+        .h3studio-context-movie-track:focus-visible { outline:2px solid #79a7ff; outline-offset:2px; }
+        .h3studio-context-window { position:absolute; top:3px; bottom:3px; min-width:1px;
+            box-sizing:border-box; border:2px solid #7ec8ff; border-radius:5px;
+            background:rgba(47,143,220,.42); box-shadow:0 0 0 1px rgba(0,0,0,.55) inset;
+            display:grid; place-items:center; overflow:hidden; color:#fff; font-size:10px;
+            font-variant-numeric:tabular-nums; cursor:grab; user-select:none; }
+        .h3studio-context-movie-track.h3studio-dragging .h3studio-context-window { cursor:grabbing; }
+        .h3studio-context-window::before,.h3studio-context-window::after { content:"";
+            position:absolute; top:6px; bottom:6px; width:2px; background:rgba(255,255,255,.78); }
+        .h3studio-context-window::before { left:4px; }
+        .h3studio-context-window::after { right:4px; }
+        .h3studio-context-phase-tail { position:absolute; z-index:0; top:0; bottom:0;
+            pointer-events:none; border-left:1px dashed #d39a50;
+            background:repeating-linear-gradient(135deg,rgba(211,154,80,.24) 0,
+                rgba(211,154,80,.24) 4px,rgba(211,154,80,.06) 4px,
+                rgba(211,154,80,.06) 8px); }
+        .h3studio-context-phase-note { margin-top:4px; color:var(--hs-warning); font-size:10px; }
+        .h3studio-context-playhead { position:absolute; z-index:2; top:0; bottom:0; width:2px;
+            pointer-events:none; background:#ff9a3c; transform:translateX(-1px); }
+        .h3studio-context-range-readout { display:flex; justify-content:space-between; gap:8px; }
+        .h3studio-context-movie-length { color:var(--hs-muted); font-variant-numeric:tabular-nums; }
+        .h3studio-context-range-label { min-width:150px; color:var(--hs-muted);
+            font-variant-numeric:tabular-nums; text-align:right; }
+        .h3studio-context-actions { display:flex; align-items:center; gap:6px; margin-top:7px;
+            flex-wrap:wrap; }
+        .h3studio-compare-controls { display:grid; grid-template-columns:auto minmax(100px,1fr) auto; gap:6px; align-items:center; }
+        .h3studio-compare-controls.h3studio-no-motion { grid-template-columns:1fr; }
+        .h3studio-audio-mix { display:flex; align-items:center; justify-content:flex-end; gap:8px; flex-wrap:wrap; }
+        .h3studio-audio-control { display:flex; align-items:center; gap:4px; }
+        .h3studio-audio-toggle { display:flex; align-items:center; gap:4px; color:var(--hs-muted); white-space:nowrap; }
+        .h3studio-audio-toggle input { width:auto; margin:0; padding:0; }
+        .h3studio-audio-volume { width:68px !important; min-width:48px !important; padding:0 !important; }
+        .h3studio-audio-level { width:31px; color:var(--hs-muted); font-size:9px; text-align:right; }
+        .h3studio-refs { display:none; gap:5px; padding:7px; border:1px solid var(--hs-border);
+            border-radius:6px; background:var(--hs-bg); flex-wrap:wrap; }
+        .h3studio-refs.h3studio-open { display:flex; }
+        .h3studio-ref-entry { display:flex; align-items:stretch; gap:2px; }
+        .h3studio-ref-mode { display:flex; gap:1px; }
+        .h3studio-ref-mode button { min-width:28px; padding:2px 5px; font-size:10px; }
+        .h3studio-ref-mode button.h3studio-selected { border-color:var(--hs-accent);
+            color:var(--hs-accent); }
+        .h3studio-ref-preview { flex:1 0 100%; display:grid; grid-template-columns:minmax(120px,220px) 1fr;
+            gap:8px; align-items:start; color:var(--hs-muted); }
+        .h3studio-ref-preview img,.h3studio-ref-preview video { width:100%; max-height:150px; object-fit:contain; background:#08090c; }
+        .h3studio-ref-preview audio { width:100%; height:36px; }
+        @media(max-width:760px) { .h3studio-plan-settings,.h3studio-alternate-grid,
+            .h3studio-audio-overrides { grid-template-columns:1fr 1fr; }
+            .h3studio-defaults,.h3studio-context-blocks { grid-template-columns:1fr; } }
+    `;
+    document.head.appendChild(style);
+}
+
+function element(tag, className = "", text) {
+    const item = document.createElement(tag);
+    if (className) item.className = className;
+    if (text !== undefined) item.textContent = text;
+    return item;
+}
+
+function button(label, title, action) {
+    const item = element("button", "", label);
+    item.type = "button";
+    item.title = title || "";
+    item.addEventListener("click", action);
+    return item;
+}
+
+function nodeType(node) {
+    return node?.comfyClass ?? node?.type ?? null;
+}
+
+function allNodes(graph, output = []) {
+    for (const node of graph?._nodes ?? []) {
+        output.push(node);
+        if (node.subgraph) allNodes(node.subgraph, output);
+    }
+    return output;
+}
+
+function upstreamPlanNode(start) {
+    const queue = [start];
+    const seen = new Set();
+    while (queue.length) {
+        const node = queue.shift();
+        if (!node || seen.has(node)) continue;
+        seen.add(node);
+        if (node !== start && PLAN_NAMES.has(nodeType(node))) return node;
+        for (const input of node.inputs ?? []) {
+            if (input.link == null) continue;
+            const link = node.graph?.links?.[input.link];
+            const parent = link ? node.graph?.getNodeById?.(link.origin_id) : null;
+            if (parent) queue.push(parent);
+        }
+    }
+    return null;
+}
+
+function widget(node, name) {
+    return node?.widgets?.find((item) => item.name === name);
+}
+
+function inputSource(node, name) {
+    const input = node?.inputs?.find((item) => item.name === name);
+    const link = input?.link == null ? null : node.graph?.links?.[input.link];
+    return link ? node.graph?.getNodeById?.(link.origin_id) ?? null : null;
+}
+
+function inputConnected(node, name) {
+    const input = node?.inputs?.find((item) => item.name === name);
+    return input?.link !== null && input?.link !== undefined;
+}
+
+function mediaExtension(kind) {
+    if (kind === "image") return /\.(?:avif|bmp|gif|jpe?g|png|webp)$/i;
+    if (kind === "video") return /\.(?:m4v|mkv|mov|mp4|webm)$/i;
+    return /\.(?:aac|flac|m4a|mp3|ogg|opus|wav)$/i;
+}
+
+function widgetAsset(value, kind) {
+    if (value && typeof value === "object" && value.filename) {
+        return {filename:String(value.filename), subfolder:String(value.subfolder ?? ""), type:String(value.type ?? "input")};
+    }
+    let text = typeof value === "string" ? value.trim() : "";
+    if (!text) return null;
+    if (/^(?:blob:|data:|https?:|\/api\/view\?|\/view\?)/i.test(text)) return {url:text};
+    let type = "input";
+    const annotated = text.match(/\s+\[(input|output|temp)\]\s*$/i);
+    if (annotated) { type = annotated[1].toLowerCase(); text = text.slice(0, annotated.index).trim(); }
+    text = text.replaceAll("\\", "/").replace(/^\/+/, "");
+    if (!mediaExtension(kind).test(text)) return null;
+    const slash = text.lastIndexOf("/");
+    return {filename:slash >= 0 ? text.slice(slash + 1) : text,
+        subfolder:slash >= 0 ? text.slice(0, slash) : "", type};
+}
+
+function assetUrl(asset) {
+    if (!asset) return null;
+    if (asset.url) return asset.url;
+    const query = new URLSearchParams({filename:asset.filename, subfolder:asset.subfolder ?? "", type:asset.type ?? "input"});
+    return api.apiURL(`/view?${query.toString()}`);
+}
+
+function findMediaPreview(start, kind) {
+    const queue = [start];
+    const seen = new Set();
+    while (queue.length) {
+        const current = queue.shift();
+        if (!current || seen.has(current)) continue;
+        seen.add(current);
+        if (kind === "image") {
+            const rendered = current.imgs?.[0];
+            const src = typeof rendered === "string" ? rendered : rendered?.src;
+            if (src) return src;
+        }
+        for (const item of current.widgets ?? []) {
+            const value = widgetAsset(item.value, kind);
+            if (value) return assetUrl(value);
+        }
+        for (const input of current.inputs ?? []) {
+            const parent = inputSource(current, input.name);
+            if (parent) queue.push(parent);
+        }
+    }
+    return null;
+}
+
+function videoUrl(item) {
+    if (!item) return "";
+    const query = new URLSearchParams({
+        filename:item.filename, subfolder:item.subfolder ?? "", type:item.type ?? "output",
+    });
+    return api.apiURL(`/view?${query.toString()}`);
+}
+
+function insertText(textarea, text, selectionOffset = text.length) {
+    const start = textarea.selectionStart ?? textarea.value.length;
+    const end = textarea.selectionEnd ?? start;
+    textarea.setRangeText(text, start, end, "end");
+    const caret = start + selectionOffset;
+    textarea.setSelectionRange(caret, caret);
+    textarea.dispatchEvent(new Event("input", {bubbles:true}));
+    textarea.focus();
+}
+
+function insertDialogue(textarea) {
+    const start = textarea.selectionStart ?? textarea.value.length;
+    const end = textarea.selectionEnd ?? start;
+    const selected = textarea.value.slice(start, end);
+    const markup = `<d>${selected}</d>`;
+    insertText(textarea, markup, selected ? markup.length : 3);
+}
+
+function mount(node) {
+    if (node._h3PlanStudioMounted || typeof node.addDOMWidget !== "function") return;
+    node._h3PlanStudioMounted = true;
+    injectStyles();
+    node.properties ??= {};
+    const alternateTakeWidget = widget(node, "alternate_take_json");
+    if (alternateTakeWidget) {
+        alternateTakeWidget.hidden = true;
+        alternateTakeWidget.type = "hidden";
+        alternateTakeWidget.computeSize = () => [0, -4];
+        alternateTakeWidget.draw = () => {};
+    }
+
+    const root = element("div", "h3studio");
+    root.title = "Timeline Plan editor: use it standalone or synchronize it with a connected H3 Chain Plan.";
+    for (const name of ["pointerdown","pointerup","mousedown","mouseup","click","dblclick"]) {
+        root.addEventListener(name, (event) => event.stopPropagation());
+    }
+    root.addEventListener("wheel", (event) => event.stopPropagation());
+
+    const state = {
+        plan:null, planNode:null, planOwner:null, planWidget:null,
+        lastValue:"", lastRunName:"",
+        lastSettingsSignature:"",
+        active:Math.max(0, Number(node.properties[ACTIVE_PROPERTY]) || 0),
+        activeChapterId:String(node.properties[ACTIVE_CHAPTER_PROPERTY] ?? ""),
+        view:["scene","shared","settings","context","player","subtitles","json"].includes(node.properties[VIEW_PROPERTY])
+            ? node.properties[VIEW_PROPERTY] : "scene",
+        timelineZoom:normalizedTimelineZoom(
+            node.properties[TIMELINE_ZOOM_PROPERTY]),
+        checkpoints:new Map(), checkpointSignature:"", checkpointError:"", checkpointToken:0,
+        checkpointPromise:null, checkpointRefreshQueued:false, disposed:false,
+        sourcePreview:null, sourceWaveform:null, sourceWaveformToken:"",
+        presentationToken:0,
+        sourceWaveformPromise:null,
+        pollTimer:null, checkpointTimer:null, timelineHost:null, sourceTimelineHost:null,
+        sourceAudioTimelineHost:null, sourceTrack:null, sourceAudioTrack:null,
+        timelineViewport:null, timelineContent:null, timelineRuler:null,
+        timelineZoomInput:null, timelineZoomLabel:null,
+        timelineResizeObserver:null, timelineWidths:[], timelineSegments:[],
+        timelinePixelsPerSecond:0,
+        timelineRenderedActive:null,
+        timelineWorkspaceEndFrame:0, timelineSceneEndFrame:0,
+        timelineExtending:false, timelineDragging:false,
+        timelineScrollIntentUntil:0, timelineLastScrollLeft:0,
+        timelineLayoutFrame:null,
+        subtitleTimelineHost:null,
+        panelHost:null,
+        planNotifyTimer:null, editorialTimer:null, editorialPending:null,
+        editorialSavePromise:null, lastEditorialSignature:"",
+        editorialReady:false, editorialRun:"", editorialBindingError:"",
+        editorialStored:null, editorialBaseline:null, editorialEditEpoch:0,
+        editorial:{revision:"", placements:[], trims:[], locked_scene_ids:[], subtitles:{},
+            alternate_draft:null, replacements:[]},
+        subtitleAssets:[], subtitleAssetsRun:"", subtitleAssetsToken:0,
+        playhead:null, player:null, playerAudio:null, sourceAudioPlayer:null,
+        sourcePlayer:null, sourceLayer:null, subtitleOverlay:null,
+        editorialClockFrame:null, mediaClockFrame:null, mediaClockKind:"",
+        playerSegmentKey:"",
+        contextPlayers:[],
+        contextTab:"picture",
+        playerSlider:null, playerIndex:-1,
+        playerPreloadVideo:null, playerPreloadAudio:null,
+        primePlayerNext:null, playPlayerTransport:null,
+        togglePlayerPlayback:null, keyboardHover:false,
+        generatedVolume:monitorVolume(
+            node.properties[GENERATED_VOLUME_PROPERTY]),
+        sourceVolume:monitorVolume(node.properties[SOURCE_VOLUME_PROPERTY]),
+        motionVolume:monitorVolume(node.properties[MOTION_VOLUME_PROPERTY]),
+        timelinePosition:null, pendingSeek:0,
+        history:{sceneKey:"", data:null, revisionId:null, host:null, textarea:null,
+            status:null, loadToken:0, loadPromise:null, saveTimer:null,
+            pendingDraft:null, savePromise:null, error:""},
+        promptEditors:[], lastPromptEditorsSignature:"",
+        referenceSyntax:new Map(),
+    };
+    node._h3PlanStudioState = state;
+
+    root.tabIndex = 0;
+    root.addEventListener("pointerenter", () => { state.keyboardHover = true; });
+    root.addEventListener("pointerleave", () => { state.keyboardHover = false; });
+    const pausePlayerMonitors = () => {
+        for (const media of [
+            state.playerAudio, state.sourceAudioPlayer, state.sourcePlayer,
+            ...state.contextPlayers,
+        ]) {
+            try { media?.pause(); } catch (_error) {}
+        }
+    };
+    const onPlayerKeydown = (event) => {
+        if (event.code !== "Space" || event.repeat || state.view !== "player"
+                || !state.togglePlayerPlayback) return;
+        const target = event.target;
+        if (target instanceof Element && target.closest(
+            "input,textarea,select,button,[contenteditable=true]")) return;
+        if (!state.keyboardHover && !root.contains(document.activeElement)) return;
+        event.preventDefault(); event.stopPropagation();
+        state.togglePlayerPlayback();
+    };
+    document.addEventListener("keydown", onPlayerKeydown, true);
+
+    function dirty() {
+        node.graph?.setDirtyCanvas?.(true, true);
+        app.graph?.setDirtyCanvas?.(true, true);
+    }
+
+    function persistView() {
+        node.properties[ACTIVE_PROPERTY] = state.active;
+        node.properties[ACTIVE_CHAPTER_PROPERTY] = state.activeChapterId;
+        node.properties[VIEW_PROPERTY] = state.view;
+        node.properties[TIMELINE_ZOOM_PROPERTY] = state.timelineZoom;
+        dirty();
+    }
+
+    function runName() {
+        return String(widget(state.planOwner ?? node, "run_name")?.value ?? "").trim();
+    }
+
+    function settings() {
+        const owner = state.planOwner ?? node;
+        const transition = resolveTransitionPolicy(owner);
+        const audioPolicy = resolveAudioPolicy(owner);
+        return {
+            contextLength:transition.known
+                ? transition.contextLength
+                : widget(owner, "context_length")?.value ?? 22,
+            audioContextLength:resolveAudioContextLength(owner),
+            videoBlendFrames:widget(owner, "video_blend_frames")?.value ?? 0,
+            encodeMode:widget(owner, "encode_mode")?.value ?? "video",
+            anchorMode:widget(owner, "anchor_mode")?.value ?? "head",
+            continuationMode:transition.known
+                ? transition.continuationMode
+                : widget(owner, "continuation_mode")?.value ?? "guide",
+            generatedContinuity:audioPolicy.known
+                ? audioPolicy.generatedContinuity : "on",
+            sourceAudioTarget:audioPolicy.known
+                ? audioPolicy.sourceAudioTarget ?? "off" : "off",
+            transitionPreset:transition.known ? transition.preset : "custom",
+            audioPolicy,
+            defaultDurationSeconds:widget(owner, "default_duration_seconds")?.value ?? 15,
+            defaultSteps:widget(owner, "default_steps")?.value ?? 20,
+        };
+    }
+
+    function settingsSignature(planOwner = state.planOwner ?? node) {
+        const transition = resolveTransitionPolicy(planOwner);
+        const audioPolicy = resolveAudioPolicy(planOwner);
+        return JSON.stringify([
+            transition.known
+                ? transition.contextLength
+                : widget(planOwner, "context_length")?.value ?? 22,
+            resolveAudioContextLength(planOwner),
+            widget(planOwner, "video_blend_frames")?.value ?? 0,
+            widget(planOwner, "encode_mode")?.value ?? "video",
+            widget(planOwner, "anchor_mode")?.value ?? "head",
+            transition.known
+                ? transition.continuationMode
+                : widget(planOwner, "continuation_mode")?.value ?? "guide",
+            audioPolicy.sourceReference,
+            audioPolicy.generatedContinuity,
+            audioPolicy.sourceAudioTarget ?? "off",
+            inputConnected(planOwner, "project_assets"),
+            ...PLAN_SETTING_WIDGETS.slice(1).map(
+                (name) => widget(planOwner, name)?.value ?? null),
+        ]);
+    }
+
+    function mirrorConnectedPlan(planNode) {
+        if (!planNode) return false;
+        let changed = false;
+        for (const name of PLAN_SETTING_WIDGETS) {
+            const source = widget(planNode, name);
+            const target = widget(node, name);
+            if (!source || !target || Object.is(source.value, target.value)) continue;
+            target.value = source.value;
+            changed = true;
+        }
+        if (changed) dirty();
+        return changed;
+    }
+
+    function writePlanSetting(name, value, rerender = true) {
+        const targets = state.planNode ? [state.planNode, node] : [node];
+        for (const target of targets) {
+            const targetWidget = widget(target, name);
+            if (!targetWidget || Object.is(targetWidget.value, value)) continue;
+            targetWidget.value = value;
+            targetWidget.callback?.(targetWidget.value);
+        }
+        state.lastRunName = runName();
+        state.lastSettingsSignature = settingsSignature(state.planOwner ?? node);
+        dirty();
+        if (rerender) renderShell();
+    }
+
+    function timing() {
+        return calculatePlanTiming(state.plan, settings());
+    }
+
+    function normalizedEditorial(value = {}) {
+        const knownIds = new Set((state.plan?.shots ?? []).map((shot, index) => (
+            safeShotId(shot?.id, `clip_${String(index + 1).padStart(4, "0")}`)
+        )));
+        const placements = [];
+        const seen = new Set();
+        for (const item of Array.isArray(value?.placements) ? value.placements : []) {
+            const sceneId = String(item?.scene_id ?? "").trim();
+            const startFrame = Math.max(0, Math.min(
+                864000, Math.round(Number(item?.start_frame) || 0),
+            ));
+            if (!sceneId || !knownIds.has(sceneId) || seen.has(sceneId)) continue;
+            seen.add(sceneId);
+            placements.push({
+                scene_id:sceneId,
+                start_frame:startFrame,
+            });
+        }
+        const trims = [];
+        const trimmed = new Set();
+        for (const item of Array.isArray(value?.trims) ? value.trims : []) {
+            const sceneId = String(item?.scene_id ?? "").trim();
+            const outFrame = Math.round(Number(item?.out_frame));
+            if (!sceneId || !knownIds.has(sceneId) || trimmed.has(sceneId)
+                    || !Number.isInteger(outFrame) || outFrame < 1
+                    || outFrame > MAX_H3_FRAMES) continue;
+            trimmed.add(sceneId);
+            trims.push({scene_id:sceneId, out_frame:outFrame});
+        }
+        const rawSubtitles = value?.subtitles && typeof value.subtitles === "object"
+            ? value.subtitles : {};
+        const mode = ["off", "preview_srt"].includes(rawSubtitles.mode)
+            ? rawSubtitles.mode : "off";
+        const offset = Number(rawSubtitles.offset_seconds);
+        const lockedSceneIds = [...new Set(
+            (Array.isArray(value?.locked_scene_ids)
+                ? value.locked_scene_ids : [])
+                .map((sceneId) => String(sceneId ?? "").trim())
+                .filter((sceneId) => knownIds.has(sceneId)),
+        )];
+        const revisionPattern = /^[0-9a-f]{32}$/;
+        let alternateDraft = null;
+        const rawAlternate = value?.alternate_draft;
+        if (rawAlternate && typeof rawAlternate === "object") {
+            const sceneId = String(rawAlternate.scene_id ?? "").trim();
+            const scene = (state.plan?.shots ?? []).findIndex((shot, index) =>
+                safeShotId(shot?.id, `clip_${String(index + 1).padStart(4, "0")}`) === sceneId) + 1;
+            const baseRevision = String(rawAlternate.base_revision ?? "").toLowerCase();
+            const prompt = String(rawAlternate.prompt ?? "").trim();
+            let seed = "0";
+            try {
+                const parsed = BigInt(String(rawAlternate.seed ?? "0"));
+                if (parsed >= 0n && parsed <= MAX_SEED) seed = parsed.toString();
+            } catch (_error) {}
+            if (scene > 0 && revisionPattern.test(baseRevision) && prompt) {
+                alternateDraft = {
+                    enabled:rawAlternate.enabled !== false,
+                    scene, scene_id:sceneId, base_revision:baseRevision,
+                    prompt, seed, media_mode:"picture_only",
+                };
+            }
+        }
+        const replacements = [];
+        const replaced = new Set();
+        for (const item of Array.isArray(value?.replacements)
+            ? value.replacements : []) {
+            const sceneId = String(item?.scene_id ?? "").trim();
+            const scene = (state.plan?.shots ?? []).findIndex((shot, index) =>
+                safeShotId(shot?.id, `clip_${String(index + 1).padStart(4, "0")}`) === sceneId) + 1;
+            const baseRevision = String(item?.base_revision ?? "").toLowerCase();
+            const alternateRevision = String(item?.alternate_revision ?? "").toLowerCase();
+            if (scene < 1 || replaced.has(sceneId)
+                    || !revisionPattern.test(baseRevision)
+                    || !revisionPattern.test(alternateRevision)) continue;
+            replaced.add(sceneId);
+            replacements.push({
+                scene, scene_id:sceneId, base_revision:baseRevision,
+                alternate_revision:alternateRevision,
+                media_mode:"picture_only",
+            });
+        }
+        return {
+            revision:revisionPattern.test(String(value?.revision ?? "").toLowerCase())
+                ? String(value.revision).toLowerCase() : "",
+            placements,
+            trims,
+            locked_scene_ids:lockedSceneIds,
+            subtitles:{
+                mode,
+                asset_id:String(rawSubtitles.asset_id ?? ""),
+                offset_seconds:Number.isFinite(offset)
+                    ? Math.max(-3600, Math.min(3600, offset)) : 0,
+            },
+            alternate_draft:alternateDraft,
+            replacements,
+        };
+    }
+
+    function timelineModel() {
+        const result = timing();
+        const sceneSegments = studioTimelineSegments(
+            result.shots, state.editorial.placements, null,
+            state.editorial.trims,
+        );
+        const sceneEndFrame = Math.max(
+            1,
+            Math.round(studioTimelineTotalSeconds(sceneSegments) * FPS),
+        );
+        const sourceDescriptor = state.sourcePreview?.source_audio;
+        const sourceEndFrame = sourceDescriptor?.available
+            ? Math.max(
+                Number(sourceDescriptor.available_frame_count) || 0,
+                Number(sourceDescriptor.frame_count) || 0,
+            ) : 0;
+        const subtitleOffset = Number(
+            state.editorial.subtitles?.offset_seconds,
+        ) || 0;
+        const subtitleEndFrame = subtitleCues().reduce(
+            (latest, cue) => Math.max(
+                latest,
+                Math.ceil((Number(cue?.endSeconds) + subtitleOffset) * FPS),
+            ),
+            0,
+        );
+        const workspaceEndFrame = Math.min(864000, Math.max(
+            sceneEndFrame * 2,
+            sourceEndFrame,
+            subtitleEndFrame,
+            Number(state.timelineWorkspaceEndFrame) || 0,
+        ));
+        state.timelineSceneEndFrame = sceneEndFrame;
+        state.timelineWorkspaceEndFrame = workspaceEndFrame;
+        const segments = studioTimelineSegments(
+            result.shots, state.editorial.placements, workspaceEndFrame,
+            state.editorial.trims,
+        );
+        return {
+            result, segments,
+            totalSeconds:studioTimelineTotalSeconds(segments),
+            sceneEndSeconds:sceneEndFrame / FPS,
+            workspaceEndFrame,
+        };
+    }
+
+    function sceneLocked(index) {
+        const row = timing().shots[index];
+        return Boolean(row && state.editorial.locked_scene_ids.includes(
+            String(row.id),
+        ));
+    }
+
+    function setSceneLocked(index, locked) {
+        const row = timing().shots[index];
+        if (!row) return;
+        const sceneId = String(row.id);
+        const next = new Set(state.editorial.locked_scene_ids);
+        if (locked) next.add(sceneId);
+        else next.delete(sceneId);
+        state.editorial.locked_scene_ids = [...next];
+        scheduleEditorialSave();
+        renderShell();
+    }
+
+    function unlockAllScenes() {
+        if (!state.editorial.locked_scene_ids.length) return;
+        state.editorial.locked_scene_ids = [];
+        scheduleEditorialSave();
+        renderShell();
+    }
+
+    function placementForScene(index) {
+        const row = timing().shots[index];
+        const placement = state.editorial.placements.find(
+            (placement) => placement.scene_id === String(row?.id ?? ""),
+        ) ?? null;
+        return placement ? {...placement} : null;
+    }
+
+    function trimForScene(index) {
+        const row = timing().shots[index];
+        const trim = state.editorial.trims.find(
+            (item) => item.scene_id === String(row?.id ?? ""),
+        ) ?? null;
+        return trim ? {...trim} : null;
+    }
+
+    function setSceneTrim(index, outFrame) {
+        const row = timing().shots[index];
+        if (!row || sceneLocked(index)) return;
+        const sceneId = String(row.id);
+        const fullFrames = Math.max(1, Number(row.deliveredFrames) || 1);
+        const safeOut = studioNearestLatentSafeOutFrame(
+            row.rawFrames, fullFrames, outFrame,
+        );
+        state.editorial.trims = state.editorial.trims.filter(
+            (item) => item.scene_id !== sceneId,
+        );
+        if (safeOut < fullFrames) state.editorial.trims.push({
+            scene_id:sceneId, out_frame:safeOut,
+        });
+        scheduleEditorialSave();
+        renderShell();
+    }
+
+    function setScenePlacement(index, startFrame) {
+        const row = timing().shots[index];
+        if (!row || sceneLocked(index)) return;
+        state.editorial.placements = state.editorial.placements.filter(
+            (placement) => placement.scene_id !== String(row.id),
+        );
+        if (startFrame != null && String(startFrame).trim() !== "") {
+            const requestedStart = Math.max(0, Math.min(
+                864000, Math.round(Number(startFrame) || 0),
+            ));
+            state.editorial.placements.push({
+                scene_id:String(row.id),
+                start_frame:requestedStart,
+            });
+        }
+        scheduleEditorialSave();
+        renderShell();
+        if (state.sourcePreview?.source_audio?.available) {
+            void loadSourceWaveform(state.sourcePreview);
+        }
+    }
+
+    function selectedSubtitleAsset() {
+        const assetId = String(state.editorial.subtitles?.asset_id ?? "");
+        return state.subtitleAssets.find(
+            (asset) => String(asset?.id ?? "") === assetId,
+        ) ?? null;
+    }
+
+    function subtitleCues() {
+        const asset = selectedSubtitleAsset();
+        return state.editorial.subtitles?.mode === "preview_srt" && asset
+            ? parseTimedLyrics(asset.lyrics) : [];
+    }
+
+    function updateSubtitleOverlay(seconds = state.timelinePosition ?? 0) {
+        if (!state.subtitleOverlay) return;
+        const cue = timedLyricAtSecond(
+            subtitleCues(), seconds,
+            state.editorial.subtitles?.offset_seconds,
+        );
+        state.subtitleOverlay.textContent = cue?.text ?? "";
+        state.subtitleOverlay.hidden = !cue;
+    }
+
+    async function loadSubtitleAssets() {
+        const currentRun = runName();
+        if (!currentRun || state.disposed) return;
+        const token = ++state.subtitleAssetsToken;
+        try {
+            const response = await api.fetchApi(
+                `/minimax_h3_context_loop/project-assets?project=${encodeURIComponent(currentRun)}`,
+            );
+            const payload = await response.json();
+            if (!response.ok) throw new Error(payload.error || `HTTP ${response.status}`);
+            if (state.disposed || token !== state.subtitleAssetsToken
+                    || currentRun !== runName()) return;
+            state.subtitleAssetsRun = currentRun;
+            state.subtitleAssets = (payload.assets ?? []).filter(
+                (asset) => asset?.kind === "audio" && String(asset?.lyrics ?? "").trim(),
+            );
+            renderSubtitleTimeline();
+            if (state.view === "subtitles") renderPanel();
+            updateSubtitleOverlay();
+        } catch (error) {
+            if (token === state.subtitleAssetsToken) {
+                state.subtitleAssets = [];
+                console.warn("H3 Plan Studio could not load timed lyrics:", error);
+            }
+        }
+    }
+
+    function promptEditorsSignature(editors = state.promptEditors) {
+        return editors.map((editor) => `${nodeType(editor)}:${String(editor.id ?? "")}`).sort().join("|");
+    }
+
+    function promptEditorLabel() {
+        if (state.promptEditors.length > 1) return `${state.promptEditors.length} linked prompt editors`;
+        return nodeType(state.promptEditors[0]) === "MiniMaxH3ChainRichScenePromptEditor"
+            ? "Rich Scene Prompt Editor" : "Scene Prompt Editor";
+    }
+
+    function preserveDelegatedPrompts() {
+        if (!state.promptEditors.length || !state.planWidget || !state.plan) return;
+        let live;
+        try { live = parsePlanJson(String(state.planWidget.value ?? "")); }
+        catch (_error) { return; }
+        const byId = new Map();
+        for (const shot of live.shots) {
+            const id = String(shot?.id ?? "").trim();
+            if (id && !byId.has(id)) byId.set(id, shot);
+        }
+        state.plan.shots.forEach((shot, index) => {
+            const id = String(shot?.id ?? "").trim();
+            // A new ID (duplicate/add/rename) has no live counterpart yet.
+            // Never replace its prompt with the scene formerly at this index.
+            const current = id ? byId.get(id) : live.shots[index];
+            if (current) shot.prompt = promptTextToLines(promptValueToText(current.prompt));
+        });
+    }
+
+    function publishActiveScene() {
+        if (state.planNode) publishCompanionScene(node, state.planNode, state.active);
+    }
+
+    function editorialPayload() {
+        const shots = state.plan?.shots ?? [];
+        const sceneOrder = shots.map((shot, index) => ({
+            scene:index + 1,
+            scene_id:safeShotId(
+                shot?.id, `clip_${String(index + 1).padStart(4, "0")}`,
+            ),
+        }));
+        const sceneById = new Map(sceneOrder.map((row) => [row.scene_id, row.scene]));
+        return {
+            run_name:runName(),
+            revision:String(state.editorial.revision ?? ""),
+            base_revision:String(state.editorial.revision ?? ""),
+            chapters:orderedChapters(state.plan).map((chapter) => ({
+                id:chapter.id,
+                title:chapter.title,
+                start_scene_id:chapter.start_scene_id,
+                start_scene:sceneById.get(chapter.start_scene_id),
+                text:chapter.text ?? "",
+                ...(chapter.resolution ? {resolution:{...chapter.resolution}} : {}),
+            })),
+            scene_order:sceneOrder,
+            placements:state.editorial.placements.map((placement) => ({
+                scene_id:placement.scene_id,
+                scene:sceneById.get(placement.scene_id),
+                start_frame:placement.start_frame,
+            })),
+            trims:state.editorial.trims.map((trim) => ({
+                scene_id:trim.scene_id,
+                scene:sceneById.get(trim.scene_id),
+                out_frame:trim.out_frame,
+            })),
+            locked_scene_ids:[...state.editorial.locked_scene_ids],
+            subtitles:{...state.editorial.subtitles},
+            alternate_draft:state.editorial.alternate_draft
+                ? {...state.editorial.alternate_draft} : null,
+            replacements:state.editorial.replacements.map(
+                (replacement) => ({...replacement})),
+        };
+    }
+
+    function applyEditorialPayload(payload, expectedEpoch = state.editorialEditEpoch ?? 0, unusedSceneIds = []) {
+        const currentRun = runName();
+        if (!payload || String(payload.run_name ?? "") !== currentRun) return false;
+        if (expectedEpoch !== (state.editorialEditEpoch ?? 0)) return false;
+        // A periodic GET must not replace edits waiting for their POST.
+        if (state.editorialRun === currentRun
+                && (state.editorialTimer != null || state.editorialSavePromise
+                    || state.editorialSaving || state.editorialSaveError)) return false;
+        const next = normalizedEditorial(payload);
+        const previous = JSON.stringify(state.editorial);
+        const previousError = state.editorialBindingError;
+        state.editorial = next;
+        state.editorialRun = currentRun;
+        state.editorialReady = true;
+        // A GET is hydration, never permission to rewrite another Run's Plan.
+        // Keep the server document and the local view separately: unchanged
+        // Plan fields (notably chapters) must survive an unrelated scene edit.
+        state.editorialStored = structuredClone(payload);
+        state.editorialBaseline = editorialPayload();
+        const knownIds = new Set(state.editorialBaseline.scene_order.map((row) => row.scene_id));
+        // Only the same fresh checkpoint response can prove a missing order
+        // entry has no active or retained render. Cached/older servers fail
+        // closed. This permission never applies to saved editorial edits.
+        const unusedIds = new Set(Array.isArray(unusedSceneIds) ? unusedSceneIds : []);
+        state.editorialUnusedSceneIds = (payload.scene_order ?? [])
+            .map((row) => row.scene_id).filter((id) => !knownIds.has(id) && unusedIds.has(id));
+        const savedIds = [
+            ...(payload.scene_order ?? []).map((row) => row.scene_id).filter((id) => !unusedIds.has(id)),
+            ...(payload.chapters ?? []).map((row) => row.start_scene_id),
+            ...(payload.placements ?? []).map((row) => row.scene_id),
+            ...(payload.trims ?? []).map((row) => row.scene_id),
+            ...(payload.locked_scene_ids ?? []),
+            ...(payload.replacements ?? []).map((row) => row.scene_id),
+            payload.alternate_draft?.scene_id,
+        ].filter(Boolean);
+        const missingIds = [...new Set(savedIds.filter((id) => !knownIds.has(id)))];
+        state.editorialBindingError = missingIds.length
+            ? `Editorial saving paused: this Run contains saved scenes or edits absent from the connected Plan (${missingIds.slice(0, 5).join(", ")}${missingIds.length > 5 ? ", …" : ""}). Load its matching Plan or choose a new Run name.`
+            : "";
+        state.lastEditorialSignature = editorialSignature(state.editorialStored);
+        syncAlternateTakeWidget();
+        return previous !== JSON.stringify(next)
+            || previousError !== state.editorialBindingError;
+    }
+
+    function cacheStudioPresentation(records, editorial) {
+        const snapshot = studioCheckpointCacheSnapshot(
+            runName(), records, editorial,
+        );
+        if (snapshot) node.properties[CHECKPOINT_CACHE_PROPERTY] = snapshot;
+    }
+
+    function editorialSignature(payload) {
+        const comparable = {...payload};
+        delete comparable.base_revision;
+        delete comparable.revision;
+        return JSON.stringify(comparable);
+    }
+
+    async function persistEditorial(payload, signature) {
+        // Capture the editor binding, not just its Run name: A -> B -> A
+        // creates a new view that must not adopt an old request's revision.
+        const binding = state.editorial;
+        const readRevision = String(binding.revision ?? payload.base_revision ?? "");
+        const previousSave = state.editorialSavePromise;
+        const request = (async () => {
+            let previous = null;
+            if (previousSave) {
+                try { previous = await previousSave; } catch (_error) {}
+            }
+            const outbound = {
+                ...payload,
+                base_revision:previous?.binding === binding
+                        && previous.run_name === payload.run_name
+                    ? previous.revision : readRevision,
+            };
+            const response = await api.fetchApi(
+                "/minimax_h3_context_loop/editorial",
+                {
+                    method:"POST", headers:{"Content-Type":"application/json"},
+                    body:JSON.stringify(outbound),
+                },
+            );
+            const detail = await response.json().catch(() => ({}));
+            if (!response.ok) {
+                throw new Error(detail.error || `HTTP ${response.status}`);
+            }
+            const saved = detail.editorial;
+            if (state.editorial === binding && state.editorialRun === payload.run_name
+                    && saved && typeof saved === "object") {
+                state.editorial.revision = String(saved.revision ?? "");
+                // Invalidate checkpoint GETs that started before this commit.
+                state.editorialEditEpoch = (state.editorialEditEpoch ?? 0) + 1;
+                state.editorialSaveError = "";
+                if (!state.disposed) renderStatus();
+            }
+            return {binding, run_name:payload.run_name, revision:String(saved?.revision ?? readRevision)};
+        })();
+        state.editorialSavePromise = request;
+        try {
+            await request;
+        } catch (error) {
+            if (state.editorial === binding && state.lastEditorialSignature === signature) {
+                state.lastEditorialSignature = "";
+                state.editorialSaveError = error?.message || String(error);
+                if (!state.disposed) renderStatus();
+            }
+            console.warn(
+                "H3 Plan Studio could not save chapter presentation data:",
+                error,
+            );
+            throw error;
+        } finally {
+            if (state.editorialSavePromise === request) {
+                state.editorialSavePromise = null;
+                if (!state.disposed && state.editorial === binding) renderStatus();
+            }
+        }
+    }
+
+    async function flushProjectWrites(expectedRun = runName()) {
+        const run = String(expectedRun ?? "").trim();
+        let editorialError = null;
+        try {
+            if (run && state.editorialRun === run) {
+                if (state.editorialTimer != null) {
+                    clearTimeout(state.editorialTimer);
+                    state.editorialTimer = null;
+                }
+                const pending = state.editorialPending;
+                state.editorialPending = null;
+                if (pending?.payload?.run_name === run) {
+                    await persistEditorial(pending.payload, pending.signature);
+                } else if (state.editorialSavePromise) {
+                    await state.editorialSavePromise;
+                }
+            }
+        } catch (error) {
+            editorialError = error;
+        }
+        await flushHistoryDraft();
+        if (editorialError) throw editorialError;
+    }
+
+    function syncAlternateTakeWidget() {
+        if (alternateTakeWidget) {
+            const serialized = JSON.stringify(
+                state.editorial.alternate_draft ?? null,
+            );
+            if (alternateTakeWidget.value !== serialized) {
+                alternateTakeWidget.value = serialized;
+                alternateTakeWidget.callback?.(serialized);
+                dirty();
+            }
+        }
+    }
+
+    function scheduleEditorialSave(delay = 250) {
+        syncAlternateTakeWidget();
+        if (!state.plan) return;
+        if (!state.editorialReady || state.editorialRun !== runName()) return;
+        if (state.editorialBindingError) { renderStatus(); return; }
+        const local = editorialPayload();
+        const payload = {...state.editorialStored};
+        // Only explicitly changed fields may replace saved project data.
+        for (const [key, value] of Object.entries(local)) {
+            if (JSON.stringify(value) !== JSON.stringify(state.editorialBaseline?.[key])) {
+                payload[key] = value;
+            }
+        }
+        payload.run_name = local.run_name;
+        // Do not turn a GET (or a seed/prompt-only edit) into a project write.
+        if (editorialSignature(payload) === state.lastEditorialSignature) return;
+        if (state.editorialUnusedSceneIds?.length) {
+            payload.scene_order = local.scene_order;
+        }
+        cacheStudioPresentation([...state.checkpoints.values()], payload);
+        const signature = editorialSignature(payload);
+        if (signature === state.lastEditorialSignature) return;
+        state.editorialEditEpoch = (state.editorialEditEpoch ?? 0) + 1;
+        state.lastEditorialSignature = signature;
+        if (state.editorialTimer != null) clearTimeout(state.editorialTimer);
+        if (!payload.run_name) return;
+        state.editorialPending = {payload, signature};
+        state.editorialTimer = setTimeout(() => {
+            state.editorialTimer = null;
+            const pending = state.editorialPending;
+            if (pending?.signature === signature) state.editorialPending = null;
+            void persistEditorial(payload, signature).catch(() => {});
+        }, Math.max(0, Number(delay) || 0));
+    }
+
+    function writePlan(message = null) {
+        if (!state.plan || !state.planWidget) return;
+        // A linked dedicated editor owns scene prompts. Re-read those fields at
+        // the last possible moment so a Studio seed/length edit cannot overwrite
+        // prompt text typed since Studio's 500 ms polling snapshot.
+        preserveDelegatedPrompts();
+        const value = planToJson(state.plan);
+        state.lastValue = value;
+        state.planWidget.value = value;
+        if (state.planNode) {
+            const localPlanWidget = widget(node, "plan_json");
+            if (localPlanWidget) localPlanWidget.value = value;
+        }
+        if (state.planNotifyTimer != null) clearTimeout(state.planNotifyTimer);
+        const targetWidget = state.planWidget;
+        state.planNotifyTimer = setTimeout(() => {
+            state.planNotifyTimer = null;
+            if (targetWidget !== state.planWidget) return;
+            targetWidget.callback?.(targetWidget.value);
+        }, 75);
+        state.planOwner?.graph?.setDirtyCanvas?.(true, true);
+        if (state.planNode && !state.activeChapterId) {
+            publishCompanionPrompt(
+                node, state.planNode, state.active,
+                promptValueToText(state.plan.shots[state.active]?.prompt));
+        }
+        if (message) message.textContent = state.planNode
+            ? "Saved to connected Plan" : "Saved in standalone Plan Studio";
+        scheduleEditorialSave();
+        renderStatus();
+        dirty();
+    }
+
+    function historyKey(sceneId) {
+        return `${runName()}\u0000${sceneId}`;
+    }
+
+    async function historyRequest(query = {}, body = null) {
+        const suffix = new URLSearchParams(query).toString();
+        const response = await api.fetchApi(
+            `/minimax_h3_context_loop/prompt-history${suffix ? `?${suffix}` : ""}`,
+            body == null ? undefined : {method:"POST", headers:{"Content-Type":"application/json"}, body:JSON.stringify(body)},
+        );
+        let payload = {};
+        try { payload = await response.json(); } catch (_error) {}
+        if (!response.ok) throw new Error(payload.error || `Prompt history request failed (HTTP ${response.status}).`);
+        return payload;
+    }
+
+    function renderHistory() {
+        const history = state.history;
+        if (!history.host) return;
+        history.host.replaceChildren();
+        if (history.error) {
+            history.host.append(element("span", "h3studio-history-meta h3studio-error", history.error));
+            return;
+        }
+        if (!history.data) {
+            history.host.append(element("span", "h3studio-history-meta", "Loading prompt versions…"));
+            return;
+        }
+        const navigation = promptRevisionNavigation(history.data, history.revisionId);
+        const previous = button("‹", "Activate previous prompt version in the Plan", () => {
+            if (navigation.previous) void selectHistoryRevision(navigation.previous.id);
+        });
+        const next = button("›", "Activate next prompt version in the Plan", () => {
+            if (navigation.next) void selectHistoryRevision(navigation.next.id);
+        });
+        previous.disabled = !navigation.previous;
+        next.disabled = !navigation.next;
+        const count = element("span", "h3studio-history-count", `Active ${navigation.position} / ${navigation.total}`);
+        const metadata = element("span", "h3studio-history-meta", promptRevisionLabel(navigation));
+        metadata.title = promptRevisionHelp(navigation);
+        history.host.append(previous, count, next, metadata);
+    }
+
+    async function loadHistory(sceneId, prompt, synchronize = true) {
+        const history = state.history;
+        const currentRun = runName();
+        const key = historyKey(sceneId);
+        const token = ++history.loadToken;
+        history.sceneKey = key; history.data = null; history.revisionId = null; history.error = "";
+        renderHistory();
+        if (!currentRun) { history.error = "Set a Plan run_name to enable prompt history."; renderHistory(); return; }
+        const request = synchronize ? historyRequest({}, {
+            action:"save", run_name:currentRun, scene_id:sceneId, prompt, parent_revision:null,
+        }) : historyRequest({run_name:currentRun, scene_id:sceneId});
+        history.loadPromise = request;
+        try {
+            const payload = await request;
+            if (token !== history.loadToken || history.sceneKey !== key) return;
+            history.data = payload.history ?? payload;
+            history.revisionId = payload.revision?.id ?? history.data.active_revision ?? null;
+        } catch (error) {
+            if (token === history.loadToken && history.sceneKey === key) history.error = error?.message || String(error);
+        } finally {
+            if (history.loadPromise === request) history.loadPromise = null;
+            if (token === history.loadToken && history.sceneKey === key) renderHistory();
+        }
+    }
+
+    function scheduleHistoryDraft(sceneId, prompt) {
+        const currentRun = runName();
+        if (!currentRun) return;
+        const history = state.history;
+        history.pendingDraft = {key:historyKey(sceneId), runName:currentRun, sceneId, prompt};
+        if (history.saveTimer != null) clearTimeout(history.saveTimer);
+        history.saveTimer = setTimeout(() => { history.saveTimer = null; void flushHistoryDraft(); }, 650);
+    }
+
+    async function flushHistoryDraft() {
+        const history = state.history;
+        if (history.saveTimer != null) { clearTimeout(history.saveTimer); history.saveTimer = null; }
+        if (history.savePromise) { await history.savePromise; return history.pendingDraft ? flushHistoryDraft() : undefined; }
+        const draft = history.pendingDraft;
+        if (!draft) return;
+        history.pendingDraft = null;
+        if (history.loadPromise && history.sceneKey === draft.key) await history.loadPromise;
+        const request = historyRequest({}, {action:"save", run_name:draft.runName,
+            scene_id:draft.sceneId, prompt:draft.prompt,
+            parent_revision:history.sceneKey === draft.key ? history.revisionId : null});
+        history.savePromise = request;
+        try {
+            const payload = await request;
+            if (history.sceneKey === draft.key) {
+                history.data = payload.history; history.revisionId = payload.revision?.id ?? payload.history?.active_revision;
+                history.error = ""; renderHistory();
+            }
+        } catch (error) {
+            if (history.sceneKey === draft.key) { history.error = error?.message || String(error); renderHistory(); }
+        } finally { if (history.savePromise === request) history.savePromise = null; }
+        if (history.pendingDraft) await flushHistoryDraft();
+    }
+
+    async function selectHistoryRevision(revisionId) {
+        await flushHistoryDraft();
+        const shot = state.plan?.shots?.[state.active];
+        const history = state.history;
+        if (!shot || !history.textarea) return;
+        const sceneId = safeShotId(shot.id, `clip_${String(state.active + 1).padStart(4,"0")}`);
+        const key = historyKey(sceneId);
+        try {
+            const payload = await historyRequest({}, {action:"activate", run_name:runName(), scene_id:sceneId, revision:revisionId});
+            if (history.sceneKey !== key) return;
+            history.data = payload.history; history.revisionId = payload.revision.id; history.error = "";
+            history.textarea.value = String(payload.revision.prompt ?? "");
+            shot.prompt = promptTextToLines(history.textarea.value);
+            writePlan(history.status); renderHistory(); history.textarea.focus();
+        } catch (error) { if (history.sceneKey === key) { history.error = error?.message || String(error); renderHistory(); } }
+    }
+
+    async function refreshCheckpointsNow() {
+        if (state.disposed) return;
+        const currentRun = runName();
+        const token = ++state.checkpointToken;
+        const editorialEpoch = state.editorialEditEpoch ?? 0;
+        if (!currentRun) {
+            const changed = state.checkpoints.size > 0
+                || Boolean(state.checkpointSignature) || Boolean(state.checkpointError);
+            state.checkpoints = new Map(); state.checkpointSignature = "";
+            state.checkpointError = "";
+            if (changed) { refreshTimelineCheckpoints(); renderStatus(); }
+            return;
+        }
+        let editorialChanged = false;
+        try {
+            const query = new URLSearchParams({
+                run_name:currentRun, include_graph:"false",
+            });
+            const response = await api.fetchApi(`/minimax_h3_context_loop/checkpoints?${query.toString()}`);
+            const payload = await response.json();
+            if (!response.ok) throw new Error(payload.error || `HTTP ${response.status}`);
+            if (state.disposed || token !== state.checkpointToken || currentRun !== runName()) return;
+            editorialChanged = applyEditorialPayload(
+                payload.editorial, editorialEpoch, payload.editorial_unused_scene_ids,
+            );
+            const records = payload.checkpoints ?? [];
+            cacheStudioPresentation(records, payload.editorial);
+            const signature = studioCheckpointSignature(currentRun, records);
+            const recoveredFromError = Boolean(state.checkpointError);
+            state.checkpointError = "";
+            if (signature === state.checkpointSignature) {
+                if (editorialChanged) {
+                    renderStatus(); renderTimeline();
+                    if (["player", "subtitles"].includes(state.view)) renderPanel();
+                }
+                if (recoveredFromError) renderStatus();
+                return;
+            }
+            state.checkpointSignature = signature;
+            state.checkpoints = new Map(records.map((item) => [Number(item.scene), item]));
+        } catch (error) {
+            if (token !== state.checkpointToken) return;
+            state.checkpointError = error?.message || String(error);
+            renderStatus();
+            return;
+        }
+        if (editorialChanged) renderTimeline();
+        else refreshTimelineCheckpoints();
+        renderStatus();
+        if (state.view === "context") renderPanel();
+        if (editorialChanged && ["player", "subtitles"].includes(state.view)) {
+            renderPanel();
+        }
+        if (state.view === "player" && state.player) {
+            const media = playerCheckpoint(state.playerIndex);
+            const desired = media?.video ? videoUrl(media.video) : "";
+            const desiredAudio = media?.audio ? videoUrl(media.audio) : "";
+            if (desired !== String(state.player.dataset.source ?? "") ||
+                    desiredAudio !== String(
+                        state.playerAudio?.dataset.source ?? "")) renderPanel();
+        }
+    }
+
+    async function refreshCheckpoints() {
+        if (state.disposed) return;
+        if (state.checkpointPromise) {
+            state.checkpointRefreshQueued = true;
+            return state.checkpointPromise;
+        }
+        const request = refreshCheckpointsNow();
+        state.checkpointPromise = request;
+        try {
+            return await request;
+        } finally {
+            if (state.checkpointPromise === request) state.checkpointPromise = null;
+            if (state.checkpointRefreshQueued && !state.disposed) {
+                state.checkpointRefreshQueued = false;
+                void refreshCheckpoints();
+            }
+        }
+    }
+
+    function renderStatus() {
+        const host = root.querySelector(".h3studio-statusline");
+        if (!host || !state.plan) return;
+        const {result, totalSeconds, sceneEndSeconds} = timelineModel();
+        const ready = result.shots.filter(
+            (row, index) => matchingStudioCheckpoint(state.checkpoints, index, row),
+        ).length;
+        host.replaceChildren();
+        host.append(
+            element("strong", "", `${result.shots.length} scenes`),
+            document.createTextNode(
+                `${result.totalFrames} generated frames · ` +
+                `${formatClock(sceneEndSeconds)} placed · ` +
+                `blank track open to ${formatClock(totalSeconds)}`,
+            ),
+            document.createTextNode(`${settings().contextLength}f overlap · ${ready}/${result.shots.length} rendered`),
+        );
+        if (result.errors.length) host.append(element("span", "h3studio-error", `${result.errors.length} plan issue${result.errors.length === 1 ? "" : "s"}`));
+        if (state.checkpointError) host.append(element("span", "h3studio-error", state.checkpointError));
+        if (state.editorialBindingError) host.append(element("span", "h3studio-error", state.editorialBindingError));
+        if (state.editorialSaveError) {
+            host.append(element("span", "h3studio-error",
+                `Editorial edits are not saved: ${state.editorialSaveError}`));
+            const retry = button("Retry save", "Retry the current local editorial edits", () => {
+                scheduleEditorialSave(0);
+            });
+            const reload = button("Reload saved cut", "Discard unsaved editorial edits and reload the saved final cut", () => {
+                if (state.editorialSavePromise || state.editorialTimer != null) return;
+                if (!window.confirm("Discard the unsaved editorial edits in this Studio and reload the saved final cut?")) return;
+                state.editorialSaveError = "";
+                state.editorialEditEpoch = (state.editorialEditEpoch ?? 0) + 1;
+                void refreshCheckpoints();
+            });
+            retry.disabled = reload.disabled = Boolean(state.editorialSavePromise || state.editorialTimer != null);
+            host.append(retry, reload);
+        }
+    }
+
+    function timelinePixelAtSecond(seconds) {
+        return studioTimelinePixelAtSecond(
+            seconds,
+            state.timelinePixelsPerSecond,
+            Number(state.timelineContent?.dataset.timelineWidth) || 0,
+        );
+    }
+
+    function positionTimelinePlayhead(seconds) {
+        if (!state.playhead) return;
+        state.playhead.style.left = `${timelinePixelAtSecond(seconds)}px`;
+    }
+
+    function renderRuler(ruler, totalSeconds) {
+        ruler.replaceChildren();
+        const width = Math.max(
+            Number(state.timelineContent?.dataset.timelineWidth) || 0,
+            ruler.clientWidth,
+        );
+        for (const tick of studioRulerTicks(totalSeconds, width)) {
+            const marker = element(
+                "span",
+                `h3studio-ruler-tick${tick.major ? " h3studio-major" : ""}`,
+            );
+            marker.style.left = `${timelinePixelAtSecond(tick.seconds)}px`;
+            if (tick.major) marker.append(
+                element("span", "", formatClock(tick.seconds)),
+            );
+            ruler.append(marker);
+        }
+        const playhead = element("span", "h3studio-playhead");
+        ruler.append(playhead);
+        state.playhead = playhead;
+        positionTimelinePlayhead(state.timelinePosition ?? 0);
+        const hover = element("span", "h3studio-ruler-hover");
+        hover.hidden = true;
+        ruler.append(hover);
+        const targetAtEvent = (event) => {
+            if (!totalSeconds) return;
+            const rect = ruler.getBoundingClientRect();
+            const localRatio = (event.clientX - rect.left) /
+                Math.max(1, rect.width);
+            if (!(state.timelinePixelsPerSecond > 0)) {
+                return Math.max(0, Math.min(
+                    totalSeconds, localRatio * totalSeconds,
+                ));
+            }
+            return Math.max(0, Math.min(
+                totalSeconds,
+                localRatio * width /
+                    Math.max(Number.EPSILON, state.timelinePixelsPerSecond),
+            ));
+        };
+        const showHover = (event) => {
+            const target = targetAtEvent(event);
+            if (target == null) return;
+            hover.hidden = false;
+            hover.textContent = formatClock(target);
+            hover.style.left = `${timelinePixelAtSecond(target)}px`;
+        };
+        const scrub = (event) => {
+            const target = targetAtEvent(event);
+            if (target == null) return;
+            state.timelinePosition = target;
+            if (state.view !== "player") {
+                state.view = "player"; persistView(); renderToolbarState(); renderPanel();
+            } else seekTimeline(target, false);
+            showHover(event);
+        };
+        ruler.onpointerdown = (event) => {
+            if (event.button !== 0) return;
+            event.preventDefault();
+            ruler.setPointerCapture?.(event.pointerId);
+            ruler.dataset.scrubbing = "true";
+            scrub(event);
+        };
+        ruler.onpointermove = (event) => {
+            showHover(event);
+            if (ruler.dataset.scrubbing === "true") scrub(event);
+        };
+        ruler.onpointerup = ruler.onpointercancel = (event) => {
+            delete ruler.dataset.scrubbing;
+            ruler.releasePointerCapture?.(event.pointerId);
+        };
+        ruler.onpointerleave = () => {
+            if (ruler.dataset.scrubbing !== "true") hover.hidden = true;
+        };
+    }
+
+    function revealActiveTimelineScene() {
+        const viewport = state.timelineViewport;
+        const card = state.timelineHost?.querySelector(
+            `[data-scene-index="${state.active}"]`,
+        );
+        if (!viewport || !card) return;
+        const start = card.offsetLeft;
+        const end = start + card.offsetWidth;
+        const visibleStart = viewport.scrollLeft;
+        const visibleEnd = visibleStart + viewport.clientWidth;
+        let target = null;
+        if (start < visibleStart) target = start;
+        else if (end > visibleEnd) {
+            target = Math.max(0, end - viewport.clientWidth);
+        }
+        if (target == null) return;
+        state.timelineScrollIntentUntil = 0;
+        state.timelineLastScrollLeft = target;
+        viewport.scrollLeft = target;
+    }
+
+    function timelineScrollSnapshot(anchorRatio = .5) {
+        const viewport = state.timelineViewport;
+        const content = state.timelineContent;
+        const totalSeconds = studioTimelineTotalSeconds(state.timelineSegments);
+        const contentWidth = Math.max(
+            0, Number(content?.dataset.timelineWidth) || content?.scrollWidth || 0,
+        );
+        if (!viewport || !content) return null;
+        const boundedAnchor = Math.max(0, Math.min(
+            1, Number(anchorRatio) || 0,
+        ));
+        return {
+            scrollLeft:Math.max(0, Number(viewport.scrollLeft) || 0),
+            seconds:contentWidth > 0 && totalSeconds > 0
+                ? studioTimelineScrollAnchorSeconds(
+                    viewport.scrollLeft, viewport.clientWidth,
+                    contentWidth, totalSeconds, boundedAnchor,
+                ) : null,
+            anchorRatio:boundedAnchor,
+        };
+    }
+
+    function layoutTimeline({preserveScroll = true, revealActive = false,
+        anchorRatio = .5, restoreScroll = null} = {}) {
+        const viewport = state.timelineViewport;
+        const content = state.timelineContent;
+        if (!viewport || !content || !state.plan) return;
+        const boundedAnchor = Math.max(0, Math.min(
+            1, Number(restoreScroll?.anchorRatio ?? anchorRatio) || 0,
+        ));
+        const restoredSeconds = restoreScroll == null
+            ? Number.NaN : Number(restoreScroll.seconds);
+        const restoredLeft = restoreScroll == null
+            ? Number.NaN : Number(restoreScroll.scrollLeft);
+        const preservedLeft = preserveScroll
+            ? Math.max(0, Number(viewport.scrollLeft) || 0) : Number.NaN;
+        const model = timelineModel();
+        const result = model.result;
+        const layout = studioTimelineLayout(
+            result.shots, viewport.clientWidth, state.timelineZoom,
+            state.editorial.placements, model.workspaceEndFrame,
+            state.editorial.trims,
+        );
+        state.timelineZoom = layout.zoom;
+        state.timelineWidths = layout.widths;
+        state.timelineSegments = layout.segments;
+        state.timelinePixelsPerSecond = layout.pixelsPerSecond;
+        content.dataset.timelineWidth = String(layout.contentWidth);
+        content.style.width = `${layout.contentWidth}px`;
+        for (const host of [
+            state.timelineHost, state.sourceTimelineHost,
+            state.sourceAudioTimelineHost,
+        ]) {
+            if (!host) continue;
+            [...host.querySelectorAll(
+                "[data-timeline-key]",
+            )].forEach((card) => {
+                const index = layout.segments.findIndex(
+                    (segment) => segment.key === card.dataset.timelineKey,
+                );
+                card.style.setProperty(
+                    "--h3-scene-width",
+                    `${layout.widths[index] ?? 0}px`,
+                );
+            });
+        }
+        if (state.timelineZoomInput) {
+            state.timelineZoomInput.value = String(layout.zoom);
+        }
+        if (state.timelineZoomLabel) {
+            state.timelineZoomLabel.textContent = `${Math.round(layout.zoom * 100)}%`;
+        }
+        if (state.timelineRuler) renderRuler(
+            state.timelineRuler, layout.totalSeconds,
+        );
+        if (state.timelineLayoutFrame != null) {
+            cancelAnimationFrame(state.timelineLayoutFrame);
+        }
+        state.timelineLayoutFrame = requestAnimationFrame(() => {
+            state.timelineLayoutFrame = null;
+            if (!viewport.isConnected) return;
+            let targetLeft = Number.isFinite(restoredLeft)
+                ? restoredLeft : preservedLeft;
+            if (!Number.isFinite(targetLeft)
+                    && Number.isFinite(restoredSeconds)) {
+                targetLeft = studioTimelineScrollLeftForAnchor(
+                    restoredSeconds, viewport.clientWidth,
+                    layout.pixelsPerSecond, boundedAnchor,
+                );
+            }
+            if (Number.isFinite(targetLeft)
+                    && Math.abs(viewport.scrollLeft - targetLeft) > .5) {
+                // Keep programmatic restoration invisible to the edge-growth
+                // listener. Only a user's rightward scroll may grow the open
+                // timeline workspace.
+                state.timelineLastScrollLeft = targetLeft;
+                viewport.scrollLeft = targetLeft;
+            }
+            if (revealActive) revealActiveTimelineScene();
+            layoutChapterMarkers();
+        });
+    }
+
+    function layoutChapterMarkers() {
+        if (!state.timelineHost) return;
+        for (const marker of state.timelineHost.querySelectorAll(
+            ".h3studio-chapter-marker",
+        )) {
+            const index = Number(marker.dataset.startSceneIndex);
+            const card = state.timelineHost.querySelector(
+                `[data-scene-index="${index}"]`,
+            );
+            if (card) marker.style.left = `${card.offsetLeft}px`;
+        }
+    }
+
+    function setTimelineZoom(value, anchorRatio = .5) {
+        const zoomAnchor = timelineScrollSnapshot(anchorRatio);
+        if (zoomAnchor) delete zoomAnchor.scrollLeft;
+        state.timelineZoom = normalizedTimelineZoom(value);
+        node.properties[TIMELINE_ZOOM_PROPERTY] = state.timelineZoom;
+        layoutTimeline({
+            preserveScroll:false, anchorRatio, restoreScroll:zoomAnchor,
+        });
+        dirty();
+    }
+
+    function extendTimelineWorkspace(minimumEndFrame = null) {
+        if (state.timelineExtending) return false;
+        const model = timelineModel();
+        if (model.workspaceEndFrame >= 864000) return false;
+        const pageFrames = Math.max(FPS, state.timelineSceneEndFrame);
+        const requested = minimumEndFrame == null
+            ? model.workspaceEndFrame + pageFrames
+            : Number(minimumEndFrame);
+        const next = Math.min(864000, Math.max(
+            model.workspaceEndFrame + 1,
+            Math.ceil(Number(requested) || 0),
+        ));
+        if (next <= model.workspaceEndFrame) return false;
+        state.timelineExtending = true;
+        state.timelineWorkspaceEndFrame = next;
+        renderTimeline({revealActive:false});
+        const updated = timelineModel();
+        if (state.playerSlider) {
+            state.playerSlider.max = String(updated.totalSeconds);
+        }
+        const clock = root.querySelector(".h3studio-player-clock");
+        if (clock) clock.textContent = `${formatClock(state.timelinePosition ?? 0)} / ${formatClock(updated.totalSeconds)}`;
+        renderStatus();
+        requestAnimationFrame(() => { state.timelineExtending = false; });
+        return true;
+    }
+
+    function sourceScene(index) {
+        return matchingStudioSourceScene(
+            state.sourcePreview, index, timing().shots[index],
+        );
+    }
+
+    function sourceReference(index) {
+        return sourceScene(index)?.references?.[0] ?? null;
+    }
+
+    function sourcePreviewUrl(index, reference = sourceReference(index)) {
+        if (!state.sourcePreview?.token || !reference) return "";
+        const query = new URLSearchParams({
+            token:state.sourcePreview.token,
+            scene:String(index + 1),
+            slot:String(reference.slot ?? 0),
+        });
+        return api.apiURL(`/minimax_h3_context_loop/plan-studio/source-preview?${query.toString()}`);
+    }
+
+    function checkpointThumbnailUrl(index, checkpoint) {
+        const revision = String(
+            checkpoint?.presentation_revision ?? checkpoint?.revision ?? "",
+        ).trim().toLowerCase();
+        if (!checkpoint?.ready || !/^[0-9a-f]{32}$/.test(revision) || !runName()) {
+            return "";
+        }
+        const query = new URLSearchParams({
+            run_name:runName(), scene:String(index + 1), revision,
+        });
+        return api.apiURL(`/minimax_h3_context_loop/plan-studio/checkpoint-thumbnail?${query.toString()}`);
+    }
+
+    function sourceAudio() {
+        return matchingStudioSourceAudio(
+            state.sourcePreview, timing().shots, runName(),
+        );
+    }
+
+    function sourceAudioUrl() {
+        if (!sourceAudio() || !state.sourcePreview?.token) return "";
+        const query = new URLSearchParams({token:state.sourcePreview.token});
+        return api.apiURL(`/minimax_h3_context_loop/plan-studio/source-audio?${query.toString()}`);
+    }
+
+    function sourceWaveformUrl(payload = state.sourcePreview) {
+        if (!payload?.source_audio?.available || !payload?.token) return "";
+        const availableFrames = Number(
+            payload.source_audio.available_frame_count,
+        ) || Math.ceil(timelineModel().totalSeconds * FPS);
+        const requestedFrames = Math.max(
+            Number(payload.source_audio.frame_count) || 0,
+            Math.min(
+                availableFrames,
+                Math.ceil(timelineModel().totalSeconds * FPS),
+            ),
+        );
+        const query = new URLSearchParams({
+            token:payload.token,
+            frame_count:String(requestedFrames),
+        });
+        return api.apiURL(`/minimax_h3_context_loop/plan-studio/source-waveform?${query.toString()}`);
+    }
+
+    function sourceAudioMuteMap() {
+        const current = node.properties[SOURCE_AUDIO_MUTES_PROPERTY];
+        if (current && typeof current === "object" && !Array.isArray(current)) return current;
+        const created = {};
+        node.properties[SOURCE_AUDIO_MUTES_PROPERTY] = created;
+        return created;
+    }
+
+    function sourceAudioMuted(index) {
+        const row = timing().shots[index];
+        const key = row ? `${runName()}::${String(row.id)}` : "";
+        return Boolean(key && sourceAudioMuteMap()[key]);
+    }
+
+    function setSourceAudioMuted(index, muted) {
+        const row = timing().shots[index];
+        if (!row) return;
+        const mutes = sourceAudioMuteMap();
+        const key = `${runName()}::${String(row.id)}`;
+        if (muted) mutes[key] = true;
+        else delete mutes[key];
+        dirty();
+        renderSourceAudioTimeline();
+        root.querySelector(".h3studio-audio-generated")?.dispatchEvent(
+            new Event("change"),
+        );
+    }
+
+    function drawSourceWaveform(canvas, samples, color, muted) {
+        requestAnimationFrame(() => {
+            if (!canvas.isConnected) return;
+            const ratio = Math.max(1, window.devicePixelRatio || 1);
+            const width = Math.max(1, Math.round(canvas.clientWidth * ratio));
+            const height = Math.max(1, Math.round(canvas.clientHeight * ratio));
+            canvas.width = width; canvas.height = height;
+            const context = canvas.getContext("2d");
+            if (!context) return;
+            context.clearRect(0, 0, width, height);
+            context.strokeStyle = muted ? "rgba(190,198,214,.52)" : color;
+            context.lineWidth = Math.max(1, ratio);
+            const middle = height / 2;
+            context.beginPath();
+            if (!samples.length) {
+                context.moveTo(0, middle); context.lineTo(width, middle);
+            } else {
+                for (let x = 0; x < width; x += Math.max(1, Math.round(ratio))) {
+                    const sample = Math.max(0, Math.min(1, Number(
+                        samples[Math.min(samples.length - 1, Math.floor(
+                            x / width * samples.length,
+                        ))],
+                    ) || 0));
+                    const half = Math.max(ratio, sample * (height / 2 - ratio));
+                    context.moveTo(x, middle - half); context.lineTo(x, middle + half);
+                }
+            }
+            context.stroke();
+        });
+    }
+
+    async function loadSourceWaveform(payload = state.sourcePreview) {
+        const token = String(payload?.token ?? "");
+        const url = sourceWaveformUrl(payload);
+        if (!token || !url) return;
+        const requestKey = `${token}:${url}`;
+        if (state.sourceWaveformToken === requestKey && state.sourceWaveform) return;
+        if (state.sourceWaveformToken === requestKey && state.sourceWaveformPromise) {
+            // The owning request below reports errors in the timeline. A
+            // deduplicated fire-and-forget caller must not reject separately.
+            await state.sourceWaveformPromise.catch(() => {});
+            return;
+        }
+        const sameSource = state.sourceWaveformToken.startsWith(`${token}:`);
+        state.sourceWaveformToken = requestKey;
+        // Keep the already-loaded portion visible while a longer arrangement
+        // requests more coverage. Never retain a different source's waveform.
+        if (!sameSource) state.sourceWaveform = null;
+        const request = (async () => {
+            const response = await api.fetchApi(url);
+            const waveform = await response.json();
+            if (!response.ok) throw new Error(
+                waveform.error || `HTTP ${response.status}`,
+            );
+            if (state.disposed || state.sourceWaveformToken !== requestKey) return;
+            state.sourceWaveform = waveform;
+            renderSourceAudioTimeline();
+        })();
+        state.sourceWaveformPromise = request;
+        try { await request; }
+        catch (error) {
+            if (state.sourceWaveformToken === requestKey) {
+                state.sourceWaveform = {samples:[], error:error?.message || String(error)};
+                renderSourceAudioTimeline();
+            }
+        } finally {
+            if (state.sourceWaveformPromise === request) {
+                state.sourceWaveformPromise = null;
+            }
+        }
+    }
+
+    function applySourcePresentation(payload) {
+        if (!payload || String(payload.run_name ?? "") !== runName()) return;
+        if (!state.sourceWaveformToken.startsWith(
+            `${String(payload.token ?? "")}:`,
+        )) {
+            state.sourceWaveform = null;
+            state.sourceWaveformToken = "";
+            state.sourceWaveformPromise = null;
+        }
+        state.sourcePreview = payload;
+        renderSourceTimeline();
+        renderSourceAudioTimeline();
+        if (payload.source_audio?.available) void loadSourceWaveform(payload);
+        if (state.view === "player" && state.player) {
+            seekTimeline(
+                state.timelinePosition ?? studioEditorialSceneStartSeconds(
+                    timelineModel().segments, state.active),
+                false,
+            );
+        }
+    }
+
+    async function restoreSourcePresentation() {
+        const currentRun = runName();
+        if (!currentRun || state.disposed) return;
+        const token = ++state.presentationToken;
+        try {
+            const query = new URLSearchParams({run_name:currentRun});
+            const response = await api.fetchApi(
+                `/minimax_h3_context_loop/plan-studio/presentation?${query.toString()}`,
+            );
+            const payload = await response.json();
+            if (response.status === 404) return;
+            if (!response.ok) throw new Error(payload.error || `HTTP ${response.status}`);
+            if (state.disposed || token !== state.presentationToken
+                    || currentRun !== runName()) return;
+            applySourcePresentation(payload);
+        } catch (error) {
+            if (token === state.presentationToken) {
+                console.warn("Plan Studio could not restore its saved track", error);
+            }
+        }
+    }
+
+    function updateTimelineCheckpointCard(card, index, result = timing()) {
+        if (!card) return;
+        const row = result.shots[index];
+        const checkpoint = matchingStudioCheckpoint(
+            state.checkpoints, index, row,
+        );
+        card.classList.toggle("h3studio-rendered", Boolean(checkpoint?.ready));
+        card.classList.toggle(
+            "h3studio-alternate-selected",
+            Boolean(checkpoint?.presentation_revision),
+        );
+        const url = checkpointThumbnailUrl(index, checkpoint);
+        const current = card.querySelector(".h3studio-card-thumbnail");
+        if (!url) {
+            current?.remove();
+            delete card.dataset.checkpointThumbnail;
+            return;
+        }
+        if (card.dataset.checkpointThumbnail === url && current) return;
+        current?.remove();
+        const image = element("img", "h3studio-card-thumbnail");
+        image.alt = "";
+        image.loading = "lazy";
+        image.decoding = "async";
+        image.src = url;
+        image.addEventListener("error", () => {
+            image.remove();
+            if (card.dataset.checkpointThumbnail === url) {
+                delete card.dataset.checkpointThumbnail;
+            }
+        }, {once:true});
+        card.dataset.checkpointThumbnail = url;
+        card.prepend(image);
+    }
+
+    function refreshTimelineCheckpoints() {
+        if (!state.timelineHost || !state.plan) return;
+        const result = timing();
+        for (const card of state.timelineHost.querySelectorAll(
+            ".h3studio-card[data-scene-index]",
+        )) {
+            const index = Number(card.dataset.sceneIndex);
+            if (Number.isInteger(index) && index >= 0
+                    && index < result.shots.length) {
+                updateTimelineCheckpointCard(card, index, result);
+            }
+        }
+    }
+
+    function trailingGapSegment() {
+        return state.timelineSegments.find(
+            (segment) => segment.kind === "gap" && segment.trailing,
+        ) ?? null;
+    }
+
+    function appendTimelineGap(host, segment, interactive = false) {
+        if (!host || !segment) return;
+        const gap = interactive
+            ? button("", segment.trailing
+                ? `Open black timeline after the last scene · ${formatClock(segment.durationSeconds)}`
+                : `Black gap · ${formatClock(segment.durationSeconds)}`, (event) => {
+                const rect = event.currentTarget?.getBoundingClientRect?.();
+                const ratio = rect?.width > 0 ? Math.max(0, Math.min(
+                    1, (event.clientX - rect.left) / rect.width,
+                )) : 0;
+                state.timelinePosition = segment.startSeconds +
+                    segment.durationSeconds * ratio;
+                state.view = "player"; persistView(); renderToolbarState(); renderPanel();
+            })
+            : element("div");
+        gap.className = interactive ? "h3studio-gap" : "h3studio-gap-spacer";
+        gap.dataset.timelineKey = segment.key;
+        gap.dataset.gapId = segment.gapId;
+        const segmentIndex = state.timelineSegments.findIndex(
+            (candidate) => candidate.key === segment.key,
+        );
+        if (state.timelineWidths[segmentIndex] > 0) gap.style.setProperty(
+            "--h3-scene-width", `${state.timelineWidths[segmentIndex]}px`,
+        );
+        if (interactive) gap.append(element(
+            "span", "h3studio-gap-copy",
+            segment.trailing
+                ? `OPEN TIMELINE · ${formatClock(segment.durationSeconds)}`
+                : `EMPTY · ${formatClock(segment.durationSeconds)}`,
+        ));
+        host.append(gap);
+    }
+
+    function enableScenePlacementDrag(card, handle, index) {
+        handle.title = sceneLocked(index)
+            ? "Scene locked · unlock it before moving"
+            : "Drag the clip or its grip to set the editorial start. Empty track space becomes black.";
+        const startDrag = (event) => {
+            if (event.button !== 0 || sceneLocked(index)) return;
+            if (event.target?.closest?.(
+                ".h3studio-lock-handle,.h3studio-resize-handle,button,input,select,textarea",
+            )) return;
+            event.preventDefault(); event.stopPropagation();
+            const model = timelineModel();
+            const scene = model.segments.find(
+                (segment) => segment.kind === "scene" && segment.sceneIndex === index,
+            );
+            if (!scene) return;
+            const contentWidth = Math.max(
+                1, Number(state.timelineContent?.dataset.timelineWidth)
+                    || state.timelineContent?.clientWidth || 1,
+            );
+            const secondsPerPixel = model.totalSeconds / contentWidth;
+            const originX = event.clientX;
+            const viewport = state.timelineViewport;
+            const originScrollLeft = viewport?.scrollLeft ?? 0;
+            const pointerId = event.pointerId;
+            let targetFrame = scene.startFrame;
+            let moved = false;
+            state.timelineDragging = true;
+            card.classList.add("h3studio-moving");
+            card.setPointerCapture?.(pointerId);
+            const onMove = (moveEvent) => {
+                if (moveEvent.pointerId !== pointerId) return;
+                moveEvent.preventDefault();
+                if (viewport) {
+                    const rect = viewport.getBoundingClientRect();
+                    if (moveEvent.clientX > rect.right - 36) viewport.scrollLeft += 18;
+                    else if (moveEvent.clientX < rect.left + 36) viewport.scrollLeft -= 18;
+                }
+                const deltaX = moveEvent.clientX - originX +
+                    ((viewport?.scrollLeft ?? 0) - originScrollLeft);
+                if (Math.abs(deltaX) > 3) moved = true;
+                if (!moved) return;
+                targetFrame = Math.max(
+                    0,
+                    Math.min(864000, Math.round(
+                        scene.startFrame + deltaX * secondsPerPixel * FPS,
+                    )),
+                );
+                const placedDeltaX = (targetFrame - scene.startFrame)
+                    / Math.max(Number.EPSILON, secondsPerPixel * FPS);
+                card.style.transform = `translateX(${placedDeltaX}px)`;
+                card.style.opacity = ".78";
+                handle.textContent = formatClock(targetFrame / FPS);
+            };
+            const finish = (upEvent) => {
+                if (upEvent.pointerId !== pointerId) return;
+                window.removeEventListener("pointermove", onMove, true);
+                window.removeEventListener("pointerup", finish, true);
+                window.removeEventListener("pointercancel", finish, true);
+                if (card.hasPointerCapture?.(pointerId)) {
+                    card.releasePointerCapture(pointerId);
+                }
+                state.timelineDragging = false;
+                card.classList.remove("h3studio-moving");
+                card.style.removeProperty("transform");
+                card.style.removeProperty("opacity");
+                handle.textContent = "⋮⋮";
+                card._h3SuppressClick = moved;
+                if (moved && upEvent.type === "pointerup") {
+                    setScenePlacement(index, targetFrame);
+                }
+            };
+            window.addEventListener("pointermove", onMove, true);
+            window.addEventListener("pointerup", finish, true);
+            window.addEventListener("pointercancel", finish, true);
+        };
+        card.addEventListener("pointerdown", startDrag);
+    }
+
+    function enableSceneDurationDrag(card, handle, index) {
+        const defaultTitle = sceneLocked(index)
+            ? "Scene locked · unlock it before changing its length"
+            : "Drag to set this scene's generated length. It snaps to H3's 17n+5 frame grid.";
+        handle.title = defaultTitle;
+        handle.addEventListener("pointerdown", (event) => {
+            if (event.button !== 0 || sceneLocked(index)) return;
+            event.preventDefault(); event.stopPropagation();
+            const model = timelineModel();
+            const row = model.result.shots[index];
+            const shot = state.plan?.shots?.[index];
+            if (!row || !shot) return;
+            const contentWidth = Math.max(
+                1, Number(state.timelineContent?.dataset.timelineWidth)
+                    || state.timelineContent?.clientWidth || 1,
+            );
+            const secondsPerPixel = model.totalSeconds / contentWidth;
+            const contextFrames = Math.max(
+                0, Number(row.rawFrames) - Number(row.deliveredFrames),
+            );
+            const minimumRaw = studioNearestH3FrameLength(
+                contextFrames + 1, contextFrames + 1, 3592,
+            );
+            const originX = event.clientX;
+            const originWidth = card.getBoundingClientRect().width;
+            let targetRaw = Number(row.rawFrames) || minimumRaw;
+            let moved = false;
+            state.timelineDragging = true;
+            handle.setPointerCapture?.(event.pointerId);
+            const onMove = (moveEvent) => {
+                const deltaX = moveEvent.clientX - originX;
+                if (Math.abs(deltaX) > 2) moved = true;
+                if (!moved) return;
+                targetRaw = studioNearestH3FrameLength(
+                    Number(row.rawFrames) + deltaX * secondsPerPixel * FPS,
+                    minimumRaw, 3592,
+                );
+                const deliveredFrames = Math.max(1, targetRaw - contextFrames);
+                card.style.setProperty(
+                    "--h3-scene-width",
+                    `${deliveredFrames / FPS / secondsPerPixel}px`,
+                );
+                handle.title = `${targetRaw} raw frames · ${(targetRaw / FPS).toFixed(3)}s generation`;
+            };
+            const finish = (upEvent) => {
+                handle.removeEventListener("pointermove", onMove);
+                handle.removeEventListener("pointerup", finish);
+                handle.removeEventListener("pointercancel", finish);
+                handle.releasePointerCapture?.(upEvent.pointerId);
+                state.timelineDragging = false;
+                handle.title = defaultTitle;
+                card.style.setProperty("--h3-scene-width", `${originWidth}px`);
+                if (!moved || targetRaw === Number(row.rawFrames)) return;
+                shot.length = targetRaw;
+                delete shot.frames;
+                delete shot.duration_seconds;
+                writePlan();
+                renderShell();
+            };
+            handle.addEventListener("pointermove", onMove);
+            handle.addEventListener("pointerup", finish);
+            handle.addEventListener("pointercancel", finish);
+        });
+    }
+
+    function enableSceneLatentTrimDrag(card, handle, index) {
+        const row = timing().shots[index];
+        if (!row) return;
+        const fullFrames = Math.max(1, Number(row.deliveredFrames) || 1);
+        const options = studioLatentSafeOutFrames(
+            row.rawFrames, fullFrames,
+        );
+        const currentOut = Number(trimForScene(index)?.out_frame) || fullFrames;
+        const defaultTitle = sceneLocked(index)
+            ? "Scene locked · unlock it before changing the used endpoint"
+            : `Latent-safe used end · ${currentOut}/${fullFrames} frames. Drag to trim; double-click to restore the full checkpoint.`;
+        handle.title = defaultTitle;
+        handle.addEventListener("dblclick", (event) => {
+            event.preventDefault(); event.stopPropagation();
+            if (!sceneLocked(index)) setSceneTrim(index, fullFrames);
+        });
+        handle.addEventListener("pointerdown", (event) => {
+            if (event.button !== 0 || sceneLocked(index) || !options.length) return;
+            event.preventDefault(); event.stopPropagation();
+            const model = timelineModel();
+            const contentWidth = Math.max(
+                1, Number(state.timelineContent?.dataset.timelineWidth)
+                    || state.timelineContent?.clientWidth || 1,
+            );
+            const secondsPerPixel = model.totalSeconds / contentWidth;
+            const originX = event.clientX;
+            const originWidth = card.getBoundingClientRect().width;
+            let targetOut = currentOut;
+            let moved = false;
+            state.timelineDragging = true;
+            handle.setPointerCapture?.(event.pointerId);
+            const onMove = (moveEvent) => {
+                const deltaX = moveEvent.clientX - originX;
+                if (Math.abs(deltaX) > 2) moved = true;
+                if (!moved) return;
+                targetOut = studioNearestLatentSafeOutFrame(
+                    row.rawFrames, fullFrames,
+                    currentOut + deltaX * secondsPerPixel * FPS,
+                );
+                card.style.setProperty(
+                    "--h3-scene-width",
+                    `${targetOut / FPS / secondsPerPixel}px`,
+                );
+                handle.title = `${targetOut}/${fullFrames} frames used · ${(targetOut / FPS).toFixed(3)}s · full sampled checkpoint retained`;
+            };
+            const finish = (upEvent) => {
+                handle.removeEventListener("pointermove", onMove);
+                handle.removeEventListener("pointerup", finish);
+                handle.removeEventListener("pointercancel", finish);
+                handle.releasePointerCapture?.(upEvent.pointerId);
+                state.timelineDragging = false;
+                handle.title = defaultTitle;
+                card.style.setProperty("--h3-scene-width", `${originWidth}px`);
+                if (moved && targetOut !== currentOut) {
+                    setSceneTrim(index, targetOut);
+                }
+            };
+            handle.addEventListener("pointermove", onMove);
+            handle.addEventListener("pointerup", finish);
+            handle.addEventListener("pointercancel", finish);
+        });
+    }
+
+    function renderTimeline({revealActive = false, restoreScroll = null} = {}) {
+        const host = state.timelineHost;
+        if (!host || !state.plan) return;
+        const preservedScroll = restoreScroll ?? timelineScrollSnapshot();
+        host.replaceChildren();
+        const result = timing();
+        state.timelineSegments = timelineModel().segments;
+        for (const timelineSegment of state.timelineSegments) {
+            if (timelineSegment.kind === "gap") {
+                if (!timelineSegment.trailing) {
+                    appendTimelineGap(host, timelineSegment, true);
+                }
+                continue;
+            }
+            const index = timelineSegment.sceneIndex;
+            const row = result.shots[index];
+            const checkpoint = matchingStudioCheckpoint(state.checkpoints, index, row);
+            const locked = sceneLocked(index);
+            const card = element("div");
+            card.title = locked
+                ? `Scene ${index + 1}: ${row.id} · locked`
+                : `Scene ${index + 1}: ${row.id} · drag to move`;
+            if (checkpoint?.continuation_stale) card.title +=
+                ` · regenerate: ${checkpoint.continuation_stale_reason}`;
+            card.tabIndex = 0;
+            card.setAttribute("role", "button");
+            card.addEventListener("click", (event) => {
+                if (card._h3SuppressClick) {
+                    card._h3SuppressClick = false;
+                    event.preventDefault(); event.stopPropagation();
+                    return;
+                }
+                void selectScene(index);
+            });
+            card.addEventListener("keydown", (event) => {
+                if (event.target !== card || !["Enter", " "].includes(event.key)) return;
+                event.preventDefault();
+                void selectScene(index);
+            });
+            card.dataset.sceneIndex = String(index);
+            card.dataset.timelineKey = `scene:${index}`;
+            card.className = `h3studio-card${index === state.active ? " h3studio-selected" : ""}${checkpoint?.ready ? " h3studio-rendered" : ""}${checkpoint?.continuation_stale ? " h3studio-continuation-stale" : ""}${locked ? " h3studio-locked" : ""}`;
+            card.style.setProperty("--scene", automaticSceneColor(index));
+            const segmentIndex = state.timelineSegments.findIndex(
+                (segment) => segment.key === card.dataset.timelineKey,
+            );
+            if (state.timelineWidths[segmentIndex] > 0) {
+                card.style.setProperty(
+                    "--h3-scene-width", `${state.timelineWidths[segmentIndex]}px`,
+                );
+            }
+            updateTimelineCheckpointCard(card, index, result);
+            const sceneSegment = timelineSegment;
+            const usedFrames = Number(sceneSegment?.durationFrames)
+                || Number(row.deliveredFrames) || 0;
+            const copy = element("span", "h3studio-card-copy");
+            copy.append(element("span", "h3studio-card-title", `${index + 1}. ${row.id}`),
+                element("span", "h3studio-card-meta", `${formatClock(sceneSegment?.startSeconds ?? 0)} → ${formatClock(sceneSegment?.endSeconds ?? row.deliveredSeconds)} · ${usedFrames}/${row.deliveredFrames}f used${row.loraRoute === "base" ? "" : ` · LoRA ${row.loraRoute.toUpperCase()}`}`));
+            const dragHandle = element("span", "h3studio-drag-handle", "⋮⋮");
+            dragHandle.title = locked
+                ? "Scene locked · unlock it before moving"
+                : "Move scene on the editorial timeline";
+            enableScenePlacementDrag(card, dragHandle, index);
+            const lockHandle = button(
+                "",
+                locked
+                ? "Unlock scene movement, duration editing, and the saved chapter resolution pin"
+                : "Lock scene movement and duration; saved scenes also pin their chapter resolution",
+                (event) => {
+                    event.preventDefault(); event.stopPropagation();
+                    setSceneLocked(index, !locked);
+                },
+            );
+            lockHandle.className = `h3studio-lock-handle${locked ? " h3studio-is-locked" : ""}`;
+            lockHandle.setAttribute("aria-label", locked ? "Unlock scene" : "Lock scene");
+            const lockIcon = element("span", "h3studio-lock-icon");
+            lockIcon.setAttribute("aria-hidden", "true");
+            lockHandle.append(lockIcon);
+            lockHandle.addEventListener("pointerdown", (event) => event.stopPropagation());
+            const resizeHandle = element("span", "h3studio-resize-handle");
+            if (checkpoint?.ready) {
+                resizeHandle.classList.add("h3studio-latent-trim");
+                enableSceneLatentTrimDrag(card, resizeHandle, index);
+            } else {
+                resizeHandle.title = locked
+                    ? "Scene locked · unlock it before changing its length"
+                    : "Resize generated length · snaps to H3's 17n+5 frame grid";
+                enableSceneDurationDrag(card, resizeHandle, index);
+            }
+            card.append(
+                copy, dragHandle, lockHandle, resizeHandle,
+                element("span", "h3studio-render-dot"),
+            );
+            host.append(card);
+        }
+        appendTimelineGap(host, trailingGapSegment(), true);
+        for (const chapter of orderedChapters(state.plan)) {
+            const index = state.plan.shots.findIndex((shot, offset) => (
+                safeShotId(shot?.id, `clip_${String(offset + 1).padStart(4, "0")}`)
+                    === chapter.start_scene_id
+            ));
+            if (index < 0) continue;
+            const marker = button("", `${chapter.title}, before scene ${index + 1}`, () => {
+                void selectChapter(chapter.id);
+            });
+            marker.className = `h3studio-chapter-marker${state.activeChapterId === chapter.id ? " h3studio-selected" : ""}`;
+            marker.dataset.startSceneIndex = String(index);
+            marker.dataset.chapterId = chapter.id;
+            marker.append(element("span", "", chapter.title));
+            host.append(marker);
+        }
+        renderSourceTimeline();
+        renderSourceAudioTimeline();
+        renderSubtitleTimeline();
+        layoutTimeline({
+            preserveScroll:false,
+            revealActive,
+            restoreScroll:preservedScroll,
+        });
+        state.timelineRenderedActive = state.active;
+    }
+
+    function renderSourceTimeline() {
+        const host = state.sourceTimelineHost;
+        if (!host || !state.plan) return;
+        host.replaceChildren();
+        const result = timing();
+        const available = result.shots.some((_row, index) => sourceScene(index));
+        if (!available) {
+            host.append(element(
+                "div", "h3studio-source-empty",
+                state.sourcePreview
+                    ? "No active path-backed motion reference in this Plan."
+                    : "Queue Plan Studio once to load motion-reference windows.",
+            ));
+            return;
+        }
+        for (const timelineSegment of state.timelineSegments) {
+            if (timelineSegment.kind === "gap") {
+                if (!timelineSegment.trailing) {
+                    appendTimelineGap(host, timelineSegment);
+                }
+                continue;
+            }
+            const index = timelineSegment.sceneIndex;
+            const row = result.shots[index];
+            const scene = sourceScene(index);
+            const reference = scene?.references?.[0] ?? null;
+            const card = button("", reference
+                ? `Scene ${index + 1} source motion @${reference.tag}`
+                : `Scene ${index + 1} has no active path-backed motion reference`,
+            () => void selectScene(index));
+            card.dataset.sceneIndex = String(index);
+            card.dataset.timelineKey = `scene:${index}`;
+            card.className = `h3studio-card h3studio-source-card${index === state.active ? " h3studio-selected" : ""}`;
+            card.style.setProperty("--scene", automaticSceneColor(index));
+            const segmentIndex = state.timelineSegments.findIndex(
+                (segment) => segment.key === card.dataset.timelineKey,
+            );
+            if (state.timelineWidths[segmentIndex] > 0) {
+                card.style.setProperty(
+                    "--h3-scene-width", `${state.timelineWidths[segmentIndex]}px`,
+                );
+            }
+            if (reference && index === state.active && state.view !== "player") {
+                const media = element("video");
+                media.muted = true; media.playsInline = true; media.preload = "metadata";
+                media.src = sourcePreviewUrl(index, reference);
+                media.addEventListener("loadedmetadata", () => {
+                    try { media.currentTime = studioSourceSecond(reference, 0); }
+                    catch (_error) {}
+                }, {once:true});
+                card.append(media);
+            }
+            const copy = element("span", "h3studio-card-copy");
+            copy.append(
+                element("span", "h3studio-card-title", reference
+                    ? `@${reference.tag} · ${reference.start_frame}:${reference.end_frame}`
+                    : "No active @motion"),
+                element("span", "h3studio-card-meta", reference
+                    ? `${reference.frame_count}f source · +${reference.compare_offset_frames}f compare offset`
+                    : `Scene ${index + 1}`),
+            );
+            card.append(copy, element("span", "h3studio-render-dot"));
+            host.append(card);
+        }
+        appendTimelineGap(host, trailingGapSegment());
+    }
+
+    function renderSourceAudioTimeline() {
+        const host = state.sourceAudioTimelineHost;
+        if (!host || !state.plan) return;
+        host.replaceChildren();
+        const audio = sourceAudio();
+        if (!audio) {
+            const descriptor = state.sourcePreview?.source_audio;
+            const message = !state.sourcePreview
+                ? "Queue Plan Studio once to load Source Timeline audio."
+                : descriptor?.timeline_available && !descriptor?.has_audio
+                    ? "Source Timeline connected · no audio."
+                    : descriptor?.timeline_available
+                        ? "Source Timeline audio exists but is not path-backed yet."
+                        : "No Source Timeline is connected.";
+            host.append(element("div", "h3studio-source-empty", message));
+            return;
+        }
+        const result = timing();
+        for (const timelineSegment of state.timelineSegments) {
+            if (timelineSegment.kind === "gap") {
+                if (timelineSegment.trailing) continue;
+                const gap = timelineSegment;
+                const gapCard = element("div", "h3studio-audio-card");
+                gapCard.dataset.timelineKey = gap.key;
+                gapCard.title = `Source song continues through ${formatClock(gap.durationSeconds)} of black video`;
+                const gapSegmentIndex = state.timelineSegments.findIndex(
+                    (segment) => segment.key === gap.key,
+                );
+                if (state.timelineWidths[gapSegmentIndex] > 0) gapCard.style.setProperty(
+                    "--h3-scene-width", `${state.timelineWidths[gapSegmentIndex]}px`,
+                );
+                const gapWaveform = element("canvas", "h3studio-waveform");
+                gapWaveform.style.inset = "3px 4px";
+                gapWaveform.style.width = "calc(100% - 8px)";
+                drawSourceWaveform(
+                    gapWaveform,
+                    studioWaveformIntervalSamples(
+                        state.sourceWaveform, gap.startSeconds,
+                        gap.durationSeconds,
+                    ),
+                    "#9aa5b8", false,
+                );
+                gapCard.append(gapWaveform);
+                host.append(gapCard);
+                continue;
+            }
+            const index = timelineSegment.sceneIndex;
+            const row = result.shots[index];
+            const muted = sourceAudioMuted(index);
+            const card = element(
+                "div",
+                `h3studio-audio-card${index === state.active ? " h3studio-selected" : ""}${muted ? " h3studio-audio-muted" : ""}`,
+            );
+            card.dataset.sceneIndex = String(index);
+            card.dataset.timelineKey = `scene:${index}`;
+            card.title = `Scene ${index + 1} Source Timeline audio${muted ? " (muted)" : ""}`;
+            card.style.setProperty("--scene", automaticSceneColor(index));
+            const segmentIndex = state.timelineSegments.findIndex(
+                (segment) => segment.key === card.dataset.timelineKey,
+            );
+            if (state.timelineWidths[segmentIndex] > 0) {
+                card.style.setProperty(
+                    "--h3-scene-width", `${state.timelineWidths[segmentIndex]}px`,
+                );
+            }
+            card.addEventListener("click", () => void selectScene(index));
+            const canvas = element("canvas", "h3studio-waveform");
+            const sceneSegment = timelineSegment;
+            const samples = studioWaveformIntervalSamples(
+                state.sourceWaveform,
+                sceneSegment?.startSeconds ?? 0,
+                sceneSegment?.durationSeconds ?? row.deliveredSeconds,
+            );
+            drawSourceWaveform(
+                canvas, samples, automaticSceneColor(index), muted,
+            );
+            const mute = button(
+                muted ? "🔇" : "🔊",
+                muted
+                    ? `Unmute source audio for scene ${index + 1}`
+                    : `Mute source audio for scene ${index + 1}`,
+                (event) => {
+                    event.stopPropagation();
+                    setSourceAudioMuted(index, !muted);
+                },
+            );
+            mute.className = "h3studio-audio-mute";
+            card.append(canvas, mute);
+            host.append(card);
+        }
+        const tail = trailingGapSegment();
+        if (tail) {
+            const tailCard = element("div", "h3studio-audio-card");
+            tailCard.dataset.timelineKey = tail.key;
+            tailCard.title = "Source song continues through the open black timeline";
+            const segmentIndex = state.timelineSegments.findIndex(
+                (segment) => segment.key === tail.key,
+            );
+            if (state.timelineWidths[segmentIndex] > 0) tailCard.style.setProperty(
+                "--h3-scene-width", `${state.timelineWidths[segmentIndex]}px`,
+            );
+            const waveform = element("canvas", "h3studio-waveform");
+            waveform.style.inset = "3px 4px";
+            waveform.style.width = "calc(100% - 8px)";
+            drawSourceWaveform(
+                waveform,
+                studioWaveformIntervalSamples(
+                    state.sourceWaveform, tail.startSeconds,
+                    tail.durationSeconds,
+                ),
+                "#9aa5b8", false,
+            );
+            tailCard.append(waveform);
+            host.append(tailCard);
+        }
+        // Resizes, trims and placement edits can change the coverage needed.
+        // The token + URL cache coalesces repeated renders and in-flight loads.
+        void loadSourceWaveform();
+    }
+
+    function renderSubtitleTimeline() {
+        const host = state.subtitleTimelineHost;
+        if (!host) return;
+        host.replaceChildren();
+        const {totalSeconds} = timelineModel();
+        if (!totalSeconds) return;
+        const offset = Number(state.editorial.subtitles?.offset_seconds) || 0;
+        for (const cue of subtitleCues()) {
+            const start = Math.max(0, Number(cue.startSeconds) + offset);
+            const end = Math.min(totalSeconds, Number(cue.endSeconds) + offset);
+            if (!(end > start)) continue;
+            const item = element("div", "h3studio-subtitle-cue", cue.text);
+            item.title = `${formatClock(start)}–${formatClock(end)} · ${cue.text}`;
+            item.style.left = `${start / totalSeconds * 100}%`;
+            item.style.width = `${(end - start) / totalSeconds * 100}%`;
+            host.append(item);
+        }
+    }
+
+    function updateTimelineSelection() {
+        for (const host of [
+            state.timelineHost, state.sourceTimelineHost,
+            state.sourceAudioTimelineHost,
+        ]) {
+            if (!host) continue;
+            [...host.querySelectorAll(".h3studio-card,.h3studio-audio-card")].forEach(
+                (card) => card.classList.toggle(
+                    "h3studio-selected", Number(card.dataset.sceneIndex) === state.active,
+                ),
+            );
+        }
+        for (const marker of state.timelineHost?.querySelectorAll(
+            ".h3studio-chapter-marker",
+        ) ?? []) {
+            marker.classList.toggle(
+                "h3studio-selected",
+                Boolean(state.activeChapterId)
+                    && marker.dataset.chapterId === state.activeChapterId,
+            );
+        }
+    }
+
+    async function selectScene(index, synchronize = true, reveal = true) {
+        if (!state.plan?.shots?.length || !Number.isFinite(Number(index))) return;
+        const requested = Math.max(0, Math.min(state.plan.shots.length - 1, Math.trunc(Number(index))));
+        const selection = {
+            planNode:state.planNode, runName:runName(),
+            sceneId:String(state.plan.shots[requested]?.id ?? ""), index:requested,
+        };
+        state.sceneNavigation = selection;
+        await flushHistoryDraft();
+        // A late history save must not undo a newer click (including an
+        // empty scene) or send that stale selection back to the prompt editor.
+        if (state.disposed || state.sceneNavigation !== selection
+                || state.planNode !== selection.planNode
+                || runName() !== selection.runName) return;
+        state.sceneNavigation = null;
+        const target = selection.sceneId
+                && String(state.plan.shots[selection.index]?.id ?? "") !== selection.sceneId
+            ? state.plan.shots.findIndex(shot => String(shot?.id ?? "") === selection.sceneId)
+            : selection.index;
+        if (!state.plan.shots[target]) return;
+        state.activeChapterId = "";
+        state.active = target;
+        if (state.view === "player") {
+            state.timelinePosition = studioEditorialSceneStartSeconds(
+                timelineModel().segments, state.active,
+            );
+        }
+        persistView(); renderSourceTimeline(); renderSourceAudioTimeline();
+        updateTimelineSelection();
+        if (reveal) revealActiveTimelineScene();
+        if (state.view === "player" && state.player) {
+            seekTimeline(state.timelinePosition, false);
+        } else renderPanel();
+        if (synchronize) publishActiveScene();
+    }
+
+    async function selectChapter(chapterId) {
+        await flushHistoryDraft();
+        const chapter = orderedChapters(state.plan).find(
+            (candidate) => candidate.id === chapterId,
+        );
+        if (!chapter) return;
+        state.activeChapterId = chapter.id;
+        state.view = "scene";
+        persistView();
+        renderToolbarState();
+        renderTimeline();
+        renderPanel();
+    }
+
+    function field(label, control) {
+        const wrap = element("label", "h3studio-field");
+        wrap.append(element("span", "", label), control);
+        return wrap;
+    }
+
+    function renderReferenceTray(tray, textarea) {
+        tray.replaceChildren();
+        const referenceData = availableReferenceRecords(
+            state.planNode ?? node, state.active + 1, {
+                includeInactive: true,
+                prompt: [
+                    sharedPrompt(state.plan).text.trim(), textarea.value.trim(),
+                ].filter(Boolean).join("\n\n"),
+            },
+        );
+        const {wrapper} = referenceData;
+        const records = referenceData.mode === "tagged"
+            ? referenceData.records
+            : referenceData.records.filter((record) => record.active);
+        if (!records.length) {
+            tray.append(element("span", "h3studio-message", wrapper
+                ? `No connected references are active in scene ${state.active + 1}.`
+                : "No downstream Tagged/Scheduled Ref2VA, core Ref2VA, or I2V references were found."));
+            return;
+        }
+        function syntaxFor(record) {
+            const key = `${String(state.plan?.shots?.[state.active]?.id ?? state.active)}:${record.tag}`;
+            const usedMode = referenceData.mode === "tagged" && record.supportsSemantic
+                ? taggedPictureReferenceMode(textarea.value, record.tag) : "native";
+            return {
+                key,
+                usedMode,
+                syntax:["native", "semantic"].includes(usedMode)
+                    ? usedMode : state.referenceSyntax.get(key) ?? "native",
+            };
+        }
+        const preview = element("div", "h3studio-ref-preview");
+        function show(record) {
+            preview.replaceChildren();
+            const kind = record.kind === "picture" ? "image" : record.kind;
+            const url = record.previewUrl
+                ? api.apiURL(record.previewUrl)
+                : findMediaPreview(record.source, kind);
+            if (url) {
+                const media = element(kind === "image" ? "img" : kind);
+                media.src = url;
+                if (kind !== "image") { media.controls = true; media.preload = "metadata"; }
+                preview.append(media);
+            }
+            const {syntax} = syntaxFor(record);
+            const displayToken = syntax === "semantic"
+                ? taggedPictureReferenceToken(record.tag, "semantic")
+                : record.token;
+            preview.append(element("div", "", `${displayToken}${record.label && record.label !== record.token ? ` → ${record.label}` : ""}\n${record.kind} · ${record.selector === "prompt tag" ? "insert to activate" : `scenes ${record.selector}`}`));
+        }
+        const icons = {picture:"▧",video:"▶",audio:"♫"};
+        for (const record of records) {
+            const {key, usedMode, syntax} = syntaxFor(record);
+            const displayToken = syntax === "semantic"
+                ? taggedPictureReferenceToken(record.tag, "semantic")
+                : record.token;
+            const entry = element("div", "h3studio-ref-entry");
+            const chip = button(`${icons[record.kind] ?? "@"} ${displayToken}`, "Insert this connected reference label or alias", () => {
+                const start = textarea.selectionStart ?? textarea.value.length;
+                insertText(textarea, displayToken);
+                if (syntax === "semantic" && displayToken.includes("[")
+                        && displayToken.includes("s]")) {
+                    textarea.setSelectionRange(
+                        start + displayToken.indexOf("[") + 1,
+                        start + displayToken.lastIndexOf("s]"),
+                    );
+                }
+                tray.classList.remove("h3studio-open");
+            });
+            chip.addEventListener("mouseenter", () => show(record));
+            chip.addEventListener("focus", () => show(record));
+            entry.append(chip);
+            if (referenceData.mode === "tagged" && record.supportsSemantic) {
+                const modes = element("div", "h3studio-ref-mode");
+                for (const [target, label] of [["native", "@"], ["semantic", "#"]]) {
+                    const control = button(
+                        label,
+                        target === "native"
+                            ? "Use native @tag and convert semantic anchors in this scene"
+                            : "Use untimed Qwen-only #tag; add [time] for placement",
+                        () => {
+                            state.referenceSyntax.set(key, target);
+                            const next = convertTaggedPictureReference(
+                                textarea.value, record.tag, target,
+                            );
+                            if (next !== textarea.value) {
+                                textarea.value = next;
+                                textarea.dispatchEvent(new InputEvent("input", {
+                                    bubbles:true, inputType:"insertReplacementText",
+                                }));
+                            }
+                            renderReferenceTray(tray, textarea);
+                        },
+                    );
+                    control.classList.toggle(
+                        "h3studio-selected",
+                        syntax === target || usedMode === "mixed",
+                    );
+                    modes.append(control);
+                }
+                entry.append(modes);
+            }
+            tray.append(entry);
+        }
+        tray.append(preview); show(records[0]);
+    }
+
+    function renderScenePanel() {
+        const shot = state.plan.shots[state.active];
+        const row = timing().shots[state.active];
+        const checkpoint = matchingStudioCheckpoint(
+            state.checkpoints, state.active, row,
+        );
+        const activeTrim = trimForScene(state.active);
+        const usedFrames = Number(activeTrim?.out_frame)
+            || Number(row.deliveredFrames) || 0;
+        const timelineLocked = sceneLocked(state.active);
+        const panel = element("div");
+        const head = element("div", "h3studio-scene-head");
+        const editorialStart = studioEditorialSceneStartSeconds(
+            timelineModel().segments, state.active,
+        );
+        head.append(element("strong", "", `Scene ${state.active + 1} of ${state.plan.shots.length}`),
+            element("span", "h3studio-scene-label", `${row.rawFrames || "—"} raw · ${usedFrames}/${row.deliveredFrames || "—"} used · ${row.videoBlendFrames}f incoming blend · generation ${formatClock(row.generationStartFrame / 24)} · editorial ${formatClock(editorialStart)}`));
+        if (checkpoint?.continuation_stale) head.append(element(
+            "span", "h3studio-error",
+            `Regenerate this scene: ${checkpoint.continuation_stale_reason}. Its saved media still plays, but it was generated from the previous cut endpoint.`,
+        ));
+        const grid = h3StudioGridMarkers(
+            row.rawFrames, row.contextLength, row.continuationMode,
+            row.preservesGeneratedAudioPrefix,
+        );
+        const gridMarkers = element("span", "h3studio-grid-markers");
+        const rawGrid = element(
+            "span",
+            `h3studio-grid-marker ${grid.raw.onGrid
+                ? "h3studio-grid-exact" : "h3studio-grid-warning"}`,
+            grid.raw.label,
+        );
+        rawGrid.title = grid.raw.onGrid
+            ? "Raw generation length is on H3's 17n+5 temporal latent grid."
+            : "Raw generation length is off H3's 17n+5 temporal latent grid.";
+        gridMarkers.append(rawGrid);
+        if (grid.av) {
+            const avGrid = element(
+                "span",
+                `h3studio-grid-marker ${grid.av.exact
+                    ? "h3studio-grid-exact" : "h3studio-grid-warning"}`,
+                grid.av.label,
+            );
+            avGrid.title = grid.av.exact
+                ? (grid.av.audioPreserved
+                    ? "The AV context ends on both H3's video latent grid and its 40 Hz audio grid."
+                    : "Valid video-only AV context. Generated predecessor audio is not carried, so the 40 Hz audio grid does not constrain this test.")
+                : "This AV context is invalid because carried predecessor audio ends between 40 Hz ticks. Exact aligned choices are 39, 90, 141, 192, … frames.";
+            gridMarkers.append(avGrid);
+        }
+        if (grid.cut) {
+            const cut = element(
+                "span",
+                "h3studio-grid-marker h3studio-grid-experimental",
+                grid.cut.label,
+            );
+            cut.title = "Experimental only: nearest reported four-frame 17n−3 cut window for generated-to-real joins. This does not change or validate the Plan.";
+            gridMarkers.append(cut);
+        }
+        head.append(gridMarkers);
+
+        const id = element("input");
+        id.value = shot.id ?? "";
+        id.addEventListener("change", () => {
+            preserveDelegatedPrompts();
+            let renamed;
+            try {
+                renamed = renamePlanShot(state.plan, state.active, id.value);
+                id.setCustomValidity("");
+            } catch (error) {
+                id.value = safeShotId(shot.id, row.id);
+                id.setCustomValidity(error?.message || String(error));
+                id.reportValidity();
+                return;
+            }
+            const previousId = renamed.previousId;
+            shot.id = renamed.id; id.value = renamed.id;
+            remapStudioEditorialSceneId(
+                state.editorial, previousId, renamed.id,
+            );
+            writePlan(); renderShell();
+        });
+        const mode = element("select");
+        for (const [value,label] of [["default","Plan default"],["seconds","Seconds"],["frames","Exact frames"]]) {
+            const option = element("option", "", label); option.value = value; mode.append(option);
+        }
+        const length = element("input"); length.type = "number";
+        function refreshLength() {
+            const selected = shotLengthMode(shot); mode.value = selected;
+            mode.disabled = timelineLocked;
+            length.disabled = timelineLocked || selected === "default";
+            if (selected === "seconds") { length.value = shot.duration_seconds ?? ""; length.min = ".01"; length.max = String(3592 / 24); length.step = ".01"; }
+            else if (selected === "frames") { length.value = shot.length ?? shot.frames ?? ""; length.min = "5"; length.max = "3592"; length.step = "17"; }
+            else length.value = "";
+        }
+        mode.addEventListener("change", () => {
+            setShotLengthMode(shot, mode.value, settings().defaultDurationSeconds);
+            refreshLength(); writePlan(); renderShell();
+        });
+        length.addEventListener("change", () => {
+            if (mode.value === "seconds") shot.duration_seconds = Number(length.value);
+            if (mode.value === "frames") { shot.length = Number(length.value); delete shot.frames; }
+            writePlan(); renderShell();
+        });
+        refreshLength();
+        const lengthControl = element("span", "h3studio-length h3studio-duration"); lengthControl.append(mode, length);
+        const steps = element("input"); steps.type = "number"; steps.min = "1"; steps.max = "10000";
+        steps.placeholder = String(settings().defaultSteps); steps.value = shot.steps ?? "";
+        steps.addEventListener("change", () => { if (steps.value) shot.steps = Number(steps.value); else delete shot.steps; writePlan(); });
+        const promptSeedMode = element("select");
+        for (const [value, label] of [
+            ["inherit", "Stable derived"],
+            ["fixed", "Fixed scene seed"],
+            ["randomize", "Randomize each queue"],
+        ]) {
+            const option = element("option", "", label);
+            option.value = value;
+            promptSeedMode.append(option);
+        }
+        const promptSeed = element("input");
+        promptSeed.type = "text";
+        promptSeed.inputMode = "numeric";
+        promptSeed.placeholder = "Prompt seed";
+        const promptSeedWrap = element("span", "h3studio-prompt-seed");
+        const rerollPromptSeed = button(
+            "↻", "Store a new fixed prompt-alternative seed for this scene",
+            () => {
+                shot.prompt_seed_mode = "fixed";
+                shot.prompt_seed = randomSceneSeed();
+                refreshPromptSeed();
+                writePlan();
+            },
+        );
+        function refreshPromptSeed() {
+            const selected = scenePromptSeedMode(shot);
+            promptSeedMode.value = selected;
+            promptSeed.disabled = selected !== "fixed";
+            rerollPromptSeed.disabled = selected !== "fixed";
+            promptSeed.value = selected === "fixed" ? (shot.prompt_seed ?? "") : "";
+            promptSeedWrap.title = selected === "inherit"
+                ? "Derive a stable seed from this scene's index and ID for its {one|two} choices."
+                : selected === "randomize"
+                    ? "Choose fresh prompt alternatives whenever this Plan is queued; the exact choice seed is saved with the checkpoint."
+                    : "Exact uint64 seed for this scene's prompt alternatives. This does not change sampler noise.";
+        }
+        promptSeedMode.addEventListener("change", () => {
+            setScenePromptSeedMode(shot, promptSeedMode.value);
+            refreshPromptSeed();
+            writePlan();
+            renderStatus();
+        });
+        promptSeed.addEventListener("change", () => {
+            if (promptSeed.value.trim()) shot.prompt_seed = promptSeed.value.trim();
+            else shot.prompt_seed = randomSceneSeed();
+            setScenePromptSeedMode(shot, "fixed");
+            refreshPromptSeed();
+            writePlan();
+        });
+        promptSeedWrap.append(promptSeedMode, promptSeed, rerollPromptSeed);
+        refreshPromptSeed();
+        const seed = element("input"); seed.type = "text"; seed.inputMode = "numeric"; seed.placeholder = "Stable derived seed"; seed.value = shot.seed ?? "";
+        seed.addEventListener("change", () => { if (seed.value.trim()) shot.seed = seed.value.trim(); else delete shot.seed; writePlan(); });
+        const seedWrap = element("span", "h3studio-length");
+        const reroll = button("↻", "Store a new random seed for this scene", () => { seed.value = randomSceneSeed(); shot.seed = seed.value; writePlan(); });
+        seedWrap.append(seed, reroll);
+        const loraRoute = element("select");
+        const selectedLoRARoute = sceneLoRARoute(shot);
+        for (const route of availableLoRARoutes(
+            node.graph ?? app.graph,
+            [node, state.planNode],
+            selectedLoRARoute,
+        )) {
+            const option = element("option", "", loraRouteLabel(route));
+            option.value = route;
+            loraRoute.append(option);
+        }
+        loraRoute.value = selectedLoRARoute;
+        loraRoute.title = "Select Base or a connected A-Z MODEL branch on MiniMax H3 Scene LoRA Scheduler. Connecting its last empty route reveals the next one automatically; branches come from ordinary ComfyUI LoRA loaders.";
+        loraRoute.addEventListener("change", () => {
+            if (loraRoute.value === "base") delete shot.lora_route;
+            else shot.lora_route = loraRoute.value;
+            sceneLoRARoute(shot);
+            writePlan();
+            renderTimeline();
+        });
+        const planSettings = settings();
+        function normalizeVisualLeadSpan() {
+            if (!Object.hasOwn(shot, "visual_context_lead_source")) return;
+            const resolved = sceneContextLength(
+                shot, planSettings.contextLength,
+            );
+            const allowed = visualContextCompositions()
+                .filter((choice) => choice.total === resolved)
+                .map((choice) => choice.lead);
+            if (!allowed.length) {
+                delete shot.visual_context_lead_source;
+                delete shot.visual_context_lead_frames;
+                delete shot.visual_context_lead_start_frame;
+                return;
+            }
+            try {
+                sceneVisualContextLeadFrames(shot, resolved);
+            } catch (_error) {
+                shot.visual_context_lead_frames = allowed[0];
+            }
+        }
+        const incomingTransition = element("select");
+        const inheritOption = element(
+            "option", "",
+            `Inherit Chain Policy · ${transitionPresetLabel(planSettings.transitionPreset)}`,
+        );
+        inheritOption.value = "inherit";
+        incomingTransition.append(inheritOption);
+        for (const preset of primaryTransitionOptions()) {
+            const option = element(
+                "option", "", `${preset.label} · ${preset.description}`,
+            );
+            option.value = preset.name;
+            incomingTransition.append(option);
+        }
+        function refreshIncomingTransition() {
+            const selected = sceneTransitionPreset(
+                shot, planSettings.continuationMode,
+                planSettings.contextLength,
+                planSettings.audioContextLength,
+            );
+            let custom = incomingTransition.querySelector(
+                'option[value="custom"]',
+            );
+            if (selected === "custom" && !custom) {
+                custom = element(
+                    "option", "", transitionPresetLabel("custom"),
+                );
+                custom.value = "custom";
+                incomingTransition.append(custom);
+            }
+            incomingTransition.value = selected;
+        }
+        refreshIncomingTransition();
+        incomingTransition.title = "One semantic boundary choice. Inherit "
+            + "uses the connected Chain Policy. A preset writes its tested "
+            + "visual implementation/context pair and restores automatic "
+            + "generated-audio context. Custom means raw Advanced "
+            + "overrides remain below.";
+        incomingTransition.addEventListener("change", () => {
+            if (incomingTransition.value === "custom") return;
+            applySceneTransitionPreset(shot, incomingTransition.value);
+            const nextContext = sceneContextLength(
+                shot, planSettings.contextLength,
+            );
+            if (Object.hasOwn(shot, "video_blend_frames")
+                    && Number(shot.video_blend_frames) > nextContext) {
+                shot.video_blend_frames = nextContext;
+            }
+            normalizeVisualLeadSpan();
+            delete shot.visual_context_start_frame;
+            delete shot.visual_context_lead_start_frame;
+            if (Array.isArray(shot.visual_context_blocks)) {
+                if (nextContext <= 0) {
+                    delete shot.visual_context_blocks;
+                    writePlan();
+                    renderShell();
+                    return;
+                }
+                const sources = shot.visual_context_blocks.map(
+                    (block) => String(block?.source ?? ""),
+                );
+                const count = Math.min(
+                    Math.max(1, sources.length),
+                    visualContextMaximumBlocks(nextContext),
+                );
+                const partition = visualContextDefaultPartition(
+                    nextContext, count,
+                );
+                shot.visual_context_blocks = partition.map(
+                    (frames, offset) => ({
+                        source:sources[offset] ?? sources.at(-1)
+                            ?? safeShotId(
+                                state.plan.shots[state.active - 1]?.id,
+                                `clip_${String(state.active).padStart(4, "0")}`,
+                            ),
+                        frames,
+                    }),
+                );
+                shot.video_blend_frames = 0;
+            }
+            writePlan();
+            renderShell();
+        });
+        const blendFrames = element("input");
+        blendFrames.type = "number";
+        blendFrames.min = "0";
+        blendFrames.step = "1";
+        blendFrames.value = shot.video_blend_frames ?? "";
+        function refreshBlendControl() {
+            const resolvedContext = sceneContextLength(
+                shot, settings().contextLength,
+            );
+            blendFrames.max = String(resolvedContext);
+            blendFrames.placeholder = String(Math.min(
+                Number(settings().videoBlendFrames), resolvedContext,
+            ));
+        }
+        refreshBlendControl();
+        blendFrames.title = state.active === 0
+            ? "Assembly blend entering scene 1 when Existing Video Context is present. Blank inherits the Plan default, capped to scene context."
+            : "Assembly blend from the previous scene into this scene. Blank inherits the Plan default, capped to scene context; zero is a hard cut. It does not change diffusion.";
+        blendFrames.addEventListener("change", () => {
+            if (blendFrames.value === "") delete shot.video_blend_frames;
+            else shot.video_blend_frames = Number(blendFrames.value);
+            sceneVideoBlendFrames(
+                shot, settings().videoBlendFrames,
+                sceneContextLength(shot, settings().contextLength),
+            );
+            writePlan();
+            renderStatus();
+        });
+        const placement = placementForScene(state.active);
+        const editorialScene = timelineModel().segments.find(
+            (segment) => segment.kind === "scene"
+                && segment.sceneIndex === state.active,
+        );
+        const sceneStart = element("input");
+        sceneStart.type = "text";
+        sceneStart.inputMode = "decimal";
+        sceneStart.value = placement
+            ? formatClock(Number(placement.start_frame) / FPS) : "";
+        sceneStart.placeholder = `Auto · ${formatClock(editorialScene?.startSeconds ?? 0)}`;
+        sceneStart.title = "Editorial-only position. Enter seconds, M:SS, or H:MM:SS. Scenes are resolved by their requested positions; uncovered time becomes black. This may reorder playback, but never changes generation, checkpoints, or branch lineage.";
+        const resetStart = button(
+            "Auto", "Use this scene's natural packed Plan position",
+            () => setScenePlacement(state.active, null),
+        );
+        sceneStart.disabled = timelineLocked;
+        resetStart.disabled = timelineLocked;
+        if (timelineLocked) {
+            sceneStart.title = "Scene locked · unlock it from the timeline before moving it.";
+        }
+        sceneStart.addEventListener("change", () => {
+            try {
+                const seconds = parseStudioTimecode(sceneStart.value);
+                setScenePlacement(
+                    state.active,
+                    seconds == null ? null : Math.round(seconds * FPS),
+                );
+            } catch (error) {
+                sceneStart.setCustomValidity(error.message);
+                sceneStart.reportValidity();
+                sceneStart.value = placement
+                    ? formatClock(Number(placement.start_frame) / FPS) : "";
+            }
+        });
+        sceneStart.addEventListener(
+            "input", () => sceneStart.setCustomValidity(""),
+        );
+        const sceneStartWrap = element("span", "h3studio-length");
+        sceneStartWrap.append(sceneStart, resetStart);
+        const usedEnd = element("select");
+        for (const frame of studioLatentSafeOutFrames(
+            row.rawFrames, row.deliveredFrames,
+        )) {
+            const option = element(
+                "option", "",
+                frame === Number(row.deliveredFrames)
+                    ? `Full · ${frame}f · ${formatClock(frame / FPS)}`
+                    : `${frame}f · ${formatClock(frame / FPS)}`,
+            );
+            option.value = String(frame);
+            usedEnd.append(option);
+        }
+        usedEnd.value = String(usedFrames);
+        usedEnd.disabled = !checkpoint?.ready || timelineLocked;
+        usedEnd.title = checkpoint?.ready
+            ? "Non-destructive editorial endpoint. Only boundaries shared by the sampled H3 video latent and delivered 40 Hz audio grid are offered. The full checkpoint remains available, while assembly and the next scene use this endpoint."
+            : "Generate this scene first; latent-safe endpoint editing uses its saved checkpoint.";
+        usedEnd.addEventListener("change", () => {
+            setSceneTrim(state.active, Number(usedEnd.value));
+        });
+        const resetUsedEnd = button(
+            "Full", "Use the complete generated checkpoint",
+            () => setSceneTrim(state.active, row.deliveredFrames),
+        );
+        resetUsedEnd.disabled = !checkpoint?.ready || timelineLocked
+            || usedFrames === Number(row.deliveredFrames);
+        const usedEndWrap = element("span", "h3studio-length");
+        usedEndWrap.append(usedEnd, resetUsedEnd);
+        const sceneLockControl = button(
+            timelineLocked ? "Unlock scene" : "Lock scene",
+            timelineLocked
+                ? "Allow this scene to be moved, resized, or reordered; release its saved chapter resolution pin"
+                : "Protect timeline movement, resizing, and reordering; pin this chapter to the scene's saved resolution",
+            () => setSceneLocked(state.active, !timelineLocked),
+        );
+        const form = element("div", "h3studio-form");
+        form.append(
+            field("Scene ID", id), field("Length", lengthControl),
+            field("Steps", steps),
+            field("Prompt alternatives", promptSeedWrap),
+            field("Seed", seedWrap),
+            field("LoRA route", loraRoute),
+            field("Timeline lock", sceneLockControl),
+            field("Editorial start", sceneStartWrap),
+            field("Latent-safe used end", usedEndWrap),
+            field("Incoming transition", incomingTransition),
+            field("Final assembly crossfade frames", blendFrames),
+        );
+        const planAudioPolicy = settings().audioPolicy;
+        const effectiveAudioPolicy = sceneAudioPolicy(shot, planAudioPolicy);
+        const lipSync = element("select");
+        for (const [value, label] of [
+            ["inherit", `Inherit · ${planAudioPolicy.sourceAudioTarget === "locked" ? "On" : "Off"}`],
+            ["on", "On · vocals drive this scene"],
+            ["off", "Off · action / no source-audio guidance"],
+            ["custom", "Custom · advanced audio controls"],
+        ]) {
+            const option = element("option", "", label);
+            option.value = value; option.disabled = value === "custom";
+            lipSync.append(option);
+        }
+        lipSync.value = sceneLipSyncMode(shot);
+        lipSync.title = "Scene-local source lip-sync, not a mouth-motion guarantee. "
+            + "On uses grouped vocals, or the legacy single source. Off disables "
+            + "source locking, source reference, and generated-audio carry. "
+            + "Final soundtrack stays unchanged. Inherit resets these three overrides.";
+        lipSync.addEventListener("change", () => {
+            applySceneLipSync(shot, lipSync.value);
+            writePlan();
+            renderScenePanel();
+            renderStatus();
+        });
+        form.append(field("Lip-sync", lipSync));
+        function audioOverrideSelect(key, inherited, choices, title) {
+            const select = element("select");
+            const inheritedOption = element(
+                "option", "", `Inherit Chain Policy · ${inherited}`,
+            );
+            inheritedOption.value = "inherit";
+            select.append(inheritedOption);
+            for (const [value, label] of choices) {
+                const option = element("option", "", label);
+                option.value = value;
+                select.append(option);
+            }
+            select.value = sceneAudioOverride(shot, key);
+            select.title = title;
+            select.addEventListener("change", () => {
+                applySceneAudioOverride(shot, key, select.value);
+                lipSync.value = sceneLipSyncMode(shot);
+                writePlan();
+                renderStatus();
+            });
+            return select;
+        }
+        const sourceReference = audioOverrideSelect(
+            "source_reference",
+            planAudioPolicy.sourceReference ?? effectiveAudioPolicy.sourceReference,
+            [["on", "On · source window as Ref2VA audio"],
+             ["off", "Off · no source audio reference"]],
+            "Scene-local source-audio reference. It does not choose final "
+                + "soundtrack; Lock source audio wins over this switch.",
+        );
+        const generatedContinuity = audioOverrideSelect(
+            "generated_continuity",
+            planAudioPolicy.generatedContinuity
+                ?? effectiveAudioPolicy.generatedContinuity,
+            [["on", "On · continue prior generated audio"],
+             ["off", "Off · independent generated audio"]],
+            "Scene-local predecessor generated-audio carry. Lock source audio "
+                + "wins over this switch.",
+        );
+        const inheritedLock = (planAudioPolicy.sourceAudioTarget ?? "off")
+            === "locked" ? "on" : "off";
+        const lockSourceAudio = audioOverrideSelect(
+            "source_audio_target", inheritedLock,
+            [["locked", "On · protect exact source window"],
+             ["off", "Off · target remains denoisable"]],
+            "Locks this scene's exact source waveform into the target audio "
+                + "latent. Source reference and generated continuity become "
+                + "effectively off; final soundtrack stays global.",
+        );
+        const audioOverrides = element("div", "h3studio-audio-overrides");
+        audioOverrides.append(
+            field("Source reference", sourceReference),
+            field("Generated continuity", generatedContinuity),
+            field("Lock source audio", lockSourceAudio),
+        );
+        function alternateTakePanel() {
+            const section = element("section", "h3studio-alternate");
+            const title = element("div", "h3studio-alternate-title");
+            title.append(
+                element("strong", "", "Alternate final-cut take"),
+                element("span", "h3studio-grid-marker h3studio-grid-experimental",
+                    "Picture only"),
+            );
+            section.append(title, element(
+                "div", "h3studio-hint",
+                "Regenerate this scene with a small prompt change without replacing its generation checkpoint. Later scenes keep depending on the original take; preview and final assembly use the accepted alternate picture with the original audio.",
+            ));
+            if (!checkpoint?.ready) {
+                section.append(element(
+                    "div", "h3studio-message",
+                    "Generate and accept the original scene before creating an alternate.",
+                ));
+                return section;
+            }
+            const sceneId = String(row.id);
+            const baseRevision = String(checkpoint.revision ?? "");
+            const draft = state.editorial.alternate_draft;
+            const thisDraft = draft
+                && draft.scene_id === sceneId
+                && draft.base_revision === baseRevision ? draft : null;
+            const selected = state.editorial.replacements.find(
+                (item) => item.scene_id === sceneId
+                    && item.base_revision === baseRevision,
+            ) ?? null;
+            const select = element("select");
+            const original = element("option", "", `Original · ${baseRevision.slice(0, 8)}`);
+            original.value = ""; select.append(original);
+            for (const alternate of checkpoint.alternates ?? []) {
+                if (!alternate.ready || alternate.base_revision !== baseRevision) continue;
+                const option = element(
+                    "option", "",
+                    `ALT ${String(alternate.revision).slice(0, 8)} · seed ${alternate.seed || "?"}`,
+                );
+                option.value = String(alternate.revision);
+                option.title = String(alternate.prompt ?? "");
+                select.append(option);
+            }
+            select.value = selected?.alternate_revision ?? "";
+            select.title = "Choose the picture shown in Plan Studio and final assembly. This never changes the active checkpoint used by following scenes.";
+            select.addEventListener("change", () => {
+                state.editorial.replacements = state.editorial.replacements.filter(
+                    (item) => item.scene_id !== sceneId,
+                );
+                if (select.value) state.editorial.replacements.push({
+                    scene:state.active + 1, scene_id:sceneId,
+                    base_revision:baseRevision,
+                    alternate_revision:select.value,
+                    media_mode:"picture_only",
+                });
+                // Choosing presentation media is never a generation command.
+                // Disarm any draft for this scene and flush the hidden queue
+                // widget immediately so a saved ALT cannot retarget Loop Start.
+                if (state.editorial.alternate_draft?.scene_id === sceneId) {
+                    state.editorial.alternate_draft = null;
+                }
+                scheduleEditorialSave(0);
+                renderShell();
+            });
+            section.append(field("Used in final cut", select));
+
+            const enabled = element("input"); enabled.type = "checkbox";
+            enabled.checked = Boolean(thisDraft?.enabled);
+            enabled.title = "When enabled, the next queued execution generates only this scene as an immutable alternate. The original active checkpoint remains untouched.";
+            const enabledLabel = element("label", "h3studio-alternate-enable");
+            enabledLabel.append(enabled, document.createTextNode(
+                " Generate a prompt-word alternate on the next queue",
+            ));
+            section.append(enabledLabel);
+            const editor = element("textarea", "h3studio-prompt h3studio-alternate-prompt");
+            const basePrompt = promptValueToText(
+                shot.prompt, `Scene ${state.active + 1} prompt`,
+            );
+            editor.value = thisDraft?.prompt ?? basePrompt;
+            editor.disabled = !enabled.checked;
+            editor.spellcheck = true;
+            editor.placeholder = "Change only the words needed for this alternate…";
+            const altSeed = element("input");
+            altSeed.type = "text"; altSeed.inputMode = "numeric";
+            altSeed.value = String(thisDraft?.seed ?? shot.seed ?? row.seed ?? 0);
+            altSeed.disabled = !enabled.checked;
+            const diff = element("div", "h3studio-alternate-diff");
+            const refreshDiff = () => {
+                const before = basePrompt.trim().split(/\s+/);
+                const after = editor.value.trim().split(/\s+/);
+                let prefix = 0;
+                while (prefix < before.length && prefix < after.length
+                        && before[prefix] === after[prefix]) prefix += 1;
+                let suffix = 0;
+                while (suffix < before.length - prefix
+                        && suffix < after.length - prefix
+                        && before[before.length - 1 - suffix]
+                            === after[after.length - 1 - suffix]) suffix += 1;
+                const removed = before.slice(prefix, before.length - suffix).join(" ");
+                const added = after.slice(prefix, after.length - suffix).join(" ");
+                diff.textContent = removed || added
+                    ? `Prompt change: “${removed || "∅"}” → “${added || "∅"}”`
+                    : "Prompt is unchanged from the original take.";
+            };
+            const storeDraft = () => {
+                if (!enabled.checked) return;
+                let seedValue;
+                try {
+                    const parsed = BigInt(altSeed.value.trim() || "0");
+                    if (parsed < 0n || parsed > MAX_SEED) throw new Error();
+                    seedValue = parsed.toString();
+                } catch (_error) {
+                    altSeed.setCustomValidity("Seed must be an unsigned 64-bit integer.");
+                    return;
+                }
+                altSeed.setCustomValidity("");
+                state.editorial.alternate_draft = {
+                    enabled:true, scene:state.active + 1, scene_id:sceneId,
+                    base_revision:baseRevision, prompt:editor.value.trim(),
+                    seed:seedValue, media_mode:"picture_only",
+                };
+                scheduleEditorialSave();
+            };
+            enabled.addEventListener("change", () => {
+                editor.disabled = !enabled.checked;
+                altSeed.disabled = !enabled.checked;
+                if (enabled.checked) {
+                    storeDraft();
+                    scheduleEditorialSave(0);
+                }
+                else if (thisDraft || state.editorial.alternate_draft?.scene_id === sceneId) {
+                    state.editorial.alternate_draft = null;
+                    scheduleEditorialSave(0);
+                }
+                refreshDiff();
+            });
+            editor.addEventListener("input", () => {
+                refreshDiff(); storeDraft();
+            });
+            altSeed.addEventListener("change", storeDraft);
+            refreshDiff();
+            const draftForm = element("div", "h3studio-alternate-grid");
+            draftForm.append(field("Alternate prompt", editor), field("Seed", altSeed));
+            section.append(draftForm, diff, element(
+                "div", "h3studio-message",
+                enabled.checked
+                    ? `Ready: queue normally; Loop Start will render only scene ${state.active + 1}. Review acceptance selects it for the final cut.`
+                    : "Enable only while you are ready to queue the alternate.",
+            ));
+            return section;
+        }
+        const alternate = alternateTakePanel();
+
+        if (state.promptEditors.length) {
+            const delegated = element("div", "h3studio-prompt-delegated");
+            delegated.append(
+                element("strong", "", `Prompt editing delegated to ${promptEditorLabel()}`),
+                document.createTextNode(
+                    "Use the linked editor for prompt text and revision history. " +
+                    "Scene selection is synchronized in both directions; Studio keeps scene ID, length, steps, seed, timeline, and playback controls.",
+                ),
+            );
+            panel.append(head, form, audioOverrides, alternate, delegated);
+            return panel;
+        }
+
+        const prompt = element("textarea", "h3studio-prompt");
+        prompt.value = promptValueToText(shot.prompt, `Scene ${state.active + 1} prompt`);
+        prompt.placeholder = "Write this scene's action, camera, performance, dialogue, sound, and ending continuity…";
+        prompt.spellcheck = true;
+        const message = element("span", "h3studio-message", "Synchronized with Plan");
+        prompt.addEventListener("input", () => {
+            shot.prompt = promptTextToLines(prompt.value); writePlan(message);
+            scheduleHistoryDraft(row.id, prompt.value);
+        });
+        prompt.addEventListener("keydown", (event) => {
+            if (event.altKey && event.key === "ArrowLeft") { event.preventDefault(); void selectScene(state.active - 1); }
+            else if (event.altKey && event.key === "ArrowRight") { event.preventDefault(); void selectScene(state.active + 1); }
+            else if (!event.ctrlKey && !event.metaKey && !event.altKey && event.key === "#") { event.preventDefault(); insertDialogue(prompt); }
+        });
+        const tools = element("div", "h3studio-prompt-tools");
+        const tray = element("div", "h3studio-refs");
+        tools.append(
+            button("@ Reference", "Show connected reference tags and previews", () => {
+                const opening = !tray.classList.contains("h3studio-open");
+                if (opening) renderReferenceTray(tray, prompt); tray.classList.toggle("h3studio-open", opening);
+            }),
+            button("# Dialogue", "Wrap the selected text in <d> dialogue tags", () => insertDialogue(prompt)),
+            element("span", "h3studio-hint", "Alt+←/→ scenes"), message,
+        );
+        const history = element("div", "h3studio-history");
+        state.history.host = history; state.history.textarea = prompt; state.history.status = message;
+        panel.append(
+            head, form, audioOverrides, alternate, prompt, tools, tray, history,
+        );
+        void loadHistory(row.id, prompt.value);
+        return panel;
+    }
+
+    function renderChapterPanel() {
+        const chapter = orderedChapters(state.plan).find(
+            (candidate) => candidate.id === state.activeChapterId,
+        );
+        if (!chapter) {
+            state.activeChapterId = "";
+            return renderScenePanel();
+        }
+        const chapterIndex = state.plan.shots.findIndex((shot, offset) => (
+            safeShotId(shot?.id, `clip_${String(offset + 1).padStart(4, "0")}`)
+                === chapter.start_scene_id
+        ));
+        const panel = element("div");
+        const head = element("div", "h3studio-scene-head");
+        head.append(
+            element("strong", "", chapter.title),
+            element(
+                "span", "h3studio-scene-label",
+                `starts before scene ${chapterIndex + 1} · chapter settings and notes`,
+            ),
+        );
+        const title = element("input");
+        title.value = chapter.title;
+        title.maxLength = 160;
+        title.addEventListener("input", () => {
+            chapter.title = title.value.slice(0, 160) || "Untitled chapter";
+            writePlan(); renderTimeline();
+        });
+        const boundary = element("select");
+        state.plan.shots.forEach((shot, index) => {
+            const sceneId = safeShotId(
+                shot?.id, `clip_${String(index + 1).padStart(4, "0")}`,
+            );
+            const option = element("option", "", `Before scene ${index + 1} · ${sceneId}`);
+            option.value = sceneId;
+            boundary.append(option);
+        });
+        boundary.value = chapter.start_scene_id;
+        boundary.addEventListener("change", () => {
+            const occupied = (state.plan.chapters ?? []).some(
+                (candidate) => candidate !== chapter
+                    && candidate.start_scene_id === boundary.value,
+            );
+            if (occupied) {
+                boundary.value = chapter.start_scene_id;
+                return;
+            }
+            chapter.start_scene_id = boundary.value;
+            writePlan(); renderTimeline();
+        });
+        const form = element("div", "h3studio-chapter-settings");
+        form.append(field("Chapter title", title), field("Timeline marker", boundary));
+        const resolutionMode = element("select");
+        for (const [value, text] of [["inherit", "Inherit from Plan"], ["custom", "Chapter resolution"]]) {
+            const option = element("option", "", text); option.value = value;
+            resolutionMode.append(option);
+        }
+        resolutionMode.value = chapter.resolution ? "custom" : "inherit";
+        const resolutionFields = {};
+        const resolutionStatus = element("span", "h3studio-message");
+        for (const key of ["width", "height"]) {
+            const input = element("input"); input.type = "number";
+            input.min = "32"; input.max = "16384"; input.step = "32";
+            input.value = String(chapter.resolution?.[key]
+                ?? widget(state.planOwner ?? node, key)?.value ?? (key === "width" ? 960 : 544));
+            input.disabled = resolutionMode.value === "inherit";
+            resolutionFields[key] = input;
+            input.addEventListener("change", () => {
+                try {
+                    chapter.resolution = normalizeChapterResolution({
+                        width:Number(resolutionFields.width.value), height:Number(resolutionFields.height.value),
+                    });
+                    resolutionStatus.textContent = "Chapter resolution saved.";
+                    writePlan();
+                } catch (error) { resolutionStatus.textContent = error.message; }
+            });
+        }
+        resolutionMode.addEventListener("change", () => {
+            if (resolutionMode.value === "inherit") delete chapter.resolution;
+            else {
+                try {
+                    chapter.resolution = normalizeChapterResolution({
+                        width:Number(resolutionFields.width.value), height:Number(resolutionFields.height.value),
+                    });
+                } catch (error) {
+                    resolutionStatus.textContent = error.message;
+                    resolutionMode.value = "inherit";
+                    return;
+                }
+            }
+            for (const input of Object.values(resolutionFields)) input.disabled = resolutionMode.value === "inherit";
+            resolutionStatus.textContent = "Chapter resolution saved.";
+            writePlan();
+        });
+        const resolutionRow = element("div", "h3studio-chapter-resolution");
+        resolutionRow.append(field("Resolution", resolutionMode), field("Width", resolutionFields.width),
+            field("Height", resolutionFields.height));
+        form.append(resolutionRow);
+        const resolutionHelp = element("div", "h3studio-hint",
+            "One size per chapter. Locked saved scenes pin their chapter's original size, even when the Plan default changes. " +
+            "Unlock them before changing that chapter's size. Native AV/latent context cannot cross different sizes. " +
+            "Current Tagged Ref2VA Scene handles sizing automatically; with separate nodes, connect Current Shot width/height to conditioning. " +
+            "Export different-sized chapters separately.");
+        const textarea = element("textarea", "h3studio-prompt");
+        textarea.value = chapter.text ?? "";
+        textarea.placeholder = "Editorial context, lyrics, LLM notes, story intent…";
+        textarea.spellcheck = true;
+        textarea.addEventListener("input", () => {
+            chapter.text = textarea.value;
+            writePlan();
+        });
+        const actions = element("div", "h3studio-prompt-tools");
+        actions.append(
+            element(
+                "span", "h3studio-hint",
+                "Chapter notes remain editorial only. Resolution applies to generation and resume validation.",
+            ),
+            button("Delete chapter", "Remove this editorial marker and its notes", () => {
+                if (!confirm(`Delete ${chapter.title}?`)) return;
+                state.plan.chapters = (state.plan.chapters ?? []).filter(
+                    (candidate) => candidate.id !== chapter.id,
+                );
+                if (!state.plan.chapters.length) delete state.plan.chapters;
+                state.activeChapterId = "";
+                writePlan(); renderShell();
+            }),
+        );
+        panel.append(head, form, resolutionHelp, resolutionStatus, textarea, actions);
+        return panel;
+    }
+
+    function renderSharedPanel() {
+        const panel = element("div");
+        panel.append(element("div", "h3studio-scene-head", "Shared prompt — prepended to every scene"));
+        const textarea = element("textarea", "h3studio-shared");
+        textarea.value = sharedPrompt(state.plan).text;
+        textarea.placeholder = "Identity, wardrobe, style, reference definitions, audio rules, and global continuity…";
+        textarea.addEventListener("input", () => { setSharedPrompt(state.plan, textarea.value); writePlan(); });
+        panel.append(textarea);
+        return panel;
+    }
+
+    function renderPlanSettingsPanel() {
+        const panel = element("div");
+        const grid = element("div", "h3studio-plan-settings");
+        const owner = state.planOwner ?? node;
+        const modernPlan = owner?.type === MODERN_PLAN_NAME;
+        const transition = resolveTransitionPolicy(owner);
+        const audioPolicy = resolveAudioPolicy(owner);
+        const projectAssetsManaged = inputConnected(owner, "project_assets");
+        const value = (name, fallback = "") => widget(owner, name)?.value ?? fallback;
+        const section = (title) => element(
+            "div", "h3studio-plan-settings-section", title,
+        );
+        const textControl = (name, fallback = "", placeholder = "") => {
+            const control = element("input");
+            control.type = "text";
+            control.value = String(value(name, fallback));
+            control.placeholder = placeholder;
+            control.addEventListener("change", () => {
+                writePlanSetting(name, control.value.trim());
+            });
+            return control;
+        };
+        const numberControl = (
+            name, fallback, minimum, maximum, step = 1, integer = true,
+        ) => {
+            const control = element("input");
+            control.type = "number";
+            control.min = String(minimum); control.max = String(maximum);
+            control.step = String(step); control.value = String(value(name, fallback));
+            control.addEventListener("change", () => {
+                let parsed = Number(control.value);
+                if (!Number.isFinite(parsed)) parsed = Number(fallback);
+                parsed = Math.max(Number(minimum), Math.min(Number(maximum), parsed));
+                if (integer) parsed = Math.trunc(parsed);
+                writePlanSetting(name, parsed);
+            });
+            return control;
+        };
+        const selectControl = (name, options, fallback, transform = (item) => item) => {
+            const control = element("select");
+            for (const [optionValue, label] of options) {
+                const option = element("option", "", label);
+                option.value = optionValue; control.append(option);
+            }
+            control.value = String(value(name, fallback));
+            control.addEventListener("change", () => {
+                writePlanSetting(name, transform(control.value));
+            });
+            return control;
+        };
+        const baseSeed = element("input");
+        baseSeed.type = "text"; baseSeed.inputMode = "numeric";
+        baseSeed.value = String(value("base_seed", 0));
+        baseSeed.title = `Unsigned 64-bit seed (0–${MAX_SEED.toString()})`;
+        baseSeed.addEventListener("change", () => {
+            try {
+                const parsed = BigInt(baseSeed.value.trim() || "0");
+                if (parsed < 0n || parsed > MAX_SEED) throw new Error();
+                writePlanSetting("base_seed", parsed.toString());
+            } catch (_error) {
+                baseSeed.setCustomValidity("Base seed must be an unsigned 64-bit integer.");
+                baseSeed.reportValidity();
+                baseSeed.setCustomValidity("");
+            }
+        });
+
+        const mode = state.planNode
+            ? `Connected mode · changes are written to the ${modernPlan ? "Modern Plan" : "H3 Chain Plan"} and mirrored into Studio. Disconnecting keeps this synchronized snapshot.`
+            : "Standalone mode · this node owns, validates, and outputs the complete H3 Chain Plan.";
+        const identityFields = projectAssetsManaged ? [
+            element(
+                "div", "h3studio-plan-defaults-help",
+                "Run name and reference-derived generation fingerprint are managed by connected Project Assets. Their stored widget values are preserved; disconnect Project Assets to edit them.",
+            ),
+        ] : [
+            field("Run name", textControl("run_name", "h3_chain", "h3_chain")),
+            field("Generation fingerprint", textControl(
+                "generation_fingerprint", "", "optional compatibility tag",
+            )),
+        ];
+        grid.append(
+            element("div", "h3studio-plan-defaults-help", mode),
+            section("Run identity and canvas"),
+            ...identityFields,
+            field("Base seed", baseSeed),
+            field("Width", numberControl("width", 960, 32, 4096, 32)),
+            field("Height", numberControl("height", 544, 32, 4096, 32)),
+            field("Segment CRF", numberControl("segment_crf", 18, 0, 51)),
+            section("Plan-wide scene defaults"),
+            field("Default seconds", numberControl(
+                "default_duration_seconds", 15, .1, MAX_H3_FRAMES / FPS, .01, false,
+            )),
+            field("Default steps", numberControl("default_steps", 20, 1, 10000)),
+            field("Default blend frames", numberControl(
+                "video_blend_frames", 0, 0, 243,
+            )),
+            field("Context encoding", selectControl("encode_mode", [
+                ["video", "Video clip"], ["frames", "Separate frames"],
+            ], "video")),
+            field("Context fit", selectControl("crop", [
+                ["disabled", "Resize directly"], ["center", "Preserve aspect + center crop"],
+            ], "disabled")),
+        );
+        if (modernPlan) {
+            grid.append(
+                section("Generation Profile"),
+                element(
+                    "div", "h3studio-plan-defaults-help",
+                    transition.known || audioPolicy.known
+                        ? "Visual transition, context length, audio behavior, and continuation are owned by the connected Generation Profile. Per-scene Context controls remain available for deliberate overrides."
+                        : "Connect a Generation Profile to the Modern Plan. It owns visual transition, context length, audio behavior, and continuation.",
+                ),
+            );
+            panel.append(grid);
+            return panel;
+        }
+        grid.append(
+            field("Anchor placement", selectControl("anchor_mode", [
+                ["head", "Head (tested)"], ["before", "Before timeline (experimental)"],
+            ], "head")),
+            section("Legacy policy fallback"),
+        );
+        const context = selectControl(
+            "context_length", H3_CONTEXT_LENGTHS.map((item) => [String(item), `${item} frames`]), "22",
+            (item) => Number(item),
+        );
+        const continuation = selectControl(
+            "continuation_mode", CONTINUATION_MODES.map((item) => [item, item]), "guide",
+        );
+        const audioMode = selectControl("audio_mode", [
+            ["generated_audio", "Generated audio"],
+            ["source_track", "Source track"],
+            ["source_plus_timeline", "Source + generated continuity"],
+        ], "generated_audio");
+        const audioContext = numberControl("audio_context_length", 22, 0, 240);
+        context.disabled = transition.known;
+        continuation.disabled = transition.known;
+        audioMode.disabled = audioPolicy.known;
+        audioContext.disabled = audioPolicy.known;
+        grid.append(
+            field("Visual context", context),
+            field("Continuation implementation", continuation),
+            field("Audio mode", audioMode),
+            field("Audio context", audioContext),
+            element("div", "h3studio-plan-defaults-help",
+                transition.known || audioPolicy.known
+                    ? "Connected Chain Policy owns the disabled fallback controls. The active policy is used for timing and execution."
+                    : "These controls are used only when no Chain Policy is connected. Per-scene Context Planner settings can still override them."),
+        );
+        panel.append(grid);
+        return panel;
+    }
+
+    function playerCheckpoint(index) {
+        const item = matchingStudioCheckpoint(
+            state.checkpoints, index, timing().shots[index],
+        );
+        if (!item) return null;
+        return {
+            video:item.presentation_video ?? item.preview_video ?? item.video,
+            // Review previews already contain synchronized audio. Raw saved
+            // segments do not, so pair those with their delivered WAV.
+            // Picture-only alternates deliberately keep the original take's
+            // generated audio sidecar.
+            audio:item.presentation_video
+                ? (item.audio ?? null)
+                : item.preview_video ? null : (item.audio ?? null),
+        };
+    }
+
+    function renderAudioContextPanel(panel, result, row, shot) {
+        if (!row.preservesGeneratedAudioPrefix || !Number(row.audioContextLength)) {
+            panel.append(element(
+                "div", "h3studio-context-empty",
+                "This scene does not carry generated audio. Enable Generated continuity and a positive audio context before selecting extracts.",
+            ));
+            return panel;
+        }
+        const sourceSelect = (field, {lead = false} = {}) => {
+            const select = element("select");
+            if (lead) {
+                const off = element("option", "", "Off · one audio extract");
+                off.value = "";
+                select.append(off);
+            } else {
+                const previous = element(
+                    "option", "",
+                    `Previous scene · ${state.active} ${safeShotId(
+                        state.plan.shots[state.active - 1]?.id,
+                        `clip_${String(state.active).padStart(4, "0")}`,
+                    )}`,
+                );
+                previous.value = "";
+                select.append(previous);
+            }
+            for (let offset = 0; offset < state.active; offset += 1) {
+                if (!lead && offset === state.active - 1) continue;
+                const sourceId = safeShotId(
+                    state.plan.shots[offset]?.id,
+                    `clip_${String(offset + 1).padStart(4, "0")}`,
+                );
+                const option = element(
+                    "option", "", `Scene ${offset + 1} · ${sourceId}`,
+                );
+                option.value = sourceId;
+                select.append(option);
+            }
+            const resolver = lead
+                ? sceneAudioContextLeadSource : sceneAudioContextSource;
+            try {
+                const resolved = resolver(state.plan, state.active + 1);
+                select.value = resolved === null || (
+                    !lead && resolved === state.active
+                ) ? "" : safeShotId(
+                    state.plan.shots[resolved - 1]?.id,
+                    `clip_${String(resolved).padStart(4, "0")}`,
+                );
+            } catch (_error) {
+                select.value = "";
+            }
+            select.addEventListener("change", () => {
+                if (select.value) shot[field] = select.value;
+                else delete shot[field];
+                delete shot[lead
+                    ? "audio_context_lead_start_frame"
+                    : "audio_context_start_frame"];
+                if (lead) {
+                    if (!select.value) {
+                        delete shot.audio_context_lead_frames;
+                    } else if (!Object.hasOwn(
+                        shot, "audio_context_lead_frames",
+                    )) {
+                        const options = audioContextLeadFrameOptions(
+                            row.audioContextLength,
+                        );
+                        shot.audio_context_lead_frames = options.includes(5)
+                            ? 5 : options[Math.floor(options.length / 2)];
+                    }
+                }
+                writePlan();
+                renderShell();
+            });
+            return select;
+        };
+        const audioSource = sourceSelect("audio_context_source");
+        audioSource.title = "The extract nearest the new generation boundary. It may come from any earlier scene.";
+        const audioLeadSource = sourceSelect(
+            "audio_context_lead_source", {lead:true},
+        );
+        audioLeadSource.title = "Optional first extract. It may come from another character's scene or a second position in the same scene.";
+        const split = element("select");
+        const splitOptions = audioContextLeadFrameOptions(
+            row.audioContextLength,
+        );
+        for (const lead of splitOptions) {
+            const option = element(
+                "option", "",
+                `${row.audioContextLength} total · ${lead} + ${row.audioContextLength - lead}`,
+            );
+            option.value = String(lead);
+            split.append(option);
+        }
+        split.disabled = !audioLeadSource.value;
+        split.value = String(row.audioContextLeadFrames || (
+            splitOptions.includes(5) ? 5 : splitOptions.at(0)
+        ));
+        split.title = "Ordered duration of the two exact 40 Hz audio-latent extracts. These are sequential context excerpts, not a live audio mix.";
+        split.addEventListener("change", () => {
+            shot.audio_context_lead_frames = Number(split.value);
+            delete shot.audio_context_start_frame;
+            delete shot.audio_context_lead_start_frame;
+            writePlan();
+            renderShell();
+        });
+        const settingsGrid = element(
+            "div", "h3studio-context-audio-settings",
+        );
+        settingsGrid.append(
+            field("Boundary-nearest audio source", audioSource),
+            field("Optional first audio source", audioLeadSource),
+            field("Dual extract split", split),
+        );
+        panel.append(
+            element(
+                "div", "h3studio-context-help",
+                "Audio is unlocked from picture for this scene. Choose one exact latent extract, or two ordered extracts—for example two character voice regions. The second block sits nearest generation. No waveform is decoded or re-encoded.",
+            ),
+            settingsGrid,
+        );
+
+        const blocks = [];
+        if (row.audioContextLeadSource !== null) {
+            blocks.push({
+                label:"Audio block 1 · first extract",
+                sourceIndex:row.audioContextLeadSource - 1,
+                span:Number(row.audioContextLeadFrames),
+                field:"audio_context_lead_start_frame",
+                lead:true,
+            });
+        }
+        blocks.push({
+            label:row.audioContextLeadSource === null
+                ? "Audio context extract" : "Audio block 2 · nearest generation",
+            sourceIndex:row.audioContextSource - 1,
+            span:Number(row.audioContextLength - row.audioContextLeadFrames),
+            field:"audio_context_start_frame",
+            lead:false,
+        });
+        const blocksHost = element("div", "h3studio-context-blocks");
+        for (const block of blocks) {
+            const sourceRow = result.shots[block.sourceIndex];
+            const card = element("div", "h3studio-context-block");
+            const head = element("div", "h3studio-context-block-head");
+            head.append(
+                element("strong", "", `${block.label} · ${block.span}f`),
+                element(
+                    "span", "", sourceRow
+                        ? `Scene ${sourceRow.index} · ${sourceRow.id}`
+                        : "Missing source scene",
+                ),
+            );
+            card.append(head);
+            if (!sourceRow || block.span < 1) {
+                card.append(element(
+                    "div", "h3studio-context-empty",
+                    "The selected source or audio split is invalid.",
+                ));
+                blocksHost.append(card);
+                continue;
+            }
+            const validStarts = audioContextWindowStarts(
+                sourceRow.rawFrames, sourceRow.deliveredFrames, block.span,
+            );
+            if (!validStarts.length) {
+                card.append(element(
+                    "div", "h3studio-context-empty",
+                    "This scene has no position with the exact requested 40 Hz latent duration.",
+                ));
+                blocksHost.append(card);
+                continue;
+            }
+            const defaultStart = validStarts.at(-1);
+            let selectedStart = defaultStart;
+            let rangeError = "";
+            try {
+                selectedStart = sceneAudioContextStartFrame(
+                    shot, sourceRow.rawFrames, sourceRow.deliveredFrames,
+                    block.span, block.lead,
+                );
+            } catch (error) {
+                rangeError = error?.message || String(error);
+                selectedStart = nearestNativeContextWindowStart(
+                    validStarts, Number(shot[block.field]),
+                );
+            }
+            const media = playerCheckpoint(block.sourceIndex);
+            let audio = null;
+            const audioPath = media?.audio ?? media?.video;
+            if (audioPath) {
+                audio = element("audio", "h3studio-context-audio");
+                audio.controls = true;
+                audio.preload = "metadata";
+                audio.src = videoUrl(audioPath);
+                state.contextPlayers.push(audio);
+                card.append(audio);
+            }
+            const track = element("div", "h3studio-context-movie-track");
+            track.tabIndex = 0;
+            track.setAttribute("role", "slider");
+            track.setAttribute("aria-label", `${block.label} position`);
+            const zone = element(
+                "div", "h3studio-context-window", `${block.span}f`,
+            );
+            const playhead = element("div", "h3studio-context-playhead");
+            track.append(zone, playhead);
+            const rangeLabel = element("span", "h3studio-context-range-label");
+            const movieLength = element(
+                "span", "h3studio-context-movie-length",
+                `source audio · ${sourceRow.deliveredFrames}f · ${(sourceRow.deliveredFrames / FPS).toFixed(3)}s`,
+            );
+            const update = () => {
+                const layout = studioContextWindowLayout(
+                    sourceRow.deliveredFrames, block.span, selectedStart,
+                );
+                selectedStart = nearestNativeContextWindowStart(
+                    validStarts, layout.start,
+                );
+                const exact = studioContextWindowLayout(
+                    sourceRow.deliveredFrames, block.span, selectedStart,
+                );
+                zone.style.left = `${exact.leftFraction * 100}%`;
+                zone.style.width = `${exact.widthFraction * 100}%`;
+                rangeLabel.textContent = `frames ${exact.start + 1}–${exact.end} · ${(exact.start / FPS).toFixed(3)}–${(exact.end / FPS).toFixed(3)}s`;
+                track.setAttribute("aria-valuenow", String(exact.start));
+            };
+            const seek = () => {
+                if (!audio || audio.readyState < 1) return;
+                try { audio.currentTime = selectedStart / FPS; }
+                catch (_error) {}
+            };
+            const commit = () => {
+                if (selectedStart === defaultStart) delete shot[block.field];
+                else shot[block.field] = selectedStart;
+                writePlan();
+                renderStatus();
+            };
+            const choose = (value, commitNow = false) => {
+                selectedStart = nearestNativeContextWindowStart(
+                    validStarts, value,
+                );
+                update();
+                seek();
+                if (commitNow) commit();
+            };
+            let drag = null;
+            track.addEventListener("pointerdown", (event) => {
+                if (event.button !== 0) return;
+                event.preventDefault();
+                const bounds = track.getBoundingClientRect();
+                choose(studioContextWindowStartAtRatio(
+                    sourceRow.deliveredFrames, block.span,
+                    (event.clientX - bounds.left) / Math.max(1, bounds.width),
+                ));
+                drag = {id:event.pointerId, x:event.clientX,
+                    start:selectedStart, width:Math.max(1, bounds.width)};
+                track.setPointerCapture(event.pointerId);
+            });
+            track.addEventListener("pointermove", (event) => {
+                if (!drag || drag.id !== event.pointerId) return;
+                choose(drag.start + (event.clientX - drag.x) / drag.width
+                    * sourceRow.deliveredFrames);
+            });
+            const finish = (event) => {
+                if (!drag || drag.id !== event.pointerId) return;
+                drag = null;
+                try { track.releasePointerCapture(event.pointerId); }
+                catch (_error) {}
+                commit();
+            };
+            track.addEventListener("pointerup", finish);
+            track.addEventListener("pointercancel", finish);
+            track.addEventListener("keydown", (event) => {
+                const slot = Math.max(0, validStarts.indexOf(selectedStart));
+                let next = null;
+                if (event.key === "ArrowLeft") next = validStarts[Math.max(0, slot - 1)];
+                else if (event.key === "ArrowRight") next = validStarts[Math.min(validStarts.length - 1, slot + 1)];
+                else if (event.key === "Home") next = validStarts[0];
+                else if (event.key === "End") next = defaultStart;
+                if (next === null) return;
+                event.preventDefault();
+                choose(next, true);
+            });
+            const readout = element("div", "h3studio-context-range-readout");
+            readout.append(movieLength, rangeLabel);
+            const range = element("div", "h3studio-context-range");
+            range.append(track, readout);
+            card.append(range);
+            update();
+            if (audio) {
+                audio.addEventListener("loadedmetadata", seek, {once:true});
+                audio.addEventListener("timeupdate", () => {
+                    playhead.style.left = `${Math.max(0, Math.min(
+                        1, audio.currentTime * FPS / sourceRow.deliveredFrames,
+                    )) * 100}%`;
+                    const end = Number(audio.dataset.contextEnd);
+                    if (Number.isFinite(end) && audio.currentTime >= end) {
+                        delete audio.dataset.contextEnd;
+                        audio.pause();
+                    }
+                });
+            }
+            const actions = element("div", "h3studio-context-actions");
+            const play = button("Play extract", "Play only this audio extract", async () => {
+                if (!audio) return;
+                audio.dataset.contextEnd = String((selectedStart + block.span) / FPS);
+                audio.currentTime = selectedStart / FPS;
+                try { await audio.play(); } catch (_error) {}
+            });
+            play.disabled = !audio;
+            const usePlayhead = button("Start at playhead", "Place extract at the audio player's current time", () => {
+                if (audio) choose(audio.currentTime * FPS, true);
+            });
+            usePlayhead.disabled = !audio;
+            actions.append(usePlayhead, play, button(
+                "Latest exact (default)",
+                "Use the last exact 40 Hz crop and remove the override",
+                () => choose(defaultStart, true),
+            ));
+            const error = element("div", "h3studio-error", rangeError);
+            error.hidden = !rangeError;
+            card.append(actions, error);
+            blocksHost.append(card);
+        }
+        panel.append(blocksHost);
+        return panel;
+    }
+
+    function renderContextPanel() {
+        const panel = element("div", "h3studio-context-selector");
+        const result = timing();
+        const row = result.shots[state.active];
+        const shot = state.plan.shots[state.active];
+        const title = element(
+            "div", "h3studio-scene-head",
+            `Scene ${state.active + 1} context planner`,
+        );
+        panel.append(title);
+        if (!row || state.active === 0) {
+            panel.append(element(
+                "div", "h3studio-context-empty",
+                "Scene 1 has no saved predecessor. Existing Video Context remains configured by its dedicated workflow input.",
+            ));
+            return panel;
+        }
+        let audioUnlocked = false;
+        try { audioUnlocked = sceneAudioContextUnlocked(shot); }
+        catch (_error) {}
+        if (!audioUnlocked) state.contextTab = "picture";
+        const tabs = element("div", "h3studio-context-tabs");
+        const pictureTab = button(
+            "Picture", "Select picture context sources and latent windows",
+            () => { state.contextTab = "picture"; renderShell(); },
+        );
+        const audioTab = button(
+            "Audio", audioUnlocked
+                ? "Select independent audio context sources and latent windows"
+                : "Unlock audio context to choose sources independently",
+            () => { state.contextTab = "audio"; renderShell(); },
+        );
+        audioTab.disabled = !audioUnlocked;
+        (state.contextTab === "audio" ? audioTab : pictureTab).classList.add(
+            "h3studio-context-tab-active",
+        );
+        const lock = button(
+            audioUnlocked ? "Lock audio context" : "Unlock audio context",
+            audioUnlocked
+                ? "Restore the default behavior: picture may be single or dual while generated audio remains the immediate predecessor tail"
+                : "Expose an Audio tab that can choose one or two saved-scene audio extracts independently from picture",
+            () => {
+                if (audioUnlocked) {
+                    delete shot.audio_context_unlocked;
+                    delete shot.audio_context_source;
+                    delete shot.audio_context_start_frame;
+                    delete shot.audio_context_lead_source;
+                    delete shot.audio_context_lead_frames;
+                    delete shot.audio_context_lead_start_frame;
+                    state.contextTab = "picture";
+                } else {
+                    shot.audio_context_unlocked = true;
+                    state.contextTab = "audio";
+                }
+                writePlan();
+                renderShell();
+            },
+        );
+        lock.classList.add("h3studio-context-lock");
+        lock.disabled = !audioUnlocked && !row.preservesGeneratedAudioPrefix;
+        tabs.append(pictureTab, audioTab, lock);
+        panel.append(tabs);
+        if (state.contextTab === "audio" && audioUnlocked) {
+            return renderAudioContextPanel(panel, result, row, shot);
+        }
+        const legacyVisualFields = [
+            "visual_context_source", "visual_context_start_frame",
+            "visual_context_lead_source", "visual_context_lead_frames",
+            "visual_context_lead_start_frame",
+        ];
+        const clearLegacyVisualFields = () => {
+            for (const key of legacyVisualFields) delete shot[key];
+        };
+        const sourceId = (source) => safeShotId(
+            state.plan.shots[source - 1]?.id,
+            `clip_${String(source).padStart(4, "0")}`,
+        );
+        const currentVisualBlocks = () => {
+            try {
+                return sceneVisualContextBlocks(
+                    state.plan, state.active + 1,
+                    sceneContextLength(shot, settings().contextLength),
+                );
+            } catch (_error) {
+                return row.visualContextBlocks ?? [];
+            }
+        };
+        const writeVisualBuilder = (
+            partition, {preserveStarts = false} = {},
+        ) => {
+            const previous = currentVisualBlocks();
+            shot.visual_context_blocks = partition.map((frames, offset) => {
+                const prior = previous[offset] ?? previous.at(-1);
+                const source = Number(prior?.source) || state.active;
+                const block = {source:sourceId(source), frames:Number(frames)};
+                if (preserveStarts && Number(prior?.frames) === Number(frames)
+                        && Number.isInteger(prior?.startFrame)) {
+                    block.start_frame = Number(prior.startFrame);
+                }
+                return block;
+            });
+            clearLegacyVisualFields();
+            shot.video_blend_frames = 0;
+        };
+        const visualTotal = element("select");
+        for (const [value, label] of [
+            ["", `Plan default · ${settings().contextLength}`],
+            ["0", "0 · new visual scene"],
+            ...H3_CONTEXT_LENGTHS.map((value) => [
+                String(value), `${value} picture frames`,
+            ]),
+        ]) {
+            const option = element("option", "", label);
+            option.value = value;
+            visualTotal.append(option);
+        }
+        visualTotal.value = Object.hasOwn(shot, "context_length")
+            ? String(shot.context_length) : "";
+        visualTotal.title = "Total picture prefix entering this scene. The builder divides this exact H3-safe total into ordered source blocks.";
+        visualTotal.addEventListener("change", () => {
+            if (visualTotal.value === "") delete shot.context_length;
+            else shot.context_length = Number(visualTotal.value);
+            const total = sceneContextLength(shot, settings().contextLength);
+            if (total <= 0) {
+                delete shot.visual_context_blocks;
+                clearLegacyVisualFields();
+            } else {
+                const count = Math.min(
+                    Math.max(1, currentVisualBlocks().length || 1),
+                    visualContextMaximumBlocks(total),
+                );
+                writeVisualBuilder(
+                    visualContextDefaultPartition(total, count),
+                );
+            }
+            writePlan();
+            renderShell();
+        });
+        const audioTotal = element("input");
+        audioTotal.type = "number";
+        audioTotal.min = "0";
+        audioTotal.max = "240";
+        audioTotal.step = "1";
+        audioTotal.value = shot.audio_context_length ?? "";
+        audioTotal.placeholder = Number(settings().audioContextLength)
+            ? String(settings().audioContextLength)
+            : `Picture ${row.contextLength}`;
+        audioTotal.title = "Generated-audio context length. Audio remains locked to its normal continuous source unless you explicitly unlock the Audio tab.";
+        audioTotal.addEventListener("change", () => {
+            if (audioTotal.value === "") delete shot.audio_context_length;
+            else shot.audio_context_length = Number(audioTotal.value);
+            writePlan();
+            renderShell();
+        });
+        const implementation = element("select");
+        const inheritImplementation = element(
+            "option", "", `Inherit · ${settings().continuationMode}`,
+        );
+        inheritImplementation.value = "";
+        implementation.append(inheritImplementation);
+        for (const [value, label] of [
+            ["guide", "Guide"], ["latent_guide", "Latent Guide"],
+            ["tapered_guide", "Detail Guide"],
+            ["tone_carry_guide", "Tone Carry Guide"],
+            ["tapered_av", "Detail AV"],
+            ["drift_control_av", "Drift-Control AV"],
+            ["color_stable_drift_av", "Color-Stable Drift AV"],
+            ["masked_av", "Masked AV"],
+            ["feathered_av", "Feathered AV"],
+            ["audio_feathered_av", "Audio Feather AV"],
+        ]) {
+            const option = element("option", "", label);
+            option.value = value;
+            implementation.append(option);
+        }
+        implementation.value = shot.continuation_mode ?? "";
+        implementation.title = "Boundary implementation used to consume the complete ordered picture prefix.";
+        implementation.addEventListener("change", () => {
+            if (implementation.value) {
+                shot.continuation_mode = implementation.value;
+            } else delete shot.continuation_mode;
+            writePlan();
+            renderShell();
+        });
+        const spatialProxyControl = element("select");
+        for (const [value, label] of [
+            ["", "Off · native context"],
+            ["rgb_5_6", "Low-grid 5/6 proxy · Guide"],
+            ["latent_5_6", "Latent 5/6 proxy · AV"],
+        ]) {
+            const option = element("option", "", label);
+            option.value = value;
+            spatialProxyControl.append(option);
+        }
+        spatialProxyControl.value = shot.context_spatial_proxy ?? "";
+        spatialProxyControl.title = "Optional boundary-only 5/6 spatial proxy. Output, audio, checkpoints, and assembly stay at native size.";
+        spatialProxyControl.addEventListener("change", () => {
+            if (spatialProxyControl.value) {
+                shot.context_spatial_proxy = spatialProxyControl.value;
+            } else delete shot.context_spatial_proxy;
+            writePlan();
+            renderShell();
+        });
+        const contextSettings = element(
+            "div", "h3studio-context-builder-settings",
+        );
+        contextSettings.append(
+            field("Picture context total", visualTotal),
+            field("Audio context total", audioTotal),
+            field("Boundary implementation", implementation),
+            field("Boundary spatial proxy", spatialProxyControl),
+        );
+        panel.append(contextSettings);
+        if (!Number(row.contextLength)) {
+            panel.append(element(
+                "div", "h3studio-context-empty",
+                "This scene has 0 visual context. Choose a positive picture context total above to enable the builder.",
+            ));
+            return panel;
+        }
+        const resolvedBlocks = row.visualContextBlocks ?? [];
+        const blockCount = element("select");
+        const maximumBlocks = visualContextMaximumBlocks(row.contextLength);
+        for (let count = 1; count <= maximumBlocks; count += 1) {
+            const option = element(
+                "option", "",
+                `${count} ${count === 1 ? "block" : "blocks"}`,
+            );
+            option.value = String(count);
+            blockCount.append(option);
+        }
+        blockCount.value = String(Math.max(1, resolvedBlocks.length));
+        blockCount.title = "Choose how many ordered picture extracts form the prefix. Every block may use any earlier scene, including another window from the same scene.";
+        blockCount.addEventListener("change", () => {
+            writeVisualBuilder(visualContextDefaultPartition(
+                row.contextLength, Number(blockCount.value),
+            ));
+            writePlan();
+            renderShell();
+        });
+        const partition = resolvedBlocks.map((block) => Number(block.frames));
+        const cuts = [];
+        let cumulative = 0;
+        for (const span of partition.slice(0, -1)) {
+            cumulative += span;
+            cuts.push(cumulative);
+        }
+        const validBoundaries = visualContextBoundaryFrames(row.contextLength);
+        const cutsHost = element("div", "h3studio-context-cuts");
+        for (let cutOffset = 0; cutOffset < cuts.length; cutOffset += 1) {
+            const select = element("select");
+            const lower = cutOffset === 0 ? -1 : cuts[cutOffset - 1];
+            const upper = cutOffset === cuts.length - 1
+                ? row.contextLength + 1 : cuts[cutOffset + 1];
+            for (const boundary of validBoundaries) {
+                if (boundary <= lower || boundary >= upper) continue;
+                const option = element(
+                    "option", "", `after frame ${boundary}`,
+                );
+                option.value = String(boundary);
+                select.append(option);
+            }
+            select.value = String(cuts[cutOffset]);
+            select.title = "Move this division to another native H3 cumulative boundary. Together the cuts expose every valid repartition for the selected block count.";
+            select.addEventListener("change", () => {
+                const nextCuts = [...cuts];
+                nextCuts[cutOffset] = Number(select.value);
+                writeVisualBuilder(visualContextPartitionFromBoundaries(
+                    row.contextLength, nextCuts,
+                ));
+                writePlan();
+                renderShell();
+            });
+            cutsHost.append(field(`Division ${cutOffset + 1}`, select));
+        }
+        const partitionSummary = element(
+            "div", "h3studio-context-help",
+            `Ordered repartition: ${partition.join(" + ")} = ${row.contextLength} frames. The last block sits nearest the new generation boundary.`,
+        );
+        const builderSettings = element(
+            "div", "h3studio-context-builder-settings",
+        );
+        builderSettings.append(field("Picture blocks", blockCount));
+        if (cuts.length) builderSettings.append(cutsHost);
+        panel.append(builderSettings, partitionSummary);
+        panel.append(element(
+            "div", "h3studio-context-help",
+            "Drag the fixed-width zone between native H3 latent positions. The selector advances on the 17-frame / 5-latent-step lattice and crops saved latent steps directly; it never re-encodes an arbitrary RGB window. Latest aligned is the default. While audio is locked, generated-audio continuity still follows the immediate previous scene.",
+        ));
+        const blocksHost = element("div", "h3studio-context-blocks");
+        let prefixFrames = 0;
+        const blocks = resolvedBlocks.map((resolved, blockIndex) => {
+            const block = {
+                label:resolvedBlocks.length === 1
+                    ? "Picture context"
+                    : blockIndex === resolvedBlocks.length - 1
+                        ? `Block ${blockIndex + 1} · nearest generation`
+                        : `Block ${blockIndex + 1}`,
+                blockIndex,
+                sourceIndex:Number(resolved.source) - 1,
+                span:Number(resolved.frames),
+                prefixFrames,
+                startFrame:resolved.startFrame,
+            };
+            prefixFrames += block.span;
+            return block;
+        });
+
+        for (const block of blocks) {
+            const sourceRow = result.shots[block.sourceIndex];
+            const card = element("div", "h3studio-context-block");
+            const head = element("div", "h3studio-context-block-head");
+            head.append(
+                element("strong", "", `${block.label} · ${block.span}f`),
+                element(
+                    "span", "",
+                    sourceRow
+                        ? `Scene ${sourceRow.index} · ${sourceRow.id}`
+                        : "Missing source scene",
+                ),
+            );
+            card.append(head);
+            const sourceSelect = element("select");
+            for (let sourceOffset = 0; sourceOffset < state.active;
+                sourceOffset += 1) {
+                const id = sourceId(sourceOffset + 1);
+                const option = element(
+                    "option", "", `Scene ${sourceOffset + 1} · ${id}`,
+                );
+                option.value = id;
+                sourceSelect.append(option);
+            }
+            sourceSelect.value = sourceRow
+                ? sourceId(sourceRow.index) : "";
+            sourceSelect.title = "Choose any earlier scene. Multiple blocks may select the same scene and use independent latent windows.";
+            sourceSelect.addEventListener("change", () => {
+                if (!Array.isArray(shot.visual_context_blocks)) {
+                    writeVisualBuilder(partition, {preserveStarts:true});
+                }
+                const authored = shot.visual_context_blocks[block.blockIndex];
+                authored.source = sourceSelect.value;
+                delete authored.start_frame;
+                shot.video_blend_frames = 0;
+                writePlan();
+                renderShell();
+            });
+            card.append(field("Source scene", sourceSelect));
+            if (!sourceRow || !Number.isInteger(block.span) || block.span < 1) {
+                card.append(element(
+                    "div", "h3studio-context-empty",
+                    "The selected source or context split is invalid. Fix it in Scene settings.",
+                ));
+                blocksHost.append(card);
+                continue;
+            }
+            const latest = Math.max(0, sourceRow.deliveredFrames - block.span);
+            const validStarts = nativeContextWindowStarts(
+                sourceRow.rawFrames, sourceRow.deliveredFrames, block.span,
+                block.prefixFrames,
+            );
+            if (!validStarts.length) {
+                card.append(element(
+                    "div", "h3studio-context-empty",
+                    "This block has no native latent-aligned position in the selected source scene.",
+                ));
+                blocksHost.append(card);
+                continue;
+            }
+            const defaultStart = validStarts.at(-1);
+            let start = Number.isInteger(block.startFrame)
+                ? block.startFrame : defaultStart;
+            let rangeError = "";
+            if (!validStarts.includes(start)) {
+                rangeError = `Block ${block.blockIndex + 1} start ${start} is not native-aligned for this source and target offset.`;
+                const raw = Number(
+                    shot.visual_context_blocks?.[block.blockIndex]
+                        ?.start_frame,
+                );
+                start = nearestNativeContextWindowStart(
+                    validStarts, Number.isInteger(raw) ? raw : defaultStart,
+                );
+            }
+            const media = playerCheckpoint(block.sourceIndex);
+            let video = null;
+            if (media?.video) {
+                video = element("video", "h3studio-context-video");
+                video.controls = true;
+                video.playsInline = true;
+                video.preload = "metadata";
+                video.muted = true;
+                video.src = videoUrl(media.video);
+                state.contextPlayers.push(video);
+                card.append(video);
+            } else {
+                card.append(element(
+                    "div", "h3studio-context-empty",
+                    `Scene ${sourceRow.index} has no active saved video yet. The frame window can still be planned now.`,
+                ));
+            }
+            const rangeWrap = element("div", "h3studio-context-range");
+            const movieTrack = element("div", "h3studio-context-movie-track");
+            movieTrack.tabIndex = 0;
+            movieTrack.setAttribute("role", "slider");
+            movieTrack.setAttribute("aria-label", `${block.label} position in source movie`);
+            movieTrack.setAttribute("aria-valuemin", "0");
+            movieTrack.setAttribute("aria-valuemax", String(latest));
+            movieTrack.title = `Drag the fixed ${block.span}-frame context zone across ${validStarts.length} native latent-aligned positions`;
+            const selectedZone = element(
+                "div", "h3studio-context-window", `${block.span}f`,
+            );
+            const phaseTailFrames = Math.max(0, latest - defaultStart);
+            const phaseTail = element("div", "h3studio-context-phase-tail");
+            phaseTail.hidden = phaseTailFrames < 1;
+            if (phaseTailFrames > 0) {
+                phaseTail.style.left = `${(
+                    (defaultStart + block.span) / sourceRow.deliveredFrames
+                ) * 100}%`;
+                phaseTail.style.width = `${(
+                    phaseTailFrames / sourceRow.deliveredFrames
+                ) * 100}%`;
+            }
+            const playhead = element("div", "h3studio-context-playhead");
+            movieTrack.append(phaseTail, selectedZone, playhead);
+            const rangeLabel = element("span", "h3studio-context-range-label");
+            const movieLength = element(
+                "span", "h3studio-context-movie-length",
+                `source movie · ${sourceRow.deliveredFrames}f · ${(sourceRow.deliveredFrames / FPS).toFixed(3)}s`,
+            );
+            const error = element("div", "h3studio-error", rangeError);
+            error.hidden = !rangeError;
+            let selectedStart = start;
+            const updateSelection = () => {
+                const layout = studioContextWindowLayout(
+                    sourceRow.deliveredFrames, block.span, selectedStart,
+                );
+                selectedStart = layout.start;
+                selectedZone.style.left = `${layout.leftFraction * 100}%`;
+                selectedZone.style.width = `${layout.widthFraction * 100}%`;
+                selectedZone.title = `${block.span} context frames · ${layout.start + 1}–${layout.end} · native latent crop`;
+                const slot = validStarts.indexOf(layout.start) + 1;
+                rangeLabel.textContent = `aligned ${slot}/${validStarts.length} · frames ${layout.start + 1}–${layout.end} · ${(layout.start / FPS).toFixed(3)}–${(layout.end / FPS).toFixed(3)}s${phaseTailFrames > 0 ? ` · final ${phaseTailFrames}f use another phase` : ""}`;
+                movieTrack.setAttribute("aria-valuenow", String(layout.start));
+                movieTrack.setAttribute(
+                    "aria-valuetext", `frames ${layout.start + 1} through ${layout.end}`,
+                );
+            };
+            const previewStart = () => {
+                if (!video || video.readyState < 1) return;
+                try { video.currentTime = selectedStart / FPS; }
+                catch (_error) {}
+            };
+            const commitStart = () => {
+                if (!Array.isArray(shot.visual_context_blocks)) {
+                    writeVisualBuilder(partition, {preserveStarts:true});
+                }
+                const authored = shot.visual_context_blocks[block.blockIndex];
+                if (selectedStart === defaultStart) delete authored.start_frame;
+                else authored.start_frame = selectedStart;
+                shot.video_blend_frames = 0;
+                error.hidden = true;
+                error.textContent = "";
+                writePlan();
+                renderStatus();
+            };
+            const selectStart = (value, {seek = true, commit = false} = {}) => {
+                selectedStart = nearestNativeContextWindowStart(
+                    validStarts, Math.max(0, Math.min(latest, Math.round(value))),
+                );
+                updateSelection();
+                if (seek) previewStart();
+                if (commit) commitStart();
+            };
+            let drag = null;
+            movieTrack.addEventListener("pointerdown", (event) => {
+                if (event.button !== 0) return;
+                event.preventDefault();
+                const bounds = movieTrack.getBoundingClientRect();
+                if (event.target !== selectedZone) {
+                    selectStart(studioContextWindowStartAtRatio(
+                        sourceRow.deliveredFrames,
+                        block.span,
+                        (event.clientX - bounds.left) / Math.max(1, bounds.width),
+                    ));
+                }
+                drag = {
+                    id:event.pointerId,
+                    x:event.clientX,
+                    start:selectedStart,
+                    width:Math.max(1, bounds.width),
+                };
+                movieTrack.classList.add("h3studio-dragging");
+                movieTrack.setPointerCapture(event.pointerId);
+            });
+            movieTrack.addEventListener("pointermove", (event) => {
+                if (!drag || drag.id !== event.pointerId) return;
+                const frameDelta = (
+                    (event.clientX - drag.x) / drag.width
+                ) * sourceRow.deliveredFrames;
+                selectStart(drag.start + frameDelta);
+            });
+            const finishDrag = (event) => {
+                if (!drag || drag.id !== event.pointerId) return;
+                drag = null;
+                movieTrack.classList.remove("h3studio-dragging");
+                try { movieTrack.releasePointerCapture(event.pointerId); }
+                catch (_error) {}
+                commitStart();
+            };
+            movieTrack.addEventListener("pointerup", finishDrag);
+            movieTrack.addEventListener("pointercancel", finishDrag);
+            movieTrack.addEventListener("keydown", (event) => {
+                let next = null;
+                const currentSlot = Math.max(0, validStarts.indexOf(selectedStart));
+                const step = event.shiftKey ? 5 : 1;
+                if (event.key === "ArrowLeft") {
+                    next = validStarts[Math.max(0, currentSlot - step)];
+                } else if (event.key === "ArrowRight") {
+                    next = validStarts[Math.min(validStarts.length - 1, currentSlot + step)];
+                } else if (event.key === "PageUp") {
+                    next = validStarts[Math.max(0, currentSlot - 5)];
+                } else if (event.key === "PageDown") {
+                    next = validStarts[Math.min(validStarts.length - 1, currentSlot + 5)];
+                } else if (event.key === "Home") next = validStarts[0];
+                else if (event.key === "End") next = defaultStart;
+                if (next === null) return;
+                event.preventDefault();
+                selectStart(next, {commit:true});
+            });
+            const rangeReadout = element("div", "h3studio-context-range-readout");
+            rangeReadout.append(movieLength, rangeLabel);
+            rangeWrap.append(movieTrack, rangeReadout);
+            if (phaseTailFrames > 0) {
+                rangeWrap.append(element(
+                    "div", "h3studio-context-phase-note",
+                    `The hatched final ${phaseTailFrames} frames are on a different H3 latent phase for this ${block.span}-frame block at target offset ${block.prefixFrames}. A direct latent crop cannot end there; change the composed split to use that physical tail without RGB/VAE re-encoding.`,
+                ));
+            }
+            card.append(rangeWrap);
+            updateSelection();
+            if (video) {
+                video.addEventListener("loadedmetadata", previewStart, {once:true});
+            }
+            const actions = element("div", "h3studio-context-actions");
+            const usePlayhead = button(
+                "Start at playhead",
+                "Set the context window's first frame from this player's current position",
+                () => {
+                    if (!video) return;
+                    selectStart(video.currentTime * FPS, {commit:true});
+                },
+            );
+            usePlayhead.disabled = !video;
+            const playSelection = button(
+                "Play selection",
+                "Play only this context window",
+                async () => {
+                    if (!video) return;
+                    for (const item of state.contextPlayers) {
+                        if (item !== video) item.pause();
+                    }
+                    const endSeconds = (
+                        selectedStart + block.span
+                    ) / FPS;
+                    video.dataset.contextEnd = String(endSeconds);
+                    video.currentTime = selectedStart / FPS;
+                    try { await video.play(); } catch (_error) {}
+                },
+            );
+            playSelection.disabled = !video;
+            if (video) {
+                video.addEventListener("timeupdate", () => {
+                    playhead.style.left = `${Math.max(0, Math.min(
+                        1, video.currentTime * FPS / sourceRow.deliveredFrames,
+                    )) * 100}%`;
+                    const end = Number(video.dataset.contextEnd);
+                    if (Number.isFinite(end) && video.currentTime >= end) {
+                        delete video.dataset.contextEnd;
+                        video.pause();
+                        video.currentTime = end;
+                    }
+                });
+            }
+            const tail = button(
+                defaultStart === latest ? "Tail (default)" : "Latest aligned (default)",
+                "Use the latest native latent-aligned crop and remove the stored override",
+                () => {
+                    selectStart(defaultStart, {commit:true});
+                },
+            );
+            actions.append(usePlayhead, playSelection, tail);
+            card.append(actions, error);
+            blocksHost.append(card);
+        }
+        panel.append(blocksHost);
+        return panel;
+    }
+
+    function disposePlayer() {
+        if (state.editorialClockFrame != null) {
+            cancelAnimationFrame(state.editorialClockFrame);
+            state.editorialClockFrame = null;
+        }
+        if (state.mediaClockFrame != null) {
+            cancelAnimationFrame(state.mediaClockFrame);
+            state.mediaClockFrame = null;
+        }
+        state.mediaClockKind = "";
+        const current = state.player;
+        const generatedAudio = state.playerAudio;
+        const sourceAudioCurrent = state.sourceAudioPlayer;
+        const sourceCurrent = state.sourcePlayer;
+        const preloadVideo = state.playerPreloadVideo;
+        const preloadAudio = state.playerPreloadAudio;
+        state.player = null;
+        state.playerAudio = null;
+        state.sourceAudioPlayer = null;
+        state.sourcePlayer = null;
+        state.sourceLayer = null;
+        state.subtitleOverlay = null;
+        state.playerSegmentKey = "";
+        const contextPlayers = state.contextPlayers;
+        state.contextPlayers = [];
+        state.playerSlider = null;
+        state.playerPreloadVideo = null;
+        state.playerPreloadAudio = null;
+        state.primePlayerNext = null;
+        state.playPlayerTransport = null;
+        state.togglePlayerPlayback = null;
+        for (const media of [
+            current, generatedAudio, sourceAudioCurrent, sourceCurrent,
+            preloadVideo, preloadAudio, ...contextPlayers,
+        ]) {
+            if (!media) continue;
+            try { media.pause(); } catch (_error) {}
+            media.removeAttribute("src");
+            delete media.dataset.source;
+            try { media.load(); } catch (_error) {}
+        }
+    }
+
+    function seekTimeline(seconds, autoplay = false) {
+        const model = timelineModel();
+        const {result} = model;
+        const location = locateStudioTimelineSegment(model.segments, seconds);
+        if (location.index < 0) return;
+        const {index, localSeconds, targetSeconds:target} = location;
+        const inGap = location.kind === "gap";
+        const generatedMedia = inGap ? null : playerCheckpoint(index);
+        const generated = inGap ? null : generatedMedia?.video;
+        const reference = inGap ? null : sourceReference(index);
+        const source = sourcePreviewUrl(index, reference);
+        state.playerIndex = index; state.pendingSeek = localSeconds;
+        state.playerSegmentKey = location.key;
+        state.timelinePosition = target;
+        if (state.active !== index) {
+            state.active = index; persistView(); renderSourceTimeline();
+            renderSourceAudioTimeline();
+            updateTimelineSelection();
+            revealActiveTimelineScene();
+            publishActiveScene();
+        }
+        if (state.playerSlider) state.playerSlider.value = String(target);
+        positionTimelinePlayhead(target);
+        if (!state.player) return;
+        if (!generated) {
+            delete state.player.dataset.source;
+            state.player.removeAttribute("src"); state.player.load();
+            if (state.playerAudio) {
+                try { state.playerAudio.pause(); } catch (_error) {}
+                delete state.playerAudio.dataset.source;
+                state.playerAudio.removeAttribute("src");
+                state.playerAudio.load();
+            }
+        } else {
+            const url = videoUrl(generated);
+            const targetPlayer = state.player;
+            const targetAudio = state.playerAudio;
+            const requestedSeek = state.pendingSeek;
+            const audioUrl = generatedMedia?.audio ? videoUrl(generatedMedia.audio) : "";
+            if (targetAudio && targetAudio.dataset.source !== audioUrl) {
+                try { targetAudio.pause(); } catch (_error) {}
+                if (audioUrl) {
+                    targetAudio.dataset.source = audioUrl;
+                    targetAudio.src = audioUrl;
+                } else {
+                    delete targetAudio.dataset.source;
+                    targetAudio.removeAttribute("src");
+                }
+                targetAudio.load();
+            }
+            const seekGeneratedAudio = () => {
+                if (!targetAudio?.dataset.source) return;
+                const duration = Number.isFinite(targetAudio.duration)
+                    ? targetAudio.duration : requestedSeek;
+                try { targetAudio.currentTime = Math.min(
+                    requestedSeek, Math.max(0, duration - .02),
+                ); } catch (_error) {}
+            };
+            const applySeek = () => {
+                if (state.player !== targetPlayer || !targetPlayer?.isConnected) return;
+                const duration = Number.isFinite(targetPlayer.duration) ? targetPlayer.duration : requestedSeek;
+                try { targetPlayer.currentTime = Math.min(requestedSeek, Math.max(0, duration - .02)); }
+                catch (_error) {}
+                seekGeneratedAudio();
+                if (autoplay) void targetPlayer.play().catch(() => {});
+            };
+            if (targetAudio?.dataset.source) {
+                targetAudio.addEventListener(
+                    "loadedmetadata", seekGeneratedAudio, {once:true},
+                );
+            }
+            if (targetPlayer.dataset.source !== url) {
+                targetPlayer.dataset.source = url; targetPlayer.src = url; targetPlayer.load();
+                targetPlayer.addEventListener("loadedmetadata", applySeek, {once:true});
+            } else applySeek();
+        }
+        if (state.sourcePlayer) {
+            const targetSource = state.sourcePlayer;
+            const requestedSourceSeek = studioSourceSecond(reference, localSeconds);
+            const applySourceSeek = () => {
+                if (state.sourcePlayer !== targetSource || !targetSource?.isConnected) return;
+                try { targetSource.currentTime = requestedSourceSeek; }
+                catch (_error) {}
+            };
+            if (!source) {
+                delete targetSource.dataset.source;
+                targetSource.removeAttribute("src"); targetSource.load();
+            } else if (targetSource.dataset.source !== source) {
+                targetSource.dataset.source = source; targetSource.src = source; targetSource.load();
+                targetSource.addEventListener("loadedmetadata", applySourceSeek, {once:true});
+            } else applySourceSeek();
+        }
+        if (state.sourceAudioPlayer) {
+            const targetSourceAudio = state.sourceAudioPlayer;
+            const timelineAudio = sourceAudio();
+            const timelineAudioUrl = timelineAudio ? sourceAudioUrl() : "";
+            const requestedAudioSeek = timelineAudio
+                ? studioSourceAudioSecond(timelineAudio, target) : 0;
+            const applySourceAudioSeek = () => {
+                if (state.sourceAudioPlayer !== targetSourceAudio ||
+                        !targetSourceAudio?.isConnected) return;
+                if (Math.abs((Number(targetSourceAudio.currentTime) || 0) -
+                        requestedAudioSeek) > .12) {
+                    try { targetSourceAudio.currentTime = requestedAudioSeek; }
+                    catch (_error) {}
+                }
+            };
+            if (!timelineAudioUrl) {
+                targetSourceAudio.pause();
+                delete targetSourceAudio.dataset.source;
+                targetSourceAudio.removeAttribute("src");
+                targetSourceAudio.load();
+            } else if (targetSourceAudio.dataset.source !== timelineAudioUrl) {
+                targetSourceAudio.dataset.source = timelineAudioUrl;
+                targetSourceAudio.src = timelineAudioUrl;
+                targetSourceAudio.load();
+                targetSourceAudio.addEventListener(
+                    "loadedmetadata", applySourceAudioSeek, {once:true},
+                );
+            } else applySourceAudioSeek();
+        }
+        const label = root.querySelector(".h3studio-player-label");
+        if (label) label.textContent = inGap
+            ? location.trailing
+                ? `Open black timeline after scene ${index + 1} · ${formatClock(location.durationSeconds)}`
+                : `Black editorial gap before scene ${index + 1} · ${formatClock(location.durationSeconds)}`
+            : generated
+            ? `Scene ${index + 1} · ${timing().shots[index].id}${reference ? ` ↔ @${reference.tag}` : ""}`
+            : `Scene ${index + 1} has no saved segment${sourceAudio() ? " · Source track is ready" : ""}${reference ? ` · @${reference.tag} is ready` : ""}.`;
+        const motionAudioToggle = root.querySelector(".h3studio-audio-motion");
+        if (motionAudioToggle) {
+            motionAudioToggle.disabled = !reference?.has_audio;
+            if (!reference?.has_audio) motionAudioToggle.checked = false;
+            const wrapper = motionAudioToggle.closest(
+                ".h3studio-audio-control");
+            if (wrapper) wrapper.hidden = !reference?.has_audio;
+        }
+        const timelineAudioToggle = root.querySelector(".h3studio-audio-source");
+        const timelineAudioAvailable = Boolean(sourceAudio());
+        if (timelineAudioToggle) {
+            const wasAvailable = timelineAudioToggle.dataset.available === "true";
+            timelineAudioToggle.disabled = !timelineAudioAvailable;
+            if (timelineAudioAvailable && !wasAvailable) {
+                timelineAudioToggle.checked = true;
+            } else if (!timelineAudioAvailable) {
+                timelineAudioToggle.checked = false;
+            }
+            timelineAudioToggle.dataset.available = String(timelineAudioAvailable);
+            const audioControl = timelineAudioToggle.closest(
+                ".h3studio-audio-control");
+            const volume = audioControl?.querySelector(
+                ".h3studio-audio-volume");
+            if (volume) volume.disabled = !timelineAudioAvailable;
+            const text = timelineAudioToggle.closest("label")?.querySelector("span");
+            if (text) text.textContent = sourceAudioMuted(index)
+                ? "Source track (scene muted)" : "Source track";
+        }
+        const hasMotion = Boolean(reference);
+        if (state.sourceLayer) state.sourceLayer.hidden = !hasMotion;
+        const compareControls = root.querySelector(".h3studio-compare-controls");
+        compareControls?.classList.toggle("h3studio-no-motion", !hasMotion);
+        for (const item of root.querySelectorAll(
+            ".h3studio-wipe-label,.h3studio-wipe-control,.h3studio-wipe-line,.h3studio-compare-label",
+        )) item.hidden = !hasMotion;
+        root.querySelector(".h3studio-audio-generated")?.dispatchEvent(
+            new Event("change"),
+        );
+        updateSubtitleOverlay(target);
+        const segmentPosition = model.segments.findIndex(
+            (segment) => segment.key === location.key,
+        );
+        const upcomingSegment = model.segments[segmentPosition + 1];
+        state.primePlayerNext?.(
+            upcomingSegment?.kind === "scene"
+                ? upcomingSegment.sceneIndex : -1,
+        );
+        if (autoplay && !generated) state.playPlayerTransport?.();
+    }
+
+    function renderPlayerPanel() {
+        const wrapper = element("div", "h3studio-player");
+        const label = element("div", "h3studio-player-label", "Generated playback");
+        const stage = element("div", "h3studio-compare-stage");
+        let video = element("video"); video.playsInline = true; video.preload = "metadata";
+        const handoffFrame = element("canvas", "h3studio-handoff-frame");
+        handoffFrame.hidden = true;
+        let generatedAudio = element("audio");
+        generatedAudio.preload = "metadata"; generatedAudio.hidden = true;
+        const sourceTimelineAudio = element("audio");
+        sourceTimelineAudio.preload = "metadata"; sourceTimelineAudio.hidden = true;
+        const sourceVideo = element("video"); sourceVideo.playsInline = true;
+        sourceVideo.preload = "metadata"; sourceVideo.muted = true;
+        const sourceLayer = element("div", "h3studio-source-layer");
+        sourceLayer.style.clipPath = "inset(0 50% 0 0)";
+        sourceLayer.hidden = true;
+        const wipeLine = element("span", "h3studio-wipe-line"); wipeLine.style.left = "50%";
+        const sourceLabel = element(
+            "span", "h3studio-compare-label h3studio-compare-label-source",
+            "MOTION REF",
+        );
+        const generatedLabel = element(
+            "span", "h3studio-compare-label h3studio-compare-label-generated",
+            "GENERATED",
+        );
+        const subtitleOverlay = element("div", "h3studio-subtitle-overlay");
+        subtitleOverlay.hidden = true;
+        wipeLine.hidden = true; sourceLabel.hidden = true;
+        generatedLabel.hidden = true;
+        sourceLayer.append(sourceVideo);
+        stage.append(
+            video, handoffFrame, sourceLayer, wipeLine, sourceLabel,
+            generatedLabel, subtitleOverlay,
+        );
+        const preloadVideo = element("video");
+        preloadVideo.preload = "auto"; preloadVideo.muted = true;
+        preloadVideo.playsInline = true; preloadVideo.hidden = true;
+        const preloadAudio = element("audio");
+        preloadAudio.preload = "auto"; preloadAudio.muted = true;
+        preloadAudio.hidden = true;
+        let standbyVideo = preloadVideo;
+        let standbyAudio = preloadAudio;
+        stage.insertBefore(preloadVideo, handoffFrame);
+        const clearPreload = (media) => {
+            if (!media.dataset.source) return;
+            delete media.dataset.source;
+            media.removeAttribute("src"); media.load();
+        };
+        const primeNextSegment = (index) => {
+            const media = index >= 0 && index < state.plan.shots.length
+                ? playerCheckpoint(index) : null;
+            const videoSource = media?.video ? videoUrl(media.video) : "";
+            const audioSource = media?.audio ? videoUrl(media.audio) : "";
+            if (!videoSource) clearPreload(standbyVideo);
+            else if (standbyVideo.dataset.source !== videoSource) {
+                standbyVideo.dataset.source = videoSource;
+                standbyVideo.src = videoSource; standbyVideo.load();
+            }
+            if (!audioSource) clearPreload(standbyAudio);
+            else if (standbyAudio.dataset.source !== audioSource) {
+                standbyAudio.dataset.source = audioSource;
+                standbyAudio.src = audioSource; standbyAudio.load();
+            }
+        };
+        const captureHandoffFrame = () => {
+            if (!video.videoWidth || !video.videoHeight ||
+                    !stage.clientWidth || !stage.clientHeight) return;
+            const ratio = Math.max(1, Number(window.devicePixelRatio) || 1);
+            handoffFrame.width = Math.round(stage.clientWidth * ratio);
+            handoffFrame.height = Math.round(stage.clientHeight * ratio);
+            const context = handoffFrame.getContext("2d");
+            if (!context) return;
+            context.fillStyle = "#050608";
+            context.fillRect(0, 0, handoffFrame.width, handoffFrame.height);
+            const scale = Math.min(
+                handoffFrame.width / video.videoWidth,
+                handoffFrame.height / video.videoHeight,
+            );
+            const width = video.videoWidth * scale;
+            const height = video.videoHeight * scale;
+            try {
+                context.drawImage(
+                    video,
+                    (handoffFrame.width - width) / 2,
+                    (handoffFrame.height - height) / 2,
+                    width, height,
+                );
+                handoffFrame.classList.remove("h3studio-handoff-release");
+                handoffFrame.hidden = false;
+            } catch (_error) {}
+        };
+        const releaseHandoffFrame = () => {
+            if (handoffFrame.hidden) return;
+            requestAnimationFrame(() => {
+                handoffFrame.classList.add("h3studio-handoff-release");
+            });
+            window.setTimeout(() => {
+                if (!handoffFrame.isConnected) return;
+                handoffFrame.hidden = true;
+            }, 180);
+        };
+        const primedSegmentReady = (index) => {
+            const media = index >= 0 && index < state.plan.shots.length
+                ? playerCheckpoint(index) : null;
+            const videoSource = media?.video ? videoUrl(media.video) : "";
+            return Boolean(
+                videoSource && standbyVideo.dataset.source === videoSource &&
+                standbyVideo.readyState >= HTMLMediaElement.HAVE_CURRENT_DATA,
+            );
+        };
+        const promotePrimedSegment = (index) => {
+            if (!primedSegmentReady(index)) return false;
+            const outgoingVideo = video;
+            const outgoingAudio = generatedAudio;
+            const incomingVideo = standbyVideo;
+            const incomingAudio = standbyAudio;
+            incomingVideo.playbackRate = outgoingVideo.playbackRate;
+            incomingVideo.volume = outgoingVideo.volume;
+            incomingVideo.muted = outgoingVideo.muted;
+            incomingAudio.playbackRate = outgoingAudio.playbackRate;
+            incomingAudio.volume = outgoingAudio.volume;
+            incomingAudio.muted = outgoingAudio.muted;
+            incomingVideo.hidden = false;
+            outgoingVideo.hidden = true;
+            video = incomingVideo;
+            standbyVideo = outgoingVideo;
+            generatedAudio = incomingAudio;
+            standbyAudio = outgoingAudio;
+            state.player = video;
+            state.playerAudio = generatedAudio;
+            state.playerPreloadVideo = standbyVideo;
+            state.playerPreloadAudio = standbyAudio;
+            try { standbyVideo.pause(); } catch (_error) {}
+            try { standbyAudio.pause(); } catch (_error) {}
+            standbyVideo.muted = true;
+            standbyAudio.muted = true;
+            return true;
+        };
+        state.playerPreloadVideo = standbyVideo;
+        state.playerPreloadAudio = standbyAudio;
+        state.primePlayerNext = primeNextSegment;
+        const controls = element("div", "h3studio-player-controls");
+        const play = button(
+            "▶",
+            "Play or pause the planned timeline from the current position",
+            () => state.togglePlayerPlayback?.(),
+        );
+        const initialTimeline = timelineModel();
+        const slider = element("input"); slider.type = "range"; slider.min = "0"; slider.max = String(initialTimeline.totalSeconds); slider.step = String(1 / 24); slider.value = "0";
+        const clock = element("span", "h3studio-player-clock", `0 / ${formatClock(initialTimeline.totalSeconds)}`);
+        slider.addEventListener("input", () => seekTimeline(Number(slider.value), false));
+        const syncSource = () => {
+            const reference = sourceReference(state.playerIndex);
+            if (!reference || !sourceVideo.dataset.source) return;
+            sourceVideo.playbackRate = video.playbackRate;
+            const target = studioSourceSecond(reference, video.currentTime);
+            if (Math.abs(sourceVideo.currentTime - target) > .055) {
+                try { sourceVideo.currentTime = target; } catch (_error) {}
+            }
+        };
+        const synchronizeGeneratedAudio = (playAudio = false) => {
+            if (!generatedAudio.dataset.source) return;
+            generatedAudio.playbackRate = video.playbackRate;
+            if (Math.abs((Number(generatedAudio.currentTime) || 0) -
+                    (Number(video.currentTime) || 0)) > .12) {
+                try { generatedAudio.currentTime = video.currentTime; }
+                catch (_error) {}
+            }
+            if (playAudio && generatedToggle.checked) {
+                void generatedAudio.play().catch(() => {});
+            }
+        };
+        const playerTimelineSecond = () => {
+            const model = timelineModel();
+            // With no generated video, load() leaves currentTime at zero.
+            // Audio monitor/canplay sync must keep the editorial playhead,
+            // not turn that zero into a seek back to the scene's start.
+            if (!video.dataset.source) {
+                return Math.max(0, Math.min(
+                    model.totalSeconds, Number(state.timelinePosition) || 0,
+                ));
+            }
+            const clock = studioPlayerSegmentClock(
+                model.segments, state.playerSegmentKey,
+                Number(video.currentTime) || 0, FPS,
+            );
+            if (clock) return Math.min(model.totalSeconds, clock.timelineSeconds);
+            return Math.min(
+                model.totalSeconds,
+                studioEditorialSceneStartSeconds(model.segments, state.playerIndex) +
+                    (Number(video.currentTime) || 0),
+            );
+        };
+        const synchronizeSourceTimelineAudio = (
+            playAudio = false, timelineSecond = playerTimelineSecond(),
+        ) => {
+            const timelineAudio = sourceAudio();
+            if (!timelineAudio || !sourceTimelineAudio.dataset.source) return;
+            sourceTimelineAudio.playbackRate = video.playbackRate;
+            const target = studioSourceAudioSecond(
+                timelineAudio, timelineSecond,
+            );
+            if (Math.abs((Number(sourceTimelineAudio.currentTime) || 0) -
+                    target) > .12) {
+                try { sourceTimelineAudio.currentTime = target; }
+                catch (_error) {}
+            }
+            sourceTimelineAudio.muted =
+                !sourceToggle.checked ||
+                (!state.playerSegmentKey.startsWith("gap:")
+                    && sourceAudioMuted(state.playerIndex));
+            if (playAudio && sourceToggle.checked) {
+                void sourceTimelineAudio.play().catch(() => {});
+            }
+        };
+        const updateTransportPosition = (current) => {
+            const model = timelineModel();
+            const bounded = Math.max(0, Math.min(
+                model.totalSeconds, Number(current) || 0,
+            ));
+            state.timelinePosition = bounded;
+            slider.value = String(bounded);
+            clock.textContent = `${formatClock(bounded)} / ${formatClock(model.totalSeconds)}`;
+            positionTimelinePlayhead(bounded);
+            updateSubtitleOverlay(bounded);
+        };
+        const sourceTimelineSecond = () => {
+            const descriptor = sourceAudio();
+            if (!descriptor) return Number(state.timelinePosition) || 0;
+            return Math.max(
+                0,
+                (Number(sourceTimelineAudio.currentTime) || 0) -
+                    Math.max(0, Number(descriptor.seek_seconds) || 0),
+            );
+        };
+        let videoAdvancePending = false;
+        const advanceVideoSegment = (autoplay = true) => {
+            if (videoAdvancePending) return false;
+            const model = timelineModel();
+            const currentSegment = model.segments.findIndex(
+                (segment) => segment.key === state.playerSegmentKey,
+            );
+            const current = model.segments[currentSegment];
+            const next = model.segments[currentSegment + 1];
+            if (!current) return false;
+            videoAdvancePending = true;
+            stopMediaClock("video");
+            captureHandoffFrame();
+            generatedAudio.pause(); sourceVideo.pause();
+            updateTransportPosition(current.endSeconds);
+            if (!next) {
+                video.pause();
+                sourceTimelineAudio.pause();
+                play.textContent = "▶";
+                videoAdvancePending = false;
+                return false;
+            }
+            if (next.kind === "scene") promotePrimedSegment(next.sceneIndex);
+            seekTimeline(next.startSeconds, autoplay);
+            setTimeout(() => { videoAdvancePending = false; }, 0);
+            return true;
+        };
+        const refreshVideoTransport = () => {
+            if (!video.dataset.source) return;
+            const model = timelineModel();
+            const segmentClock = studioPlayerSegmentClock(
+                model.segments, state.playerSegmentKey,
+                Number(video.currentTime) || 0, FPS,
+            );
+            const current = segmentClock?.timelineSeconds
+                ?? playerTimelineSecond();
+            updateTransportPosition(current);
+            if (segmentClock?.boundaryReached && !video.paused) {
+                advanceVideoSegment(true);
+                return;
+            }
+            synchronizeGeneratedAudio(false);
+            synchronizeSourceTimelineAudio(false, current);
+            syncSource();
+        };
+        const refreshSourceTransport = () => {
+            if (!sourceAudio() || !sourceTimelineAudio.dataset.source) return;
+            const current = sourceTimelineSecond();
+            const model = timelineModel();
+            const location = locateStudioTimelineSegment(
+                model.segments, current,
+            );
+            if (location.index >= 0 &&
+                    location.key !== state.playerSegmentKey) {
+                seekTimeline(current, !sourceTimelineAudio.paused);
+            } else updateTransportPosition(current);
+        };
+        const stopMediaClock = (kind = null) => {
+            if (kind && state.mediaClockKind !== kind) return;
+            if (state.mediaClockFrame != null) {
+                cancelAnimationFrame(state.mediaClockFrame);
+                state.mediaClockFrame = null;
+            }
+            state.mediaClockKind = "";
+        };
+        const startMediaClock = (kind) => {
+            stopMediaClock();
+            stopEditorialClock();
+            state.mediaClockKind = kind;
+            const tick = () => {
+                if (!video.isConnected || state.player !== video ||
+                        state.mediaClockKind !== kind) {
+                    stopMediaClock(kind);
+                    return;
+                }
+                if (kind === "video") {
+                    if (video.paused || video.ended) {
+                        stopMediaClock(kind);
+                        return;
+                    }
+                    refreshVideoTransport();
+                } else {
+                    if (sourceTimelineAudio.paused ||
+                            sourceTimelineAudio.ended || video.dataset.source) {
+                        stopMediaClock(kind);
+                        return;
+                    }
+                    refreshSourceTransport();
+                }
+                state.mediaClockFrame = requestAnimationFrame(tick);
+            };
+            state.mediaClockFrame = requestAnimationFrame(tick);
+        };
+        const stopEditorialClock = () => {
+            if (state.editorialClockFrame == null) return;
+            cancelAnimationFrame(state.editorialClockFrame);
+            state.editorialClockFrame = null;
+        };
+        const startEditorialClock = () => {
+            stopEditorialClock();
+            stopMediaClock();
+            const originPosition = Number(state.timelinePosition) || 0;
+            const originTime = performance.now();
+            const tick = (now) => {
+                if (!video.isConnected || state.player !== video) return;
+                let model = timelineModel();
+                const unbounded =
+                    originPosition + (now - originTime) / 1000;
+                if (unbounded >= model.totalSeconds - 1 / FPS) {
+                    extendTimelineWorkspace(
+                        model.workspaceEndFrame + state.timelineSceneEndFrame,
+                    );
+                    model = timelineModel();
+                }
+                const current = Math.min(
+                    model.totalSeconds,
+                    unbounded,
+                );
+                const location = locateStudioTimelineSegment(
+                    model.segments, current,
+                );
+                if (location.key !== state.playerSegmentKey) {
+                    state.editorialClockFrame = null;
+                    seekTimeline(current, true);
+                    return;
+                }
+                updateTransportPosition(current);
+                if (current >= model.totalSeconds) {
+                    state.editorialClockFrame = null;
+                    play.textContent = "▶";
+                    return;
+                }
+                state.editorialClockFrame = requestAnimationFrame(tick);
+            };
+            play.textContent = "❚❚";
+            state.editorialClockFrame = requestAnimationFrame(tick);
+        };
+        const playPlayerTransport = () => {
+            stopEditorialClock();
+            if (video.dataset.source) {
+                return video.play().catch(() => {});
+            }
+            if (!sourceTimelineAudio.dataset.source) {
+                startEditorialClock();
+                return undefined;
+            }
+            const timelineAudio = sourceAudio();
+            const availableSeconds = Number(
+                timelineAudio?.available_duration_seconds
+                    ?? timelineAudio?.duration_seconds,
+            ) || 0;
+            if ((Number(state.timelinePosition) || 0) >=
+                    availableSeconds - 1 / FPS) {
+                startEditorialClock();
+                return undefined;
+            }
+            synchronizeSourceTimelineAudio(
+                false, state.timelinePosition ?? 0,
+            );
+            play.textContent = "❚❚";
+            return sourceTimelineAudio.play().catch(() => {
+                play.textContent = "▶";
+            });
+        };
+        const togglePlayerPlayback = () => {
+            if (video.dataset.source) {
+                if (video.paused) void playPlayerTransport();
+                else {
+                    video.pause();
+                    pausePlayerMonitors();
+                }
+                return;
+            }
+            if (!sourceTimelineAudio.dataset.source) {
+                if (state.editorialClockFrame == null) startEditorialClock();
+                else { stopEditorialClock(); play.textContent = "▶"; }
+                return;
+            }
+            if (sourceTimelineAudio.paused) void playPlayerTransport();
+            else {
+                sourceTimelineAudio.pause();
+                generatedAudio.pause(); sourceVideo.pause();
+            }
+        };
+        state.playPlayerTransport = playPlayerTransport;
+        state.togglePlayerPlayback = togglePlayerPlayback;
+        const transportVideos = [video, standbyVideo];
+        const generatedAudios = [generatedAudio, standbyAudio];
+        const onActiveVideo = (eventName, listener) => {
+            for (const player of transportVideos) {
+                player.addEventListener(eventName, (event) => {
+                    if (event.currentTarget !== video) return;
+                    listener(event);
+                });
+            }
+        };
+        const onActiveGeneratedAudio = (eventName, listener) => {
+            for (const player of generatedAudios) {
+                player.addEventListener(eventName, (event) => {
+                    if (event.currentTarget !== generatedAudio) return;
+                    listener(event);
+                });
+            }
+        };
+        onActiveVideo("play", () => {
+            play.textContent = "❚❚";
+            syncSource(); synchronizeGeneratedAudio(true);
+            synchronizeSourceTimelineAudio(true);
+            if (sourceVideo.dataset.source) void sourceVideo.play().catch(() => {});
+        });
+        onActiveVideo("playing", () => {
+            releaseHandoffFrame();
+            startMediaClock("video");
+        });
+        onActiveVideo("pause", () => {
+            stopMediaClock("video");
+            const model = timelineModel();
+            const currentSegment = model.segments.findIndex(
+                (segment) => segment.key === state.playerSegmentKey,
+            );
+            const upcoming = model.segments[currentSegment + 1];
+            if (video.ended && upcoming?.kind === "scene" &&
+                    primedSegmentReady(upcoming.sceneIndex)) {
+                generatedAudio.pause(); sourceVideo.pause();
+                return;
+            }
+            play.textContent = "▶";
+            // The source track is a monitor slaved to the video transport.
+            // Always stop it on pause; automatic scene handoff will restart it
+            // from the next absolute timeline position when video fires play.
+            pausePlayerMonitors();
+        });
+        onActiveVideo("waiting", () => {
+            stopMediaClock("video");
+            generatedAudio.pause(); sourceTimelineAudio.pause(); sourceVideo.pause();
+        });
+        onActiveGeneratedAudio("canplay", () => {
+            synchronizeGeneratedAudio(!video.paused);
+        });
+        sourceVideo.addEventListener("canplay", () => {
+            syncSource();
+            if (!video.paused) void sourceVideo.play().catch(() => {});
+        });
+        sourceTimelineAudio.addEventListener("canplay", () => {
+            synchronizeSourceTimelineAudio(!video.paused);
+        });
+        sourceTimelineAudio.addEventListener("play", () => {
+            if (!video.dataset.source) {
+                play.textContent = "❚❚";
+                startMediaClock("source");
+            }
+        });
+        sourceTimelineAudio.addEventListener("pause", () => {
+            stopMediaClock("source");
+            if (!video.dataset.source) play.textContent = "▶";
+        });
+        onActiveVideo("seeking", () => {
+            generatedAudio.pause(); sourceTimelineAudio.pause(); sourceVideo.pause();
+            synchronizeGeneratedAudio(false); synchronizeSourceTimelineAudio(false);
+            syncSource();
+        });
+        onActiveVideo("seeked", () => {
+            synchronizeGeneratedAudio(!video.paused);
+            synchronizeSourceTimelineAudio(!video.paused); syncSource();
+            if (!video.paused && sourceVideo.dataset.source) {
+                void sourceVideo.play().catch(() => {});
+            }
+        });
+        onActiveVideo("ratechange", () => {
+            synchronizeGeneratedAudio(false);
+            synchronizeSourceTimelineAudio(false); syncSource();
+        });
+        // timeupdate is only a low-frequency fallback. The visible transport
+        // is driven from requestAnimationFrame while media is playing so its
+        // clock and red timeline line remain on the same frame.
+        onActiveVideo("timeupdate", refreshVideoTransport);
+        sourceTimelineAudio.addEventListener("timeupdate", () => {
+            if (video.dataset.source) return;
+            refreshSourceTransport();
+        });
+        sourceTimelineAudio.addEventListener("ended", () => {
+            if (video.dataset.source) return;
+            stopMediaClock("source");
+            const descriptor = sourceAudio();
+            const current = Math.max(0, Number(
+                descriptor?.available_duration_seconds
+                    ?? descriptor?.duration_seconds,
+            ) || state.timelinePosition || 0);
+            updateTransportPosition(current);
+            startEditorialClock();
+        });
+        onActiveVideo("ended", () => {
+            advanceVideoSegment(true);
+        });
+        const compareControls = element("div", "h3studio-compare-controls");
+        const wipeLabel = element("span", "h3studio-wipe-label", "Wipe");
+        const wipe = element("input", "h3studio-wipe-control");
+        wipe.type = "range"; wipe.min = "0"; wipe.max = "100";
+        wipe.step = "1"; wipe.value = "50";
+        wipe.addEventListener("input", () => {
+            const percent = Number(wipe.value);
+            sourceLayer.style.clipPath = `inset(0 ${100 - percent}% 0 0)`;
+            wipeLine.style.left = `${percent}%`;
+        });
+        const audioMix = element("div", "h3studio-audio-mix");
+        const applyAudioVolumes = () => {
+            video.volume = state.generatedVolume;
+            generatedAudio.volume = state.generatedVolume;
+            sourceTimelineAudio.volume = state.sourceVolume;
+            sourceVideo.volume = state.motionVolume;
+        };
+        const audioToggle = (
+            className, text, checked, propertyName, stateName,
+        ) => {
+            const control = element("div", "h3studio-audio-control");
+            const wrapper = element("label", "h3studio-audio-toggle");
+            const input = element("input", className);
+            input.type = "checkbox"; input.checked = checked;
+            const copy = element("span", "", text);
+            wrapper.append(input, copy);
+            const volume = element("input", "h3studio-audio-volume");
+            volume.type = "range"; volume.min = "0"; volume.max = "1";
+            volume.step = ".01"; volume.value = String(state[stateName]);
+            volume.title = `${text} monitor volume`;
+            const level = element(
+                "span", "h3studio-audio-level",
+                `${Math.round(state[stateName] * 100)}%`,
+            );
+            volume.addEventListener("input", () => {
+                state[stateName] = Math.max(0, Math.min(1,
+                    Number(volume.value) || 0));
+                level.textContent = `${Math.round(state[stateName] * 100)}%`;
+                applyAudioVolumes();
+            });
+            volume.addEventListener("change", () => {
+                node.properties[propertyName] = state[stateName];
+                dirty();
+            });
+            control.append(wrapper, volume, level);
+            return {wrapper:control, input, copy, volume};
+        };
+        const generatedControl = audioToggle(
+            "h3studio-audio-generated", "Generated", true,
+            GENERATED_VOLUME_PROPERTY, "generatedVolume",
+        );
+        const sourceControl = audioToggle(
+            "h3studio-audio-source", "Source track", true,
+            SOURCE_VOLUME_PROPERTY, "sourceVolume",
+        );
+        const motionControl = audioToggle(
+            "h3studio-audio-motion", "Motion-ref", false,
+            MOTION_VOLUME_PROPERTY, "motionVolume",
+        );
+        const generatedToggle = generatedControl.input;
+        const sourceToggle = sourceControl.input;
+        const motionToggle = motionControl.input;
+        const applyAudioMix = () => {
+            applyAudioVolumes();
+            video.muted = !generatedToggle.checked ||
+                Boolean(generatedAudio.dataset.source);
+            generatedAudio.muted = !generatedToggle.checked;
+            sourceVideo.muted = !motionToggle.checked;
+            sourceTimelineAudio.muted = !sourceToggle.checked ||
+                (!state.playerSegmentKey.startsWith("gap:")
+                    && sourceAudioMuted(state.playerIndex));
+            if (generatedToggle.checked) {
+                synchronizeGeneratedAudio(!video.paused);
+            } else {
+                generatedAudio.pause();
+            }
+            if (sourceToggle.checked) {
+                synchronizeSourceTimelineAudio(!video.paused);
+            } else {
+                sourceTimelineAudio.pause();
+            }
+        };
+        for (const control of [
+            generatedControl, sourceControl, motionControl,
+        ]) {
+            control.input.addEventListener("change", applyAudioMix);
+            audioMix.append(control.wrapper);
+        }
+        applyAudioVolumes();
+        compareControls.append(wipeLabel, wipe, audioMix);
+        state.player = video; state.playerAudio = generatedAudio;
+        state.sourceAudioPlayer = sourceTimelineAudio;
+        state.sourcePlayer = sourceVideo;
+        state.sourceLayer = sourceLayer; state.subtitleOverlay = subtitleOverlay;
+        state.playerSlider = slider;
+        controls.append(play, slider, clock, button("Refresh", "Rescan saved checkpoints and segments", async () => {
+            await refreshCheckpoints(); renderPanel();
+        }));
+        wrapper.append(
+            label, stage, generatedAudio, sourceTimelineAudio,
+            preloadAudio,
+            compareControls, controls,
+            element("div", "h3studio-message", "Generated and Source Track can play together on the planned timeline. Adjacent saved scenes are pre-decoded in a second player for a smooth boundary handoff; this preview behavior never changes the saved clips or final assembly. Before a scene is rendered, Source Track playback supplies the timeline clock; playback hands back to video automatically when a saved segment begins. Each monitor has independent volume; waveform speaker buttons mute only the Source Track for that scene. Click the player and press Space to play or pause. Motion-ref audio is optional when available."),
+        );
+        setTimeout(() => {
+            if (state.player !== video || !video.isConnected) return;
+            const result = timing();
+            const start = state.timelinePosition == null
+                ? studioEditorialSceneStartSeconds(
+                    timelineModel().segments, state.active,
+                )
+                : state.timelinePosition;
+            seekTimeline(start, false);
+        }, 0);
+        return wrapper;
+    }
+
+    function renderSubtitlesPanel() {
+        const panel = element("div");
+        const head = element("div", "h3studio-scene-head");
+        head.append(
+            element("strong", "", "Timed lyrics / subtitles"),
+            element("span", "h3studio-scene-label",
+                "Editorial only · previewed here and exported as SRT beside final assembly"),
+        );
+        const settingsHost = element("div", "h3studio-subtitle-settings");
+        const assetSelect = element("select");
+        const none = element("option", "", state.subtitleAssets.length
+            ? "Choose an audio asset with timed lyrics" : "No timed-lyrics audio assets found");
+        none.value = ""; assetSelect.append(none);
+        for (const asset of state.subtitleAssets) {
+            const cues = parseTimedLyrics(asset.lyrics);
+            const option = element(
+                "option", "",
+                `@${asset.tag || "audio"} · ${cues.length} timed cue${cues.length === 1 ? "" : "s"}`,
+            );
+            option.value = String(asset.id ?? "");
+            assetSelect.append(option);
+        }
+        assetSelect.value = String(state.editorial.subtitles?.asset_id ?? "");
+        assetSelect.title = "Audio assets become available here when their Lyrics field contains LRC timestamps such as [01:23.45] or SRT cue blocks.";
+        const mode = element("select");
+        for (const [value, label] of [
+            ["off", "Off"],
+            ["preview_srt", "Preview + SRT sidecar"],
+        ]) {
+            const option = element("option", "", label);
+            option.value = value; mode.append(option);
+        }
+        mode.value = state.editorial.subtitles?.mode ?? "off";
+        mode.title = "Preview + SRT shows timed lyrics in Plan Studio and writes a matching .srt file beside each final assembled video. It does not burn text into pixels.";
+        const offset = element("input");
+        offset.type = "number"; offset.min = "-3600"; offset.max = "3600";
+        offset.step = String(1 / FPS);
+        offset.value = String(state.editorial.subtitles?.offset_seconds ?? 0);
+        offset.title = "Shift every subtitle on the editorial timeline. Positive values display later; negative values display earlier.";
+        const save = () => {
+            state.editorial.subtitles = {
+                mode:mode.value,
+                asset_id:assetSelect.value,
+                offset_seconds:Math.max(-3600, Math.min(
+                    3600, Number(offset.value) || 0,
+                )),
+            };
+            scheduleEditorialSave();
+            renderSubtitleTimeline();
+            updateSubtitleOverlay();
+        };
+        mode.addEventListener("change", () => { save(); renderPanel(); });
+        assetSelect.addEventListener("change", () => { save(); renderPanel(); });
+        offset.addEventListener("change", () => { save(); renderPanel(); });
+        settingsHost.append(
+            field("Lyrics asset", assetSelect),
+            field("Output", mode),
+            field("Timeline offset (s)", offset),
+        );
+        const actions = element("div", "h3studio-prompt-tools");
+        actions.append(
+            button("Refresh assets", "Reload lyrics from Project Asset Carousel", () => {
+                void loadSubtitleAssets();
+            }),
+            element("span", "h3studio-hint",
+                "Use [MM:SS.xx] at the beginning of lyric lines, or paste SRT. The Asset Carousel player includes a Stamp line button for live timing."),
+        );
+        const cues = subtitleCues();
+        const list = element("div", "h3studio-subtitle-list");
+        if (!selectedSubtitleAsset()) list.append(element(
+            "div", "h3studio-message",
+            "Choose an audio asset whose Lyrics field contains timestamps.",
+        ));
+        else if (!cues.length) list.append(element(
+            "div", "h3studio-error",
+            "This Lyrics field has no LRC or SRT timestamps yet.",
+        ));
+        else for (const cue of cues.slice(0, 500)) {
+            list.append(element("div", "h3studio-subtitle-row", ""));
+            list.lastElementChild.append(
+                element("span", "h3studio-hint",
+                    `${formatClock(cue.startSeconds)} → ${formatClock(cue.endSeconds)}`),
+                element("span", "", cue.text),
+            );
+        }
+        panel.append(head, settingsHost, actions, list);
+        return panel;
+    }
+
+    function renderJsonPanel() {
+        const panel = element("div");
+        const textarea = element("textarea", "h3studio-json"); textarea.value = planToJson(state.plan); textarea.spellcheck = false;
+        const status = element("span", "h3studio-message", "Raw JSON escape hatch");
+        const actions = element("div", "h3studio-json-actions");
+        actions.append(button("Apply JSON", "Validate and replace the current plan JSON", () => {
+            try { state.plan = parsePlanJson(textarea.value); state.active = Math.min(state.active, state.plan.shots.length - 1); writePlan(); status.textContent = "JSON applied"; renderShell(); publishActiveScene(); }
+            catch (error) { status.textContent = error.message; status.classList.add("h3studio-error"); }
+        }), button("Copy", "Copy plan JSON", async () => {
+            try { await navigator.clipboard.writeText(textarea.value); status.textContent = "Copied"; }
+            catch (_error) { textarea.select(); document.execCommand("copy"); status.textContent = "Copied"; }
+        }), status);
+        panel.append(textarea, actions); return panel;
+    }
+
+    function renderPanel() {
+        if (!state.panelHost || !state.plan) return;
+        state.history.host = null; state.history.textarea = null; state.history.status = null;
+        disposePlayer();
+        const content = state.view === "scene" && state.activeChapterId
+            ? renderChapterPanel()
+            : state.view === "shared" ? renderSharedPanel()
+            : state.view === "settings" ? renderPlanSettingsPanel()
+            : state.view === "context" ? renderContextPanel()
+            : state.view === "player" ? renderPlayerPanel()
+            : state.view === "subtitles" ? renderSubtitlesPanel()
+              : state.view === "json" ? renderJsonPanel() : renderScenePanel();
+        state.panelHost.replaceChildren(content);
+    }
+
+    function renderToolbarState() {
+        for (const item of root.querySelectorAll("[data-studio-view]")) {
+            item.classList.toggle("h3studio-active", item.dataset.studioView === state.view);
+        }
+    }
+
+    function renderShell() {
+        const timelineScroll = timelineScrollSnapshot();
+        // Rebuilding the Studio must never pan the editorial timeline. Scene
+        // selection already reveals a card when the user explicitly chooses
+        // it; passive rerenders keep the scrollbar exactly where it was.
+        const revealTimelineActive = false;
+        disposePlayer();
+        state.timelineResizeObserver?.disconnect();
+        state.timelineResizeObserver = null;
+        root.replaceChildren();
+        const head = element("div", "h3studio-head");
+        head.append(element("span", "h3studio-title", "MiniMax H3 Plan Studio"),
+            element("span", "h3studio-run", runName()
+                ? `${state.planNode ? "linked" : "standalone"} · ${runName()}`
+                : "name this run in Plan settings"));
+        const toolbar = element("div", "h3studio-toolbar");
+        const add = button("+ Scene", "Append a new scene and select it", async () => {
+            if (state.plan.shots.length >= MAX_SHOTS) return;
+            await flushHistoryDraft();
+            state.plan.shots.push(makeShot(state.plan.shots));
+            state.activeChapterId = "";
+            state.active = state.plan.shots.length - 1;
+            state.timelinePosition = null; persistView(); writePlan(); renderShell(); publishActiveScene();
+        });
+        add.disabled = state.plan.shots.length >= MAX_SHOTS;
+        const addChapter = button("+ Chapter", "Add a zero-duration chapter marker before the selected scene", async () => {
+            await flushHistoryDraft();
+            try {
+                const chapter = makeChapter(state.plan, state.active);
+                state.activeChapterId = chapter.id;
+                state.view = "scene";
+                persistView(); writePlan(); renderShell();
+            } catch (error) {
+                console.warn(error);
+            }
+        });
+        const duplicate = button("Duplicate", "Duplicate the selected scene", async () => {
+            if (state.plan.shots.length >= MAX_SHOTS) return;
+            await flushHistoryDraft();
+            preserveDelegatedPrompts();
+            duplicateShot(state.plan.shots, state.active); state.active += 1;
+            state.activeChapterId = "";
+            state.timelinePosition = null; persistView(); writePlan(); renderShell(); publishActiveScene();
+        });
+        const remove = button(state.activeChapterId ? "Delete chapter" : "Delete", "Delete the selected scene or chapter", async () => {
+            if (state.activeChapterId) {
+                const chapter = orderedChapters(state.plan).find(
+                    (candidate) => candidate.id === state.activeChapterId,
+                );
+                if (!chapter || !confirm(`Delete ${chapter.title}?`)) return;
+                state.plan.chapters = state.plan.chapters.filter(
+                    (candidate) => candidate.id !== chapter.id,
+                );
+                if (!state.plan.chapters.length) delete state.plan.chapters;
+                state.activeChapterId = "";
+                persistView(); writePlan(); renderShell();
+                return;
+            }
+            if (state.plan.shots.length <= 1 || !confirm(`Delete scene ${state.active + 1}?`)) return;
+            await flushHistoryDraft();
+            removePlanShot(state.plan, state.active);
+            state.editorial = normalizedEditorial(state.editorial);
+            state.active = Math.min(state.active, state.plan.shots.length - 1);
+            state.timelinePosition = null; persistView(); writePlan(); renderShell(); publishActiveScene();
+        });
+        remove.disabled = !state.activeChapterId && state.plan.shots.length <= 1;
+        const left = button("←", "Move selected scene earlier", async () => {
+            if (!state.active || sceneLocked(state.active)) return; await flushHistoryDraft();
+            moveShot(state.plan.shots, state.active, state.active - 1); state.active -= 1;
+            state.timelinePosition = null; persistView(); writePlan(); renderShell(); publishActiveScene();
+        }); left.disabled = Boolean(state.activeChapterId) || !state.active
+            || sceneLocked(state.active);
+        const right = button("→", "Move selected scene later", async () => {
+            if (state.active >= state.plan.shots.length - 1
+                    || sceneLocked(state.active)) return; await flushHistoryDraft();
+            moveShot(state.plan.shots, state.active, state.active + 1); state.active += 1;
+            state.timelinePosition = null; persistView(); writePlan(); renderShell(); publishActiveScene();
+        }); right.disabled = Boolean(state.activeChapterId)
+            || state.active >= state.plan.shots.length - 1
+            || sceneLocked(state.active);
+        toolbar.append(add, addChapter, duplicate, remove, left, right, element("span", "h3studio-spacer"));
+        const sceneViewLabel = state.activeChapterId
+            ? "Chapter notes"
+            : state.promptEditors.length ? "Scene settings" : "Scene prompt";
+        for (const [value,label] of [["scene",sceneViewLabel],["shared","Shared prompt"],
+            ["settings","Plan settings"],["context","Context"],
+            ["player","Player"],["subtitles","Subtitles"],["json","JSON"]]) {
+            const item = button(label, `Open ${label.toLowerCase()} view`, () => {
+                void flushHistoryDraft();
+                if (value === "player" && state.timelinePosition == null) {
+                    state.timelinePosition = studioEditorialSceneStartSeconds(
+                        timelineModel().segments, state.active,
+                    );
+                }
+                state.view = value; persistView(); renderToolbarState();
+                renderSourceTimeline(); renderSourceAudioTimeline(); renderPanel();
+                if (value === "subtitles") void loadSubtitleAssets();
+            });
+            item.dataset.studioView = value; toolbar.append(item);
+        }
+        const status = element("div", "h3studio-statusline");
+        const shell = element("div", "h3studio-timeline-shell");
+        const timelineTools = element("div", "h3studio-timeline-tools");
+        const zoomOut = button(
+            "−", "Zoom timeline out", () => setTimelineZoom(
+                state.timelineZoom - .25,
+            ),
+        );
+        const zoomInput = element("input", "h3studio-timeline-zoom");
+        zoomInput.type = "range";
+        zoomInput.min = "1";
+        zoomInput.max = "6";
+        zoomInput.step = ".05";
+        zoomInput.value = String(state.timelineZoom);
+        zoomInput.title = "Timeline zoom · Ctrl/Cmd + wheel over the timeline";
+        zoomInput.addEventListener("input", () => {
+            setTimelineZoom(zoomInput.value);
+        });
+        const zoomLabel = element(
+            "span", "h3studio-zoom-label",
+            `${Math.round(state.timelineZoom * 100)}%`,
+        );
+        const zoomIn = button(
+            "+", "Zoom timeline in", () => setTimelineZoom(
+                state.timelineZoom + .25,
+            ),
+        );
+        const fit = button("Fit", "Fit timeline to the available width", () => {
+            setTimelineZoom(1);
+        });
+        const lockedCount = state.editorial.locked_scene_ids.length;
+        const unlockAll = button(
+            `Unlock all (${lockedCount})`,
+            "Unlock every scene without changing its current editorial position",
+            unlockAllScenes,
+        );
+        unlockAll.hidden = !lockedCount;
+        timelineTools.append(
+            element("strong", "", "Timeline"),
+            unlockAll,
+            element("span", "h3studio-spacer"),
+            zoomOut, zoomInput, zoomLabel, zoomIn, fit,
+        );
+        const timelineGrid = element("div", "h3studio-timeline-grid");
+        const timelineLabels = element("div", "h3studio-timeline-labels");
+        timelineLabels.append(
+            element("span", "", "TIME"),
+            element("span", "", "GENERATED"),
+            element("span", "", "MOTION REF"),
+            element("span", "", "SOURCE AUDIO"),
+            element("span", "", "SUBTITLES"),
+        );
+        const timelineViewport = element("div", "h3studio-timeline-viewport");
+        const timelineContent = element("div", "h3studio-timeline-content");
+        const ruler = element("div", "h3studio-ruler");
+        const timelineHost = element("div", "h3studio-timeline h3studio-generated-timeline");
+        const sourceTimelineHost = element("div", "h3studio-timeline");
+        const sourceAudioTimelineHost = element(
+            "div", "h3studio-timeline h3studio-audio-timeline",
+        );
+        const subtitleTimelineHost = element(
+            "div", "h3studio-subtitle-timeline",
+        );
+        timelineContent.append(
+            ruler, timelineHost, sourceTimelineHost, sourceAudioTimelineHost,
+            subtitleTimelineHost,
+        );
+        timelineViewport.append(timelineContent);
+        timelineGrid.append(timelineLabels, timelineViewport);
+        shell.append(timelineTools, timelineGrid);
+        state.timelineHost = timelineHost;
+        state.sourceTimelineHost = sourceTimelineHost;
+        state.sourceAudioTimelineHost = sourceAudioTimelineHost;
+        state.subtitleTimelineHost = subtitleTimelineHost;
+        state.sourceTrack = sourceTimelineHost;
+        state.sourceAudioTrack = sourceAudioTimelineHost;
+        state.timelineViewport = timelineViewport;
+        state.timelineContent = timelineContent;
+        state.timelineRuler = ruler;
+        state.timelineZoomInput = zoomInput;
+        state.timelineZoomLabel = zoomLabel;
+        state.timelineScrollIntentUntil = 0;
+        state.timelineLastScrollLeft = timelineViewport.scrollLeft;
+        const noteTimelineScrollIntent = (duration = 1200) => {
+            state.timelineScrollIntentUntil = performance.now() + duration;
+        };
+        timelineViewport.addEventListener("pointerdown", (event) => {
+            if (event.target === timelineViewport || event.pointerType === "touch") {
+                noteTimelineScrollIntent(2000);
+            }
+        }, {passive:true});
+        timelineViewport.addEventListener("wheel", (event) => {
+            const horizontalDelta = event.shiftKey ? event.deltaY : event.deltaX;
+            if (horizontalDelta > 0) noteTimelineScrollIntent();
+            if (event.ctrlKey || event.metaKey) {
+                event.preventDefault();
+                const rect = timelineViewport.getBoundingClientRect();
+                const anchor = rect.width > 0
+                    ? (event.clientX - rect.left) / rect.width : .5;
+                setTimelineZoom(
+                    state.timelineZoom * Math.exp(-event.deltaY * .0025),
+                    anchor,
+                );
+            } else if (event.shiftKey && event.deltaY) {
+                event.preventDefault();
+                timelineViewport.scrollLeft += event.deltaY;
+            }
+        }, {passive:false});
+        timelineViewport.addEventListener("scroll", () => {
+            const currentScrollLeft = timelineViewport.scrollLeft;
+            const movingRight = currentScrollLeft >
+                state.timelineLastScrollLeft + .5;
+            state.timelineLastScrollLeft = currentScrollLeft;
+            if (state.timelineDragging || state.timelineExtending
+                    || !movingRight
+                    || performance.now() > state.timelineScrollIntentUntil) return;
+            if (timelineViewport.scrollLeft + timelineViewport.clientWidth <
+                    timelineViewport.scrollWidth - 32) return;
+            extendTimelineWorkspace();
+        }, {passive:true});
+        if (typeof ResizeObserver === "function") {
+            state.timelineResizeObserver = new ResizeObserver(() => {
+                layoutTimeline({preserveScroll:true});
+            });
+            state.timelineResizeObserver.observe(timelineViewport);
+        }
+        const panelHost = element("div", "h3studio-panel"); state.panelHost = panelHost;
+        root.append(head, toolbar, status, shell, panelHost);
+        renderToolbarState(); renderStatus();
+        renderTimeline({
+            revealActive:revealTimelineActive,
+            restoreScroll:timelineScroll,
+        });
+        renderPanel();
+    }
+
+    function showFailure(message) {
+        disposePlayer();
+        root.replaceChildren(element("div", "h3studio-title", "MiniMax H3 Plan Studio"),
+            element("div", "h3studio-error", message),
+            element("div", "h3studio-message", "Repair the JSON tab or connect a valid H3 Chain Plan. Studio can operate in either mode."));
+    }
+
+    function loadPlan(force = false) {
+        const planNode = upstreamPlanNode(node);
+        if (planNode) mirrorConnectedPlan(planNode);
+        const planOwner = planNode ?? node;
+        const planWidget = widget(planOwner, "plan_json");
+        if (!planWidget) {
+            if (force || state.planOwner) {
+                state.plan = null; state.planNode = null;
+                state.planOwner = null; state.planWidget = null;
+                showFailure("Plan Studio's internal Plan fields are unavailable.");
+            }
+            return;
+        }
+        const value = String(planWidget.value ?? "");
+        const currentRun = String(widget(planOwner, "run_name")?.value ?? "").trim();
+        const currentSettings = settingsSignature(planOwner);
+        const promptEditors = planNode ? connectedPromptEditors(node).filter(
+            (editor) => upstreamPlanNode(editor) === planNode,
+        ) : [];
+        const currentPromptEditors = promptEditorsSignature(promptEditors);
+        if (!force && planOwner === state.planOwner && value === state.lastValue
+                && currentRun === state.lastRunName
+                && currentSettings === state.lastSettingsSignature
+                && currentPromptEditors === state.lastPromptEditorsSignature) return;
+        try {
+            const runChanged = planOwner !== state.planOwner || currentRun !== state.lastRunName;
+            const previousRun = state.lastRunName;
+            if (runChanged && previousRun) {
+                void flushProjectWrites(previousRun).catch((error) => {
+                    console.warn(
+                        "H3 Plan Studio could not flush the previous Run " +
+                        "before switching:", error,
+                    );
+                });
+            }
+            state.plan = parsePlanJson(value); state.planNode = planNode;
+            state.planOwner = planOwner; state.planWidget = planWidget;
+            state.lastValue = value; state.lastRunName = currentRun;
+            state.lastSettingsSignature = currentSettings;
+            state.promptEditors = promptEditors;
+            state.lastPromptEditorsSignature = currentPromptEditors;
+            if (state.activeChapterId && !orderedChapters(state.plan).some(
+                (chapter) => chapter.id === state.activeChapterId,
+            )) state.activeChapterId = "";
+            if (runChanged) {
+                const cached = restoreStudioCheckpointCache(
+                    node.properties[CHECKPOINT_CACHE_PROPERTY], currentRun,
+                );
+                const cachedRecords = cached?.checkpoints ?? [];
+                state.checkpoints = new Map(cachedRecords.map(
+                    (item) => [Number(item.scene), item],
+                ));
+                state.checkpointSignature = cached
+                    ? studioCheckpointSignature(currentRun, cachedRecords) : "";
+                state.checkpointError = ""; state.timelinePosition = null;
+                state.editorialReady = false; state.editorialRun = "";
+                state.editorialBindingError = "";
+                state.editorialSaveError = "";
+                state.editorialUnusedSceneIds = [];
+                state.editorial = cached?.editorial
+                    ? normalizedEditorial(cached.editorial)
+                    : {revision:"", placements:[], trims:[], locked_scene_ids:[], subtitles:{
+                        mode:"off", asset_id:"", offset_seconds:0,
+                    }, alternate_draft:null, replacements:[]};
+                if (cached?.editorial) state.editorialRun = currentRun;
+                state.timelineWorkspaceEndFrame = 0;
+                state.timelineSceneEndFrame = 0;
+                state.timelineRenderedActive = null;
+                state.timelineViewport = null;
+                state.timelineContent = null;
+                state.lastEditorialSignature = "";
+                state.subtitleAssets = []; state.subtitleAssetsRun = "";
+                state.subtitleAssetsToken += 1;
+                state.presentationToken += 1;
+                state.sourcePreview = null;
+                state.sourceWaveform = null; state.sourceWaveformToken = "";
+                state.sourceWaveformPromise = null;
+            }
+            state.active = Math.min(state.active, state.plan.shots.length - 1);
+            // Always synchronize the hidden one-shot queue widget on load.
+            // Editorial data is useful even when the Plan has no chapters.
+            syncAlternateTakeWidget();
+            renderShell(); void refreshCheckpoints();
+            if (runChanged && currentRun) {
+                void restoreSourcePresentation();
+                void loadSubtitleAssets();
+            }
+        } catch (error) {
+            showFailure(`${planNode ? "Connected Plan" : "Standalone Plan Studio"} JSON is invalid:\n${error.message}`);
+        }
+    }
+
+    const domWidget = node.addDOMWidget("h3_plan_studio", "h3-plan-studio", root, {
+        serialize:false, hideOnZoom:false, getMinHeight:() => 540,
+    });
+    domWidget.serialize = false;
+    node.setSize?.([Math.max(Number(node.size?.[0]) || 0, MIN_WIDTH), Math.max(Number(node.size?.[1]) || 0, MIN_HEIGHT)]);
+    const connectionsChanged = node.onConnectionsChange;
+    node.onConnectionsChange = function () {
+        const result = connectionsChanged?.apply(this, arguments);
+        setTimeout(() => { loadPlan(true); publishActiveScene(); }, 0);
+        return result;
+    };
+    const onPromptExecuted = (event) => {
+        const sourceValues = event.detail?.output?.h3_plan_studio_source_timeline;
+        const sourcePayload = Array.isArray(sourceValues) ? sourceValues.at(-1) : null;
+        const displayNode = event.detail?.display_node ?? event.detail?.node;
+        if (sourcePayload && String(displayNode ?? "") === String(node.id ?? "")
+                && String(sourcePayload.run_name ?? "") === runName()) {
+            state.presentationToken += 1;
+            applySourcePresentation(sourcePayload);
+        }
+        // Plan Studio executes near the start of a recursive queue, while the
+        // alternate is accepted by Loop End. Refresh after later node events
+        // so the armed draft becomes the selected ALT without waiting for the
+        // periodic poll (the refresh queue coalesces repeated events).
+        if (state.editorial.alternate_draft) {
+            setTimeout(() => void refreshCheckpoints(), 250);
+        }
+        const values = event.detail?.output?.h3_chain_active_scene;
+        const scene = Array.isArray(values) ? values.at(-1) : null;
+        if (!scene || String(scene.run_name ?? "") !== runName()) return;
+        const shot = state.plan?.shots?.[state.active];
+        const sceneId = safeShotId(
+            shot?.id, `clip_${String(state.active + 1).padStart(4, "0")}`,
+        );
+        if (String(scene.shot_id ?? "") !== sceneId) return;
+        setTimeout(() => {
+            if (state.view !== "scene" || state.history.sceneKey !== historyKey(sceneId)) return;
+            void loadHistory(sceneId, promptValueToText(shot.prompt), false);
+        }, 50);
+    };
+    api.addEventListener("executed", onPromptExecuted);
+    const onLoRARoutesChanged = () => {
+        if (!state.disposed && state.plan) {
+            renderPanel();
+            renderTimeline();
+        }
+    };
+    document.addEventListener("h3-lora-routes-changed", onLoRARoutesChanged);
+    node._h3FlushProjectWrites = flushProjectWrites;
+    const removed = node.onRemoved;
+    node.onRemoved = function () {
+        const finalFlush = flushProjectWrites(runName());
+        state.disposed = true;
+        state.checkpointToken += 1;
+        state.presentationToken += 1;
+        if (state.pollTimer != null) clearInterval(state.pollTimer);
+        if (state.checkpointTimer != null) clearInterval(state.checkpointTimer);
+        if (state.planNotifyTimer != null) clearTimeout(state.planNotifyTimer);
+        if (state.editorialTimer != null) clearTimeout(state.editorialTimer);
+        state.timelineResizeObserver?.disconnect();
+        api.removeEventListener("executed", onPromptExecuted);
+        document.removeEventListener(
+            "h3-lora-routes-changed", onLoRARoutesChanged);
+        document.removeEventListener("keydown", onPlayerKeydown, true);
+        delete node._h3PromptCompanionSetActiveScene;
+        delete node._h3PromptCompanionSetScenePrompt;
+        disposePlayer();
+        delete node._h3FlushProjectWrites;
+        void finalFlush.catch((error) => console.warn(
+            "H3 Plan Studio could not flush project edits while closing:", error,
+        ));
+        return removed?.apply(this, arguments);
+    };
+    node._h3PromptCompanionSetActiveScene = (planNode, index) => {
+        if (planNode !== state.planNode || !state.plan?.shots?.length) return false;
+        // Prompt/editor synchronization changes selection, not the user's
+        // horizontal timeline position.
+        void selectScene(index, false, false);
+        return true;
+    };
+    node._h3PromptCompanionSetScenePrompt = (planNode, index, text) => {
+        if (planNode !== state.planNode || !state.plan?.shots?.[index]) return false;
+        const liveValue = String(state.planWidget?.value ?? "");
+        let livePlanParsed = false;
+        try {
+            const livePlan = parsePlanJson(liveValue);
+            livePlanParsed = true;
+            if (planHasNonPromptChanges(state.plan, livePlan)) {
+                loadPlan(true);
+                return true;
+            }
+        } catch (_error) {
+            // Leave lastValue untouched so normal polling reports invalid JSON.
+        }
+        state.plan.shots[index].prompt = promptTextToLines(text);
+        if (index === state.active && state.history.textarea
+                && state.history.textarea.value !== text) {
+            const textarea = state.history.textarea;
+            const focused = document.activeElement === textarea;
+            const start = textarea.selectionStart;
+            const end = textarea.selectionEnd;
+            textarea.value = text;
+            if (focused) textarea.setSelectionRange(
+                Math.min(start, text.length), Math.min(end, text.length));
+            scheduleHistoryDraft(
+                String(state.plan.shots[index].id || `clip_${String(index + 1).padStart(4, "0")}`),
+                text);
+        }
+        if (livePlanParsed) state.lastValue = liveValue;
+        return true;
+    };
+    node._h3PlanStudioRefresh = () => {
+        loadPlan(true);
+        publishActiveScene();
+    };
+    state.pollTimer = setInterval(() => loadPlan(false), 500);
+    state.checkpointTimer = setInterval(() => void refreshCheckpoints(), 5000);
+    loadPlan(true);
+}
+
+app.registerExtension({
+    name:"minimax_h3_context_loop.plan_studio",
+    async beforeRegisterNodeDef(nodeType, nodeData) {
+        if (nodeData.name !== NODE_NAME) return;
+        const created = nodeType.prototype.onNodeCreated;
+        nodeType.prototype.onNodeCreated = function () {
+            const result = created?.apply(this, arguments); setTimeout(() => mount(this), 0); return result;
+        };
+    },
+    async nodeCreated(node) { if (nodeType(node) === NODE_NAME) mount(node); },
+    async afterConfigureGraph() {
+        for (const node of allNodes(app.graph)) if (nodeType(node) === NODE_NAME) setTimeout(() => node._h3PlanStudioRefresh?.(), 0);
+    },
+});
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_plan_studio_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_plan_studio_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..e6127df322598dcc9a058b2dcbf983d79e4f0749
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_plan_studio_core.mjs
@@ -0,0 +1,698 @@
+export function studioCheckpointSignature(runName, records) {
+    return JSON.stringify({
+        run_name: String(runName ?? ""),
+        checkpoints: (Array.isArray(records) ? records : []).map((item) => ({
+            scene: item?.scene,
+            scene_id: item?.scene_id,
+            revision: item?.revision,
+            ready: item?.ready,
+            continuation_stale: item?.continuation_stale,
+            continuation_stale_reason: item?.continuation_stale_reason,
+            delivered_frames: item?.delivered_frames,
+            video: item?.video,
+            audio: item?.audio,
+            preview_video: item?.preview_video,
+            partial_video: item?.partial_video,
+            presentation_revision:item?.presentation_revision,
+            presentation_video:item?.presentation_video,
+            alternates:(Array.isArray(item?.alternates) ? item.alternates : [])
+                .map((alternate) => ({
+                    revision:alternate?.revision,
+                    base_revision:alternate?.base_revision,
+                    ready:alternate?.ready,
+                    prompt:alternate?.prompt,
+                    seed:alternate?.seed,
+                    used_in_final_cut:alternate?.used_in_final_cut,
+                    video:alternate?.video,
+                })),
+        })),
+    });
+}
+
+export function studioCheckpointCacheSnapshot(runName, records, editorial) {
+    const run = String(runName ?? "").trim();
+    if (!run) return null;
+    // The include_graph=false response is intentionally small and contains
+    // only media descriptors plus active/alternate revision presentation.
+    // Clone it so later response mutation cannot change serialized UI state.
+    try {
+        return JSON.parse(JSON.stringify({
+            version:1,
+            run_name:run,
+            checkpoints:Array.isArray(records) ? records : [],
+            editorial:editorial && typeof editorial === "object"
+                ? editorial : null,
+        }));
+    } catch (_error) {
+        return null;
+    }
+}
+
+export function restoreStudioCheckpointCache(value, runName) {
+    const requested = String(runName ?? "").trim();
+    if (!value || typeof value !== "object" || Array.isArray(value)
+            || Number(value.version) !== 1
+            || String(value.run_name ?? "").trim() !== requested
+            || !Array.isArray(value.checkpoints)) return null;
+    return studioCheckpointCacheSnapshot(
+        requested, value.checkpoints, value.editorial,
+    );
+}
+
+export function remapStudioEditorialSceneId(editorial, previousId, nextId) {
+    if (!editorial || typeof editorial !== "object") return editorial;
+    const previous = String(previousId ?? "");
+    const next = String(nextId ?? "");
+    if (!previous || !next || previous === next) return editorial;
+    for (const field of ["placements", "trims", "replacements"]) {
+        for (const item of Array.isArray(editorial[field]) ? editorial[field] : []) {
+            if (String(item?.scene_id ?? "") === previous) item.scene_id = next;
+        }
+    }
+    if (Array.isArray(editorial.locked_scene_ids)) {
+        editorial.locked_scene_ids = editorial.locked_scene_ids.map(
+            (sceneId) => String(sceneId) === previous ? next : sceneId,
+        );
+    }
+    if (String(editorial.alternate_draft?.scene_id ?? "") === previous) {
+        editorial.alternate_draft.scene_id = next;
+    }
+    return editorial;
+}
+
+export function matchingStudioCheckpoint(checkpoints, index, timingRow) {
+    const scene = Number(index) + 1;
+    const item = checkpoints instanceof Map
+        ? checkpoints.get(scene)
+        : (Array.isArray(checkpoints)
+            ? checkpoints.find((candidate) => Number(candidate?.scene) === scene)
+            : null);
+    if (!item?.ready || !timingRow) return null;
+    if (String(item.scene_id ?? "") !== String(timingRow.id ?? "")) return null;
+    const savedFrames = Number(item.delivered_frames);
+    const plannedFrames = Number(timingRow.deliveredFrames);
+    if (Number.isFinite(savedFrames) && savedFrames > 0
+            && Number.isFinite(plannedFrames) && savedFrames !== plannedFrames) {
+        return null;
+    }
+    return item;
+}
+
+export function studioContextWindowLayout(
+    deliveredFrames, spanFrames, startFrame,
+) {
+    const delivered = Number(deliveredFrames);
+    const span = Number(spanFrames);
+    const requestedStart = Number(startFrame);
+    if (!Number.isInteger(delivered) || delivered < 1
+            || !Number.isInteger(span) || span < 1 || span > delivered) {
+        throw new Error("Context window must fit inside delivered source frames.");
+    }
+    const latest = delivered - span;
+    const start = Number.isInteger(requestedStart)
+        ? Math.max(0, Math.min(latest, requestedStart)) : latest;
+    return {
+        delivered,
+        span,
+        latest,
+        start,
+        end:start + span,
+        leftFraction:start / delivered,
+        widthFraction:span / delivered,
+    };
+}
+
+export function studioContextWindowStartAtRatio(
+    deliveredFrames, spanFrames, ratio,
+) {
+    const layout = studioContextWindowLayout(
+        deliveredFrames, spanFrames, 0,
+    );
+    const position = Math.max(0, Math.min(1, Number(ratio) || 0));
+    return Math.max(0, Math.min(
+        layout.latest,
+        Math.round(position * layout.delivered - layout.span / 2),
+    ));
+}
+
+export function studioSceneStartSeconds(rows, index) {
+    const bounded = Math.max(0, Math.min(
+        Array.isArray(rows) ? rows.length : 0,
+        Number.isFinite(Number(index)) ? Math.trunc(Number(index)) : 0,
+    ));
+    let seconds = 0;
+    for (let offset = 0; offset < bounded; offset += 1) {
+        seconds += Math.max(0, Number(rows[offset]?.deliveredSeconds) || 0);
+    }
+    return seconds;
+}
+
+function normalizedStartFrame(value) {
+    const frames = Number(value);
+    return Number.isFinite(frames)
+        ? Math.max(0, Math.min(864000, Math.round(frames))) : null;
+}
+
+export function studioLatentSafeOutFrames(rawFrames, deliveredFrames) {
+    const raw = Math.round(Number(rawFrames));
+    const delivered = Math.round(Number(deliveredFrames));
+    if (!Number.isInteger(raw) || !Number.isInteger(delivered)
+            || raw < 1 || delivered < 1 || delivered > raw) return [];
+    const technicalTrim = raw - delivered;
+    const boundaries = [];
+    let covered = 0;
+    let step = 0;
+    const framePerToken = [1, 4, 4, 4, 4];
+    while (covered < raw) {
+        covered += framePerToken[step % framePerToken.length];
+        step += 1;
+        if (covered > raw) break;
+        const out = covered - technicalTrim;
+        // A shortened cut must end on both a video-latent boundary and an
+        // integer 40 Hz audio interval measured from the delivered start.
+        if (out > 0 && out <= delivered && out % 3 === 0) boundaries.push(out);
+    }
+    // Keeping the original endpoint is always lossless even when its nominal
+    // 24/40 Hz duration lands between audio ticks; no tensor is sliced.
+    if (!boundaries.includes(delivered)) boundaries.push(delivered);
+    return boundaries.sort((left, right) => left - right);
+}
+
+export function studioNearestLatentSafeOutFrame(
+    rawFrames, deliveredFrames, requestedFrames,
+) {
+    const options = studioLatentSafeOutFrames(rawFrames, deliveredFrames);
+    if (!options.length) return Math.max(1, Math.round(Number(deliveredFrames) || 1));
+    const requested = Number(requestedFrames);
+    return options.reduce((best, candidate) => (
+        Math.abs(candidate - requested) < Math.abs(best - requested)
+            ? candidate : best
+    ), options[0]);
+}
+
+function editorialOutFrame(row, trims) {
+    const sceneId = String(row?.id ?? "");
+    const full = Math.max(
+        0, Math.round(Number(row?.deliveredFrames)
+            || (Number(row?.deliveredSeconds) || 0) * 24),
+    );
+    const trim = (Array.isArray(trims) ? trims : []).find(
+        (item) => String(item?.scene_id ?? "") === sceneId,
+    );
+    const requested = Math.round(Number(trim?.out_frame));
+    return Number.isInteger(requested) && requested > 0 && requested <= full
+        ? requested : full;
+}
+
+export function studioTimelineSegments(
+    rows, placements = [], workspaceEndFrame = null, trims = [],
+) {
+    const scenes = Array.isArray(rows) ? rows : [];
+    const bySceneId = new Map();
+    for (const placement of Array.isArray(placements) ? placements : []) {
+        const sceneId = String(placement?.scene_id ?? "").trim();
+        const startFrame = normalizedStartFrame(placement?.start_frame);
+        if (!sceneId || startFrame == null) continue;
+        bySceneId.set(sceneId, startFrame);
+    }
+    const orderedScenes = [];
+    let naturalStartFrame = 0;
+    scenes.forEach((row, sceneIndex) => {
+        const sceneId = String(row?.id ?? "");
+        const durationFrames = editorialOutFrame(row, trims);
+        const explicit = bySceneId.has(sceneId);
+        orderedScenes.push({
+            row, sceneIndex, sceneId, durationFrames, explicit,
+            requestedStart:explicit
+                ? bySceneId.get(sceneId) : naturalStartFrame,
+        });
+        naturalStartFrame += durationFrames;
+    });
+    orderedScenes.sort((left, right) => (
+        left.requestedStart - right.requestedStart
+        || Number(right.explicit) - Number(left.explicit)
+        || left.sceneIndex - right.sceneIndex
+    ));
+    const segments = [];
+    let cursorFrame = 0;
+    orderedScenes.forEach((item) => {
+        const {sceneIndex, sceneId, durationFrames, explicit} = item;
+        const requestedStart = item.requestedStart;
+        const startFrame = Math.max(
+            cursorFrame,
+            requestedStart,
+        );
+        if (startFrame > cursorFrame) {
+            segments.push({
+                kind:"gap", key:`gap:before:${sceneId}`, sceneIndex,
+                sceneId, gapId:`before_${sceneId}`,
+                startFrame:cursorFrame, durationFrames:startFrame - cursorFrame,
+                endFrame:startFrame,
+                startSeconds:cursorFrame / 24,
+                durationSeconds:(startFrame - cursorFrame) / 24,
+                endSeconds:startFrame / 24,
+            });
+        }
+        segments.push({
+            kind:"scene", key:`scene:${sceneIndex}`, sceneIndex,
+            sceneId, startFrame, durationFrames,
+            endFrame:startFrame + durationFrames,
+            startSeconds:startFrame / 24,
+            durationSeconds:durationFrames / 24,
+            endSeconds:(startFrame + durationFrames) / 24,
+            explicitStartFrame:explicit ? requestedStart : null,
+        });
+        cursorFrame = startFrame + durationFrames;
+    });
+    const requestedWorkspaceEnd = normalizedStartFrame(workspaceEndFrame);
+    if (requestedWorkspaceEnd != null && requestedWorkspaceEnd > cursorFrame) {
+        const lastScene = orderedScenes.at(-1);
+        const sceneIndex = Math.max(0, Number(lastScene?.sceneIndex) || 0);
+        segments.push({
+            kind:"gap", key:"gap:tail", sceneIndex,
+            sceneId:String(lastScene?.sceneId ?? ""), gapId:"tail",
+            trailing:true,
+            startFrame:cursorFrame,
+            durationFrames:requestedWorkspaceEnd - cursorFrame,
+            endFrame:requestedWorkspaceEnd,
+            startSeconds:cursorFrame / 24,
+            durationSeconds:(requestedWorkspaceEnd - cursorFrame) / 24,
+            endSeconds:requestedWorkspaceEnd / 24,
+        });
+    }
+    return segments;
+}
+
+export function studioTimelineTotalSeconds(segments) {
+    const values = Array.isArray(segments) ? segments : [];
+    return values.length ? Math.max(0, Number(values.at(-1)?.endSeconds) || 0) : 0;
+}
+
+export function studioTimelineScrollAnchorSeconds(
+    scrollLeft, viewportWidth, contentWidth, totalSeconds, anchorRatio = .5,
+) {
+    const width = Math.max(0, Number(contentWidth) || 0);
+    const duration = Math.max(0, Number(totalSeconds) || 0);
+    if (!(width > 0) || !(duration > 0)) return null;
+    const ratio = Math.max(0, Math.min(1, Number(anchorRatio) || 0));
+    return Math.max(0, Math.min(
+        duration,
+        (Math.max(0, Number(scrollLeft) || 0)
+            + Math.max(0, Number(viewportWidth) || 0) * ratio)
+            / width * duration,
+    ));
+}
+
+export function studioTimelineScrollLeftForAnchor(
+    seconds, viewportWidth, pixelsPerSecond, anchorRatio = .5,
+) {
+    const ratio = Math.max(0, Math.min(1, Number(anchorRatio) || 0));
+    return Math.max(
+        0,
+        Math.max(0, Number(seconds) || 0)
+            * Math.max(0, Number(pixelsPerSecond) || 0)
+            - Math.max(0, Number(viewportWidth) || 0) * ratio,
+    );
+}
+
+export function studioTimelinePixelAtSecond(
+    seconds, pixelsPerSecond, contentWidth,
+) {
+    const position = Math.max(0, Number(seconds) || 0);
+    const scale = Math.max(0, Number(pixelsPerSecond) || 0);
+    const width = Math.max(0, Number(contentWidth) || 0);
+    return Math.max(0, Math.min(width, position * scale));
+}
+
+export function studioEditorialSceneStartSeconds(segments, sceneIndex) {
+    const wanted = Number(sceneIndex);
+    const segment = (Array.isArray(segments) ? segments : []).find(
+        (item) => item?.kind === "scene" && item.sceneIndex === wanted,
+    );
+    return Math.max(0, Number(segment?.startSeconds) || 0);
+}
+
+export function studioTimelineLayout(
+    rows, viewportWidth, zoom = 1, placements = [], workspaceEndFrame = null,
+    trims = [],
+) {
+    const packedSceneSeconds = studioTimelineTotalSeconds(
+        studioTimelineSegments(rows, [], null, trims),
+    );
+    const sceneSegments = studioTimelineSegments(rows, placements, null, trims);
+    const sceneEndSeconds = studioTimelineTotalSeconds(sceneSegments);
+    const segments = studioTimelineSegments(
+        rows, placements, workspaceEndFrame, trims,
+    );
+    const width = Math.max(1, Number(viewportWidth) || 1);
+    const scale = Math.max(1, Math.min(6, Number(zoom) || 1));
+    const totalSeconds = studioTimelineTotalSeconds(segments);
+    // Keep the time scale stable while clips are positioned. At 100%, the
+    // naturally packed generated duration fills one viewport; editorial gaps
+    // and the open workspace extend horizontally instead of re-fitting the
+    // terminal clip back onto the viewport's right edge after every move.
+    const fitSeconds = Math.max(
+        1 / 24,
+        packedSceneSeconds || sceneEndSeconds || totalSeconds,
+    );
+    const pixelsPerSecond = width * scale / fitSeconds;
+    const contentWidth = Math.max(
+        width * scale, totalSeconds * pixelsPerSecond,
+    );
+    const widths = segments.map(
+        (segment) => pixelsPerSecond * segment.durationSeconds,
+    );
+    return {
+        zoom:scale, contentWidth, widths, segments, totalSeconds,
+        sceneEndSeconds, packedSceneSeconds, pixelsPerSecond,
+    };
+}
+
+export function studioNearestH3FrameLength(
+    frames, minimumFrames = 5, maximumFrames = 3592,
+) {
+    const minimum = Math.max(5, Math.ceil(Number(minimumFrames) || 5));
+    const maximum = Math.max(minimum, Math.floor(
+        Number(maximumFrames) || 3592,
+    ));
+    const firstIndex = Math.max(0, Math.ceil((minimum - 5) / 17));
+    const lastIndex = Math.max(firstIndex, Math.floor((maximum - 5) / 17));
+    const requested = Number.isFinite(Number(frames)) ? Number(frames) : minimum;
+    const index = Math.max(firstIndex, Math.min(
+        lastIndex, Math.round((requested - 5) / 17),
+    ));
+    return 5 + index * 17;
+}
+
+export function locateStudioTimelineSegment(segments, seconds) {
+    const values = Array.isArray(segments) ? segments : [];
+    const totalSeconds = studioTimelineTotalSeconds(values);
+    const targetSeconds = Math.max(0, Math.min(
+        totalSeconds, Number.isFinite(Number(seconds)) ? Number(seconds) : 0,
+    ));
+    if (!values.length) return {
+        index:-1, segmentIndex:-1, kind:"empty", startSeconds:0,
+        localSeconds:0, targetSeconds, totalSeconds,
+    };
+    for (let segmentIndex = 0; segmentIndex < values.length; segmentIndex += 1) {
+        const segment = values[segmentIndex];
+        if (targetSeconds < segment.endSeconds || segmentIndex === values.length - 1) {
+            return {
+                ...segment,
+                index:Number(segment.sceneIndex), segmentIndex,
+                localSeconds:Math.max(0, targetSeconds - segment.startSeconds),
+                targetSeconds, totalSeconds,
+            };
+        }
+    }
+    return {
+        ...values.at(-1), index:Number(values.at(-1)?.sceneIndex),
+        segmentIndex:values.length - 1, localSeconds:0,
+        targetSeconds, totalSeconds,
+    };
+}
+
+export function studioPlayerSegmentClock(
+    segments, segmentKey, mediaSeconds, fps = 24,
+) {
+    const segment = (Array.isArray(segments) ? segments : []).find(
+        (candidate) => candidate?.key === segmentKey,
+    );
+    if (!segment || segment.kind !== "scene") return null;
+    const localSeconds = Math.max(0, Number(mediaSeconds) || 0);
+    const durationSeconds = Math.max(0, Number(segment.durationSeconds) || 0);
+    const tolerance = 1 / Math.max(1, (Number(fps) || 24) * 8);
+    return {
+        segment,
+        localSeconds:Math.min(durationSeconds, localSeconds),
+        timelineSeconds:Math.min(
+            Number(segment.endSeconds) || 0,
+            (Number(segment.startSeconds) || 0) + localSeconds,
+        ),
+        boundaryReached:localSeconds >= Math.max(0, durationSeconds - tolerance),
+    };
+}
+
+export function studioRulerTicks(totalSeconds, pixelWidth) {
+    const duration = Math.max(0, Number(totalSeconds) || 0);
+    const width = Math.max(1, Number(pixelWidth) || 1);
+    if (!duration) return [{seconds:0, major:true}];
+    const minimumMajorSeconds = duration * 72 / width;
+    const candidates = [
+        .25, .5, 1, 2, 5, 10, 15, 30, 60, 120, 300, 600, 900, 1800,
+    ];
+    const majorStep = candidates.find((value) => value >= minimumMajorSeconds)
+        ?? candidates.at(-1);
+    const minorStep = majorStep >= 5 ? majorStep / 5 : majorStep / 2;
+    const ticks = [];
+    const count = Math.ceil(duration / minorStep);
+    for (let index = 0; index <= count; index += 1) {
+        const seconds = Math.min(duration, index * minorStep);
+        if (index > 0 && seconds === ticks.at(-1)?.seconds) continue;
+        const ratio = seconds / majorStep;
+        ticks.push({seconds, major:Math.abs(ratio - Math.round(ratio)) < 1e-7});
+    }
+    if (ticks.at(-1)?.seconds !== duration) ticks.push({seconds:duration, major:true});
+    return ticks;
+}
+
+export function parseStudioTimecode(value) {
+    const entered = String(value ?? "").trim();
+    const text = /s$/i.test(entered) ? entered.slice(0, -1).trim() : entered;
+    if (!text) return null;
+    const parts = text.split(":");
+    if (parts.length > 3 || parts.some((part) => !/^\d+(?:\.\d+)?$/.test(part))) {
+        throw new Error("Use seconds, M:SS, or H:MM:SS for editorial time.");
+    }
+    let seconds = 0;
+    for (const part of parts) seconds = seconds * 60 + Number(part);
+    if (!Number.isFinite(seconds) || seconds < 0 || seconds > 36000) {
+        throw new Error("Editorial time must be between 0 and 10 hours.");
+    }
+    return seconds;
+}
+
+export function parseTimedLyrics(value) {
+    const text = String(value ?? "").replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+    const srt = [];
+    const srtPattern = /(?:^|\n)(?:\d+\s*\n)?\s*(\d{1,2}):(\d{2}):(\d{2})[,.](\d{1,3})\s*-->\s*(\d{1,2}):(\d{2}):(\d{2})[,.](\d{1,3})[^\n]*\n([\s\S]*?)(?=\n{2,}|$)/g;
+    for (const match of text.matchAll(srtPattern)) {
+        const milliseconds = (hour, minute, second, fraction) => (
+            Number(hour) * 3600000 + Number(minute) * 60000 +
+            Number(second) * 1000 + Number(String(fraction).padEnd(3, "0").slice(0, 3))
+        );
+        const start = milliseconds(match[1], match[2], match[3], match[4]) / 1000;
+        const end = milliseconds(match[5], match[6], match[7], match[8]) / 1000;
+        const cueText = match[9].trim();
+        if (cueText && end > start) srt.push({startSeconds:start, endSeconds:end, text:cueText});
+    }
+    if (srt.length) return srt.sort((a, b) => a.startSeconds - b.startSeconds);
+
+    let offsetSeconds = 0;
+    const starts = [];
+    for (const line of text.split("\n")) {
+        const offset = line.match(/^\s*\[offset:([+-]?\d+)\]\s*$/i);
+        if (offset) { offsetSeconds = Number(offset[1]) / 1000; continue; }
+        const timestamps = [...line.matchAll(/\[(\d{1,3}):(\d{2})(?:[.:](\d{1,3}))?\]/g)];
+        if (!timestamps.length) continue;
+        const cueText = line.replace(/\[[^\]]+\]/g, "").trim();
+        if (!cueText) continue;
+        for (const match of timestamps) {
+            const fraction = String(match[3] ?? "0");
+            const fractionScale = fraction.length === 3
+                ? 1000 : fraction.length === 2 ? 100 : 10;
+            const fractionSeconds = Number(fraction) / fractionScale;
+            starts.push({
+                startSeconds:Math.max(0, Number(match[1]) * 60 + Number(match[2]) + fractionSeconds + offsetSeconds),
+                text:cueText,
+            });
+        }
+    }
+    starts.sort((a, b) => a.startSeconds - b.startSeconds);
+    return starts.map((cue, index) => ({
+        ...cue,
+        endSeconds:Math.max(
+            cue.startSeconds + .1,
+            starts[index + 1]?.startSeconds ?? cue.startSeconds + 4,
+        ),
+    }));
+}
+
+export function timedLyricAtSecond(cues, seconds, offsetSeconds = 0) {
+    const target = (Number(seconds) || 0) - (Number(offsetSeconds) || 0);
+    return (Array.isArray(cues) ? cues : []).find(
+        (cue) => target >= Number(cue.startSeconds)
+            && target < Number(cue.endSeconds),
+    ) ?? null;
+}
+
+export function locateStudioTimelineSecond(rows, seconds) {
+    const scenes = Array.isArray(rows) ? rows : [];
+    const totalSeconds = studioSceneStartSeconds(scenes, scenes.length);
+    const targetSeconds = Math.max(0, Math.min(
+        totalSeconds, Number.isFinite(Number(seconds)) ? Number(seconds) : 0,
+    ));
+    if (!scenes.length) {
+        return {index: -1, startSeconds: 0, localSeconds: 0, targetSeconds, totalSeconds};
+    }
+    let startSeconds = 0;
+    for (let index = 0; index < scenes.length; index += 1) {
+        const duration = Math.max(0, Number(scenes[index]?.deliveredSeconds) || 0);
+        if (targetSeconds < startSeconds + duration || index === scenes.length - 1) {
+            return {
+                index,
+                startSeconds,
+                localSeconds: Math.max(0, targetSeconds - startSeconds),
+                targetSeconds,
+                totalSeconds,
+            };
+        }
+        startSeconds += duration;
+    }
+    return {index: scenes.length - 1, startSeconds, localSeconds: 0, targetSeconds, totalSeconds};
+}
+
+export function matchingStudioSourceScene(payload, index, timingRow) {
+    if (!payload?.token || !timingRow) return null;
+    const scene = Number(index) + 1;
+    const item = (Array.isArray(payload.scenes) ? payload.scenes : []).find(
+        (candidate) => Number(candidate?.scene) === scene,
+    );
+    if (!item || String(item.scene_id ?? "") !== String(timingRow.id ?? "")) {
+        return null;
+    }
+    if (Number(item.delivered_frames) !== Number(timingRow.deliveredFrames)) {
+        return null;
+    }
+    const references = Array.isArray(item.references) ? item.references : [];
+    return references.length ? item : null;
+}
+
+export function matchingStudioSourceAudio(
+    payload, timingRows, expectedRun = payload?.run_name,
+) {
+    const audio = payload?.source_audio;
+    if (!payload?.token || !audio?.available) return null;
+    if (String(payload.run_name ?? "") !== String(expectedRun ?? "")) return null;
+    if (!Array.isArray(timingRows) || !timingRows.length) return null;
+    // This is the whole source file, not a render tied to the saved Plan's
+    // frame count. Length edits, trims and scene reordering only move the
+    // timeline windows over it; they must not disconnect the audio track.
+    return audio;
+}
+
+export function studioSourceAudioSecond(sourceAudio, timelineSeconds) {
+    const start = Math.max(0, Number(sourceAudio?.seek_seconds) || 0);
+    const local = Math.max(0, Number(timelineSeconds) || 0);
+    // The source file is served directly and may be longer than the generated
+    // scene chain. Editorial gaps deliberately keep advancing through it.
+    return start + local;
+}
+
+export function studioWaveformSceneSamples(waveform, rows, index) {
+    const scenes = Array.isArray(rows) ? rows : [];
+    const samples = Array.isArray(waveform?.samples) ? waveform.samples : [];
+    const rate = Math.max(1, Number(waveform?.points_per_second) || 1);
+    if (!samples.length || index < 0 || index >= scenes.length) return [];
+    const start = studioSceneStartSeconds(scenes, index);
+    const end = start + Math.max(
+        0, Number(scenes[index]?.deliveredSeconds) || 0);
+    return samples.slice(
+        Math.max(0, Math.floor(start * rate)),
+        Math.min(samples.length, Math.max(1, Math.ceil(end * rate))),
+    );
+}
+
+export function studioWaveformIntervalSamples(
+    waveform, startSeconds, durationSeconds,
+) {
+    const samples = Array.isArray(waveform?.samples) ? waveform.samples : [];
+    const pointsPerSecond = Math.max(
+        0, Number(waveform?.points_per_second) || 0,
+    );
+    if (!samples.length || !pointsPerSecond) return [];
+    const start = Math.max(0, Math.floor(
+        (Number(startSeconds) || 0) * pointsPerSecond,
+    ));
+    const end = Math.max(start + 1, Math.ceil(
+        ((Number(startSeconds) || 0) + Math.max(0, Number(durationSeconds) || 0))
+            * pointsPerSecond,
+    ));
+    if (start >= samples.length) return [];
+    const interval = samples.slice(start, end);
+    // Keep seconds mapped to the same horizontal positions if a resized
+    // scene crosses the source end (or newly requested waveform coverage).
+    // Stretching the remaining samples across the entire card is misleading.
+    if (end > samples.length) {
+        interval.length = end - start;
+        interval.fill(0, samples.length - start);
+    }
+    return interval;
+}
+
+export function studioSourceSecond(reference, deliveredLocalSeconds, fps = 24) {
+    const rate = Math.max(1, Number(fps) || 24);
+    const offset = Math.max(0, Number(reference?.compare_offset_frames) || 0) / rate;
+    const local = Math.max(0, Number(deliveredLocalSeconds) || 0);
+    const duration = Math.max(0, Number(reference?.frame_count) || 0) / rate;
+    return Math.min(Math.max(0, duration - 0.02), offset + local);
+}
+
+export function h3StudioGridMarkers(
+    rawFrames, contextFrames = 0, continuationMode = "guide",
+    preserveAudioPrefix = true,
+) {
+    const frames = Math.trunc(Number(rawFrames));
+    const context = Math.trunc(Number(contextFrames));
+    const rawIndex = Number.isInteger(frames) ? (frames - 5) / 17 : NaN;
+    const rawOnGrid = Number.isInteger(rawIndex) && rawIndex >= 0;
+    const raw = {
+        frames,
+        onGrid:rawOnGrid,
+        index:rawOnGrid ? rawIndex : null,
+        label:rawOnGrid
+            ? `${frames}f = 17×${rawIndex}+5`
+            : `${frames}f is off the 17n+5 grid`,
+    };
+
+    const avMode = [
+        "masked_av", "tapered_av", "feathered_av", "audio_feathered_av",
+        "drift_control_av",
+    ].includes(
+        String(continuationMode ?? ""),
+    );
+    let av = null;
+    if (avMode && Number.isInteger(context) && context > 0) {
+        const latentIndex = (context - 5) / 17;
+        const latentGrid = Number.isInteger(latentIndex) && latentIndex >= 0;
+        const audioAligned = context % 3 === 0;
+        const audioPreserved = Boolean(preserveAudioPrefix);
+        const exact = latentGrid && (!audioPreserved || audioAligned);
+        const audioTicks = context * 5 / 3;
+        av = {
+            frames:context,
+            latentGrid,
+            exact,
+            audioAligned,
+            audioPreserved,
+            audioTicks,
+            label:audioPreserved
+                ? (audioAligned
+                    ? `${context}f AV = ${audioTicks} audio ticks`
+                    : `${context}f AV = ${audioTicks.toFixed(3)} audio ticks`)
+                : `${context}f video-only AV`,
+        };
+    }
+
+    // Community experiments report fewer flashes when a generated-to-real
+    // cut lands within the four-frame window beginning at 17n-3.  Surface the
+    // nearest completed window as an optional diagnostic, never a validator.
+    const packet = Number.isInteger(frames) ? Math.floor(frames / 17) : 0;
+    const cut = packet > 0 ? {
+        start:17 * packet - 3,
+        end:17 * packet,
+        experimental:true,
+        label:`cut test ${17 * packet - 3}–${17 * packet}f`,
+    } : null;
+    return {raw, av, cut};
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_review_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_review_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..4e91e93cbc129a6f2f62f552ec41c4217291d0c7
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_review_core.mjs
@@ -0,0 +1,406 @@
+import {
+    MAX_SEED,
+    promptValueToText,
+    promptTextToLines,
+    sceneAudioContextLength,
+    sceneContinuationMode,
+    sceneContextLength,
+    sceneLoRARoute,
+    sceneVideoBlendFrames,
+    sceneVisualContextBlocks,
+    sceneVisualContextLeadFrames,
+    sceneVisualContextLeadSource,
+    sceneVisualContextSource,
+    sharedPrompt,
+} from "./h3_chain_plan_core.mjs?v=0.6.5";
+
+const FPS = 24;
+const MAX_H3_FRAMES = 3592;
+
+export function reviewSeed(value) {
+    let seed;
+    try {
+        seed = BigInt(String(value));
+    } catch (_error) {
+        throw new Error("Seed must be an integer.");
+    }
+    if (seed < 0n || seed > MAX_SEED) {
+        throw new Error("Seed is outside the uint64 range.");
+    }
+    return seed.toString();
+}
+
+export function reviewDuration(value) {
+    const seconds = Number(value);
+    if (!Number.isFinite(seconds) || seconds <= 0) {
+        throw new Error("Duration must be a finite positive number of seconds.");
+    }
+    // The field displays six decimals, while most frame/24 values repeat.
+    // Tolerate that display rounding so leaving an unchanged duration alone
+    // can never jump to the next 17-frame H3 step.
+    const requested = Math.max(5, Math.ceil(seconds * FPS - 1e-4));
+    const length = requested + ((5 - requested % 17) + 17) % 17;
+    if (length > MAX_H3_FRAMES) {
+        throw new Error(`Duration is too long; the largest H3 length is ${MAX_H3_FRAMES} frames (${(MAX_H3_FRAMES / FPS).toFixed(3)} seconds).`);
+    }
+    return {seconds, length};
+}
+
+export function reviewDurationText(rawFrames) {
+    const length = Number(rawFrames);
+    if (!Number.isInteger(length) || length < 5 || length > MAX_H3_FRAMES
+            || length % 17 !== 5) {
+        throw new Error("The reviewed scene has an invalid H3 frame length.");
+    }
+    return (length / FPS).toFixed(6).replace(/0+$/, "").replace(/\.$/, "");
+}
+
+export function reviewPlanScenePrompt(plan, oneBasedIndex, shotId = "") {
+    if (!Array.isArray(plan?.shots)) return null;
+    const index = Number(oneBasedIndex) - 1;
+    const wantedId = String(shotId ?? "").trim();
+    const shot = (wantedId
+        ? plan.shots.find((item) => String(item?.id ?? "").trim() === wantedId)
+        : null) ?? (Number.isInteger(index) ? plan.shots[index] : null);
+    if (!shot) return null;
+    return promptValueToText(shot.prompt);
+}
+
+export function applyReviewEdit(plan, oneBasedIndex, scenePrompt, seed, length = null) {
+    const index = Number(oneBasedIndex) - 1;
+    if (!Array.isArray(plan?.shots) || index < 0 || index >= plan.shots.length) {
+        throw new Error("The reviewed scene does not exist in the plan.");
+    }
+    const prompt = String(scenePrompt ?? "").replace(/\r\n?/g, "\n").trim();
+    if (!prompt && !sharedPrompt(plan).text.trim()) {
+        throw new Error("Retry requires a scene prompt or shared prompt.");
+    }
+    const normalizedSeed = reviewSeed(seed);
+    plan.shots[index].prompt = promptTextToLines(prompt);
+    plan.shots[index].seed = normalizedSeed;
+    if (length !== null && length !== undefined) {
+        const normalizedLength = Number(length);
+        if (!Number.isInteger(normalizedLength) || normalizedLength < 5
+                || normalizedLength > MAX_H3_FRAMES
+                || normalizedLength % 17 !== 5) {
+            throw new Error("Length must be an H3-valid frame count (17k+5).");
+        }
+        plan.shots[index].length = normalizedLength;
+        delete plan.shots[index].frames;
+        delete plan.shots[index].duration_seconds;
+    }
+    return plan;
+}
+
+export function reviewCountdown(deadlineSeconds, nowMilliseconds = Date.now()) {
+    if (deadlineSeconds === null || deadlineSeconds === undefined || deadlineSeconds === "") {
+        return null;
+    }
+    const deadline = Number(deadlineSeconds);
+    if (!Number.isFinite(deadline)) return null;
+    const seconds = Math.max(0, Math.ceil(deadline - Number(nowMilliseconds) / 1000));
+    const minutes = Math.floor(seconds / 60);
+    const remainder = String(seconds % 60).padStart(2, "0");
+    return {seconds, text: `${minutes}:${remainder}`};
+}
+
+export function reviewLocalDeadline(
+    deadlineSeconds,
+    serverNowSeconds,
+    clientNowMilliseconds = Date.now(),
+) {
+    if (deadlineSeconds === null || deadlineSeconds === undefined || deadlineSeconds === "") {
+        return null;
+    }
+    const deadline = Number(deadlineSeconds);
+    const serverNow = Number(serverNowSeconds);
+    if (!Number.isFinite(deadline) || !Number.isFinite(serverNow)) return null;
+    return Number(clientNowMilliseconds) / 1000 + Math.max(0, deadline - serverNow);
+}
+
+export function acceptedPreviewDisposition(pin, payload) {
+    if (!pin) return "none";
+    const pinnedRun = String(pin.runName ?? "");
+    const incomingRun = String(payload?.run_name ?? "");
+    if (pinnedRun && incomingRun && pinnedRun !== incomingRun) return "release";
+    const pinnedScene = Number(pin.clipIndex);
+    const incomingScene = Number(payload?.clip_index);
+    if (!Number.isInteger(pinnedScene) || !Number.isInteger(incomingScene)) {
+        return "hold";
+    }
+    if (incomingScene < pinnedScene) return "ignore";
+    if (incomingScene > pinnedScene) return "release";
+    const pinnedToken = String(pin.token ?? "");
+    const incomingToken = String(payload?.token ?? "");
+    return pinnedToken && incomingToken && pinnedToken !== incomingToken
+        ? "release" : "hold";
+}
+
+export function checkpointResumeOptions(checkpoints, clipCount) {
+    const total = Number(clipCount);
+    if (!Number.isInteger(total) || total < 1) return [];
+    const byResumeScene = new Map();
+    for (const item of checkpoints ?? []) {
+        const savedScene = Number(item?.scene);
+        const resumeScene = Number(item?.resume_scene ?? savedScene + 1);
+        if (!item?.ready || !Number.isInteger(savedScene) || savedScene < 1
+            || !Number.isInteger(resumeScene) || resumeScene < 2
+            || resumeScene > total) continue;
+        byResumeScene.set(resumeScene, {
+            savedScene,
+            resumeScene,
+            sceneId: String(item.scene_id ?? `clip_${String(savedScene).padStart(4, "0")}`),
+            video: item.video ?? null,
+            partialVideo: item.partial_video ?? null,
+        });
+    }
+    return [...byResumeScene.values()].sort((left, right) =>
+        left.resumeScene - right.resumeScene);
+}
+
+export function checkpointRevisionChain(revisions, resumeScene) {
+    const nextScene = Number(resumeScene);
+    if (!Number.isInteger(nextScene) || nextScene < 2) return [];
+    const grouped = new Map();
+    for (const item of revisions ?? []) {
+        const scene = Number(item?.scene);
+        const revision = String(item?.revision ?? "");
+        if (!item?.ready || !Number.isInteger(scene) || scene < 1
+                || scene >= nextScene || !/^[0-9a-f]{32}$/.test(revision)) {
+            continue;
+        }
+        const normalized = {
+            scene,
+            sceneId: String(item.scene_id ?? `clip_${String(scene).padStart(4, "0")}`),
+            revision,
+            active: Boolean(item.active),
+            createdAt: String(item.created_at ?? ""),
+            seed: String(item.seed ?? ""),
+            sizeBytes: Math.max(0, Number(item.size_bytes) || 0),
+            promptPreview: String(item.prompt_preview ?? ""),
+            video: item.preview_video ?? item.video ?? null,
+        };
+        const entries = grouped.get(scene) ?? [];
+        entries.push(normalized);
+        grouped.set(scene, entries);
+    }
+    const chain = [];
+    for (let scene = 1; scene < nextScene; scene += 1) {
+        const entries = grouped.get(scene) ?? [];
+        entries.sort((left, right) => {
+            if (left.active !== right.active) return left.active ? -1 : 1;
+            return right.createdAt.localeCompare(left.createdAt)
+                || right.revision.localeCompare(left.revision);
+        });
+        if (!entries.length) return [];
+        chain.push({scene, revisions: entries});
+    }
+    return chain;
+}
+
+export function applyCheckpointRevisionSet(plan, revisions, {
+    useEffectivePrompts = false,
+    useTipSharedPrompt = false,
+} = {}) {
+    if (!plan || !Array.isArray(plan.shots)) {
+        throw new Error("The active Plan has no scenes.");
+    }
+    let shared = null;
+    for (const revision of revisions ?? []) {
+        const scene = Number(revision?.scene);
+        const index = scene - 1;
+        if (!Number.isInteger(scene) || index < 0 || index >= plan.shots.length) {
+            throw new Error("A restored checkpoint scene is outside the active Plan.");
+        }
+        const length = Number(revision.raw_frames);
+        if (!Number.isInteger(length) || length < 5 || length > MAX_H3_FRAMES
+                || length % 17 !== 5) {
+            throw new Error(`Restored scene ${scene} has an invalid H3 frame length.`);
+        }
+        const steps = Number(revision.steps);
+        if (!Number.isInteger(steps) || steps < 1) {
+            throw new Error(`Restored scene ${scene} has an invalid step count.`);
+        }
+        const prefix = String(revision.prompt_prefix ?? "");
+        if (shared === null || useTipSharedPrompt) shared = prefix;
+        if (!useTipSharedPrompt && prefix !== shared) {
+            throw new Error("Restored checkpoint revisions use different shared prompts.");
+        }
+        const shot = plan.shots[index];
+        if (revision.scene_id) shot.id = String(revision.scene_id);
+        const prompt = useEffectivePrompts
+            ? revision.effective_scene_prompt ?? revision.scene_prompt ?? ""
+            : revision.scene_prompt ?? revision.effective_scene_prompt ?? "";
+        shot.prompt = promptTextToLines(prompt);
+        shot.seed = reviewSeed(revision.seed);
+        shot.length = length;
+        shot.steps = steps;
+        if (Object.hasOwn(revision, "context_length")) {
+            shot.context_length = Number(revision.context_length);
+            sceneContextLength(shot);
+        } else {
+            delete shot.context_length;
+        }
+        if (Object.hasOwn(revision, "audio_context_length")) {
+            shot.audio_context_length = Number(revision.audio_context_length);
+            sceneAudioContextLength(
+                shot, 22, sceneContextLength(shot),
+            );
+        } else {
+            delete shot.audio_context_length;
+        }
+        if (Array.isArray(revision.visual_context_blocks)) {
+            shot.visual_context_blocks = revision.visual_context_blocks.map(
+                (block) => ({
+                    source:String(block?.source ?? ""),
+                    frames:Number(block?.frames),
+                    ...(Object.hasOwn(block ?? {}, "start_frame")
+                        ? {start_frame:Number(block.start_frame)} : {}),
+                }),
+            );
+            delete shot.visual_context_source;
+            delete shot.visual_context_start_frame;
+            delete shot.visual_context_lead_source;
+            delete shot.visual_context_lead_frames;
+            delete shot.visual_context_lead_start_frame;
+            sceneVisualContextBlocks(
+                plan, scene, sceneContextLength(shot),
+            );
+        } else {
+            if (Object.hasOwn(revision, "visual_context_source")) {
+                shot.visual_context_source = String(
+                    revision.visual_context_source,
+                );
+                sceneVisualContextSource(plan, scene);
+            } else {
+                delete shot.visual_context_source;
+            }
+            if (Object.hasOwn(revision, "visual_context_start_frame")) {
+                const start = Number(revision.visual_context_start_frame);
+                if (!Number.isInteger(start) || start < 0) {
+                    throw new Error(
+                        `Restored scene ${scene} has an invalid visual context start frame.`,
+                    );
+                }
+                shot.visual_context_start_frame = start;
+            } else {
+                delete shot.visual_context_start_frame;
+            }
+            if (Object.hasOwn(revision, "visual_context_lead_source")) {
+                shot.visual_context_lead_source = String(
+                    revision.visual_context_lead_source,
+                );
+                shot.visual_context_lead_frames = Number(
+                    revision.visual_context_lead_frames,
+                );
+                sceneVisualContextLeadSource(plan, scene);
+                sceneVisualContextSource(plan, scene);
+                sceneVisualContextLeadFrames(shot, sceneContextLength(shot));
+                if (Object.hasOwn(
+                    revision, "visual_context_lead_start_frame",
+                )) {
+                    const start = Number(
+                        revision.visual_context_lead_start_frame,
+                    );
+                    if (!Number.isInteger(start) || start < 0) {
+                        throw new Error(
+                            `Restored scene ${scene} has an invalid composed visual context start frame.`,
+                        );
+                    }
+                    shot.visual_context_lead_start_frame = start;
+                } else {
+                    delete shot.visual_context_lead_start_frame;
+                }
+            } else {
+                delete shot.visual_context_lead_source;
+                delete shot.visual_context_lead_frames;
+                delete shot.visual_context_lead_start_frame;
+            }
+            delete shot.visual_context_blocks;
+        }
+        if (Object.hasOwn(revision, "continuation_mode")) {
+            shot.continuation_mode = String(revision.continuation_mode);
+            sceneContinuationMode(shot);
+        } else {
+            delete shot.continuation_mode;
+        }
+        if (Object.hasOwn(revision, "video_blend_frames")) {
+            shot.video_blend_frames = Number(revision.video_blend_frames);
+            sceneVideoBlendFrames(shot, 0, sceneContextLength(shot));
+        } else {
+            delete shot.video_blend_frames;
+        }
+        if (Object.hasOwn(revision, "context_spatial_proxy")) {
+            const proxy = String(revision.context_spatial_proxy ?? "")
+                .trim().toLowerCase();
+            if (!["rgb_5_6", "latent_5_6"].includes(proxy)) {
+                throw new Error(`Restored scene ${scene} has an invalid context spatial proxy.`);
+            }
+            shot.context_spatial_proxy = proxy;
+        } else {
+            delete shot.context_spatial_proxy;
+        }
+        for (const [key, allowed] of [
+            ["source_reference", ["on", "off"]],
+            ["generated_continuity", ["on", "off"]],
+            ["source_audio_target", ["locked", "off"]],
+        ]) {
+            if (!Object.hasOwn(revision, key)) {
+                delete shot[key];
+                continue;
+            }
+            const value = String(revision[key] ?? "").trim().toLowerCase();
+            if (!allowed.includes(value)) {
+                throw new Error(`Restored scene ${scene} has an invalid ${key}.`);
+            }
+            shot[key] = value;
+        }
+        if (Object.hasOwn(revision, "lora_route")) {
+            shot.lora_route = String(revision.lora_route);
+            if (sceneLoRARoute(shot) === "base") delete shot.lora_route;
+        } else {
+            delete shot.lora_route;
+        }
+        if (Object.hasOwn(revision, "prompt_seed_mode")) {
+            const mode = String(revision.prompt_seed_mode ?? "")
+                .trim().toLowerCase();
+            if (mode === "fixed") {
+                shot.prompt_seed_mode = "fixed";
+                shot.prompt_seed = reviewSeed(revision.prompt_seed);
+            } else if (mode === "randomize") {
+                shot.prompt_seed_mode = "randomize";
+                delete shot.prompt_seed;
+            } else if (mode === "inherit") {
+                delete shot.prompt_seed_mode;
+                delete shot.prompt_seed;
+            } else {
+                throw new Error(`Restored scene ${scene} has an invalid prompt seed mode.`);
+            }
+        } else {
+            delete shot.prompt_seed_mode;
+            delete shot.prompt_seed;
+        }
+        delete shot.frames;
+        delete shot.duration_seconds;
+    }
+    if (shared !== null) {
+        const current = sharedPrompt(plan);
+        plan[current.key] = promptTextToLines(shared);
+    }
+    return plan;
+}
+
+export function applyCheckpointRevisionSeeds(plan, revisions) {
+    if (!plan || !Array.isArray(plan.shots)) {
+        throw new Error("The active Plan has no scenes.");
+    }
+    for (const revision of revisions ?? []) {
+        const scene = Number(revision?.scene);
+        const index = scene - 1;
+        if (!Number.isInteger(scene) || index < 0 || index >= plan.shots.length) {
+            throw new Error("An activated checkpoint scene is outside the active Plan.");
+        }
+        plan.shots[index].seed = reviewSeed(revision.seed);
+    }
+    return plan;
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_review_final.js b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_review_final.js
new file mode 100644
index 0000000000000000000000000000000000000000..811b82c87a26fa46bd6d4a061f75c9822b111ad0
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_review_final.js
@@ -0,0 +1,1953 @@
+import {app} from "/scripts/app.js";
+import {api} from "/scripts/api.js";
+import {
+    parsePlanJson,
+    planToJson,
+    promptValueToText,
+} from "./h3_chain_plan_core.mjs?v=0.6.5";
+import * as promptCompanionSync from "./h3_prompt_companion_sync.mjs?v=0.6.2";
+import {
+    refreshRestoredPlanEditors,
+    restoreConnectedPolicyInputs,
+} from "./h3_plan_restore_core.mjs?v=0.6.6";
+import {
+    acceptedPreviewDisposition,
+    applyCheckpointRevisionSet,
+    applyReviewEdit,
+    checkpointRevisionChain,
+    checkpointResumeOptions,
+    reviewCountdown,
+    reviewDuration,
+    reviewDurationText,
+    reviewLocalDeadline,
+    reviewPlanScenePrompt,
+    reviewSeed,
+} from "./h3_chain_review_core.mjs?v=0.6.5";
+
+const NODE_NAME = "MiniMaxH3ChainReview";
+const PLAN_NAME = "MiniMaxH3ChainPlan";
+const PLAN_NAMES = new Set([PLAN_NAME, "MiniMaxH3ChainPlanModern"]);
+const PROMPT_EDITOR_SETTING = "MiniMaxH3ContexLoop.ReviewGate.PromptEditor";
+const VIDEO_HEIGHT_PROPERTY = "h3_chain_review_video_height";
+const PROMPT_HEIGHT_PROPERTY = "h3_chain_review_prompt_height";
+const DEFAULT_VIDEO_HEIGHT = 300;
+const MIN_VIDEO_HEIGHT = 140;
+const MAX_VIDEO_HEIGHT = 1200;
+const notifiedTokens = new Set();
+const mountedReviewNodes = new Set();
+let notificationAudioContext = null;
+let pendingFetchPromise = null;
+let pendingPollTimer = null;
+const activeSceneExecutions = new Map();
+const reviewInterruptionWaiters = new Map();
+
+function sceneExecutionKey(runName, clipIndex) {
+    return `${String(runName ?? "").trim()}\u0000${Number(clipIndex)}`;
+}
+
+function activeSceneFromExecutedOutput(output) {
+    const values = output?.h3_chain_active_scene;
+    const value = Array.isArray(values) ? values.at(-1) : null;
+    const clipIndex = Number(value?.clip_index);
+    if (!value || !String(value.run_name ?? "").trim()
+            || !Number.isInteger(clipIndex) || clipIndex < 1) return null;
+    return {
+        runName: String(value.run_name).trim(),
+        clipIndex,
+    };
+}
+
+function trackActiveSceneExecution(data) {
+    const scene = activeSceneFromExecutedOutput(data?.output);
+    const promptId = String(data?.prompt_id ?? "");
+    if (!scene || !promptId) return;
+    activeSceneExecutions.set(
+        sceneExecutionKey(scene.runName, scene.clipIndex),
+        {promptId, displayNode: String(data?.display_node ?? "")},
+    );
+}
+
+function waitForReviewInterruption(promptId, timeoutMilliseconds = 30000) {
+    let timer;
+    const promise = new Promise((resolve, reject) => {
+        timer = window.setTimeout(() => {
+            reviewInterruptionWaiters.delete(promptId);
+            reject(new Error(
+                "ComfyUI did not confirm candidate interruption within 30 seconds."));
+        }, timeoutMilliseconds);
+        reviewInterruptionWaiters.set(promptId, {
+            resolve: () => {
+                window.clearTimeout(timer);
+                reviewInterruptionWaiters.delete(promptId);
+                resolve();
+            },
+            reject: (message) => {
+                window.clearTimeout(timer);
+                reviewInterruptionWaiters.delete(promptId);
+                reject(new Error(message));
+            },
+        });
+    });
+    // The websocket terminal event can beat the cancellation HTTP response.
+    void promise.catch(() => {});
+    return {
+        promise,
+        cancel() {
+            window.clearTimeout(timer);
+            reviewInterruptionWaiters.delete(promptId);
+        },
+    };
+}
+
+function finishTrackedReviewExecution(kind, data) {
+    const promptId = String(data?.prompt_id ?? "");
+    if (!promptId) return;
+    for (const [key, record] of activeSceneExecutions) {
+        if (record.promptId !== promptId) continue;
+        record.terminal = kind;
+        window.setTimeout(() => {
+            if (activeSceneExecutions.get(key) === record) {
+                activeSceneExecutions.delete(key);
+            }
+        }, 60000);
+    }
+    const waiter = reviewInterruptionWaiters.get(promptId);
+    if (!waiter) return;
+    if (kind === "interrupted") waiter.resolve();
+    else waiter.reject(
+        kind === "success"
+            ? "The candidate finished before targeted cancellation."
+            : "The H3 prompt ended before candidate cancellation was confirmed.",
+    );
+}
+
+function reviewPromptEditorEnabled() {
+    return app.ui?.settings?.getSettingValue?.(PROMPT_EDITOR_SETTING) === true;
+}
+
+// A browser can briefly retain the preceding companion module after updating
+// a custom node. Namespace access keeps Review Gate mountable in that state;
+// prompt synchronization becomes a no-op until the module cache refreshes.
+function publishCompanionPrompt(...args) {
+    return promptCompanionSync.publishCompanionPrompt?.(...args) ?? 0;
+}
+
+function publishPlanCompanionScene(...args) {
+    return promptCompanionSync.publishPlanCompanionScene?.(...args) ?? 0;
+}
+
+function ensureNotificationAudioContext() {
+    const AudioContext = window.AudioContext ?? window.webkitAudioContext;
+    if (!AudioContext) return null;
+    notificationAudioContext ??= new AudioContext();
+    return notificationAudioContext;
+}
+
+function unlockNotificationAudio() {
+    ensureNotificationAudioContext()?.resume?.().catch(() => {});
+}
+
+// Queueing a workflow is normally the needed user gesture. Prime WebAudio on
+// the first interaction so a much later review notification is not rejected by
+// browser autoplay policy.
+window.addEventListener("pointerdown", unlockNotificationAudio, {once: true, capture: true});
+window.addEventListener("keydown", unlockNotificationAudio, {once: true, capture: true});
+
+async function playReviewChime() {
+    const context = ensureNotificationAudioContext();
+    if (!context) return;
+    if (context.state === "suspended") {
+        await context.resume();
+    }
+    const now = context.currentTime;
+    const gain = context.createGain();
+    gain.gain.setValueAtTime(0.0001, now);
+    gain.gain.exponentialRampToValueAtTime(0.12, now + 0.015);
+    gain.gain.exponentialRampToValueAtTime(0.0001, now + 0.55);
+    gain.connect(context.destination);
+    for (const [frequency, delay] of [[660, 0], [880, 0.16]]) {
+        const oscillator = context.createOscillator();
+        oscillator.type = "sine";
+        oscillator.frequency.value = frequency;
+        oscillator.connect(gain);
+        oscillator.start(now + delay);
+        oscillator.stop(now + delay + 0.28);
+    }
+}
+
+function injectStyles() {
+    if (document.getElementById("h3-chain-review-style")) return;
+    const style = document.createElement("style");
+    style.id = "h3-chain-review-style";
+    style.textContent = `
+        .h3r-root { box-sizing:border-box; display:flex; flex-direction:column; gap:8px;
+            min-height:500px; padding:9px; overflow:auto; border:1px solid #56637e;
+            border-radius:8px; background:#181a20; color:#e8eaf0; font:12px/1.35 system-ui,sans-serif; }
+        .h3r-root * { box-sizing:border-box; }
+        .h3r-root [hidden] { display:none !important; }
+        .h3r-head { display:flex; align-items:center; justify-content:space-between; gap:8px; }
+        .h3r-title { font-weight:750; color:#a9c2ff; }
+        .h3r-badge { color:#d5d9e3; opacity:.75; }
+        .h3r-video-panel { width:100%; height:300px; min-height:140px; max-height:1200px;
+            flex:0 0 auto; display:flex; flex-direction:column; overflow:hidden;
+            border:1px solid #343b4b; border-radius:6px; background:#08090c; }
+        .h3r-video { width:100%; height:calc(100% - 11px); min-height:0; display:block;
+            flex:1 1 auto; background:#08090c; object-fit:contain; }
+        .h3r-video-grip { height:11px; flex:0 0 11px; cursor:ns-resize;
+            border-top:1px solid #343b4b; background:linear-gradient(180deg,#252a35,#171a21);
+            position:relative; touch-action:none; }
+        .h3r-video-grip::after { content:""; position:absolute; left:calc(50% - 20px); top:4px;
+            width:40px; height:2px; border-top:1px solid #7e899f;
+            border-bottom:1px solid #4f586b; }
+        .h3r-video-grip:hover { background:linear-gradient(180deg,#313848,#1d212b); }
+        .h3r-label { display:flex; flex-direction:column; gap:4px; color:#aeb5c5; }
+        .h3r-prompt { width:100%; min-height:120px; resize:vertical; padding:7px;
+            border:1px solid #56637e; border-radius:5px; background:#101218; color:#eef1f7; }
+        .h3r-prompt-notice { padding:8px 9px; border:1px solid #56637e;
+            border-radius:6px; background:#202431; color:#cbd3e5; white-space:pre-wrap; }
+        .h3r-row { display:flex; align-items:flex-end; gap:7px; }
+        .h3r-field { display:flex; flex-direction:column; gap:4px; min-width:0;
+            color:#aeb5c5; }
+        .h3r-field-seed { flex:2 1 0; }
+        .h3r-field-duration { flex:1 1 0; }
+        .h3r-seed { width:100%; min-width:0; padding:6px 7px; border:1px solid #56637e;
+            border-radius:5px; background:#101218; color:#eef1f7; }
+        .h3r-duration { width:100%; min-width:0; padding:6px 7px;
+            border:1px solid #56637e; border-radius:5px; background:#101218;
+            color:#eef1f7; }
+        .h3r-candidates { display:flex; flex-direction:column; gap:7px; padding:8px;
+            border:1px solid #4c6388; border-radius:6px; background:#172033; }
+        .h3r-candidate-nav { display:grid; grid-template-columns:auto minmax(0,1fr) auto;
+            align-items:center; gap:7px; }
+        .h3r-candidate-title { min-width:0; text-align:center; color:#a9c2ff;
+            font-weight:700; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+        .h3r-candidate-arrow { width:38px; padding:5px; font-size:16px; }
+        .h3r-candidate-meta { display:flex; align-items:center; justify-content:space-between;
+            gap:8px; min-width:0; }
+        .h3r-candidate-keep { display:flex; align-items:center; gap:6px; color:#d6e3ff;
+            cursor:pointer; user-select:none; }
+        .h3r-candidate-progress { color:#9ca8bc; font-size:10px; text-align:right; }
+        .h3r-candidate-dots { display:flex; flex-wrap:wrap; justify-content:center; gap:6px; }
+        .h3r-candidate-dot { width:11px; height:11px; padding:0; border:1px solid #71809c;
+            border-radius:50%; background:#343b4b; cursor:pointer; }
+        .h3r-candidate-dot:hover { background:#526078; }
+        .h3r-candidate-dot.h3r-selected { outline:2px solid #a9c2ff;
+            outline-offset:2px; background:#6f8fd0; }
+        .h3r-candidate-dot.h3r-kept { border-color:#70d39c; background:#347a54; }
+        .h3r-actions { display:grid; grid-template-columns:repeat(2,minmax(0,1fr)); gap:7px; }
+        .h3r-button { padding:7px; border:1px solid #63708b; border-radius:5px;
+            background:#292e3a; color:#eef1f7; cursor:pointer; }
+        .h3r-button:hover { background:#343b4b; }
+        .h3r-button:disabled { opacity:.42; cursor:not-allowed; }
+        .h3r-button:disabled:hover { background:#292e3a; }
+        .h3r-approve { border-color:#4b9d72; background:#204332; }
+        .h3r-retry { border-color:#b58b45; background:#4a3820; }
+        .h3r-stop { border-color:#8a6171; background:#3b252d; }
+        .h3r-status { min-height:18px; color:#aeb5c5; white-space:pre-wrap; }
+        .h3r-warning { color:#f2bd67; }
+        .h3r-prefix { margin:0; padding:6px 7px; max-height:90px; overflow:auto;
+            border-left:2px solid #56637e; color:#aeb5c5; white-space:pre-wrap; }
+        .h3r-resume { display:flex; flex-direction:column; gap:6px; margin-top:2px;
+            padding:8px; border:1px solid #3f4759; border-radius:6px; background:#14161c; }
+        .h3r-resume-title { font-weight:700; color:#a9c2ff; }
+        .h3r-resume-row { display:flex; gap:6px; align-items:center; }
+        .h3r-resume-select { flex:1; min-width:0; padding:6px; border:1px solid #56637e;
+            border-radius:5px; background:#101218; color:#eef1f7; }
+        .h3r-resume-status { color:#8f98aa; white-space:pre-wrap; }
+        .h3r-revisions { display:flex; flex-direction:column; gap:6px; padding-top:4px;
+            border-top:1px solid #343b4b; }
+        .h3r-revisions-title { font-weight:650; color:#c3cad8; }
+        .h3r-revision-rows { display:flex; flex-direction:column; gap:6px; }
+        .h3r-revision-row { display:grid; grid-template-columns:auto minmax(0,1fr) auto;
+            gap:6px; align-items:center; }
+        .h3r-revision-label { min-width:54px; color:#aeb5c5; }
+        .h3r-revision-select { min-width:0; padding:6px; border:1px solid #56637e;
+            border-radius:5px; background:#101218; color:#eef1f7; }
+        .h3r-delete { border-color:#8a6171; background:#3b252d; }
+        .h3r-root.h3r-busy .h3r-actions .h3r-button { opacity:.45; pointer-events:none; }
+        .h3r-root.h3r-busy .h3r-candidates { opacity:.55; pointer-events:none; }
+    `;
+    document.head.appendChild(style);
+}
+
+function nodeType(node) {
+    return node?.comfyClass ?? node?.type ?? null;
+}
+
+function findNodeByQualifiedId(qid) {
+    if (!app.graph || qid == null) return null;
+    const parts = String(qid).split(":");
+    let graph = app.graph;
+    for (let i = 0; i < parts.length - 1; i += 1) {
+        const id = Number(parts[i]);
+        const parent = Number.isFinite(id) ? graph?.getNodeById?.(id) : null;
+        if (!parent?.subgraph) return null;
+        graph = parent.subgraph;
+    }
+    const leaf = Number(parts.at(-1));
+    return Number.isFinite(leaf) ? graph?.getNodeById?.(leaf) ?? null : null;
+}
+
+function allNodes(graph, output = []) {
+    for (const node of graph?._nodes ?? []) {
+        output.push(node);
+        if (node.subgraph) allNodes(node.subgraph, output);
+    }
+    return output;
+}
+
+function findUpstreamNode(start, wantedType) {
+    const queue = [start];
+    const seen = new Set();
+    while (queue.length) {
+        const node = queue.shift();
+        if (!node || seen.has(node)) continue;
+        seen.add(node);
+        const matches = wantedType instanceof Set
+            ? wantedType.has(nodeType(node)) : nodeType(node) === wantedType;
+        if (node !== start && matches) return node;
+        for (const input of node.inputs ?? []) {
+            if (input.link == null) continue;
+            const link = node.graph?.links?.[input.link];
+            const parent = link ? node.graph?.getNodeById?.(link.origin_id) : null;
+            if (parent) queue.push(parent);
+        }
+    }
+    return null;
+}
+
+function videoUrl(item) {
+    const query = new URLSearchParams({
+        filename: item.filename,
+        subfolder: item.subfolder ?? "",
+        type: item.type ?? "output",
+    });
+    return api.apiURL(`/view?${query.toString()}`);
+}
+
+function upstreamPlanNode(reviewNode) {
+    return findUpstreamNode(reviewNode, PLAN_NAMES) ??
+        allNodes(app.graph).find((item) => PLAN_NAMES.has(nodeType(item)));
+}
+
+function widgetByName(node, name) {
+    return node?.widgets?.find((item) => item.name === name);
+}
+
+function planResumeContext(reviewNode) {
+    const planNode = upstreamPlanNode(reviewNode);
+    const planWidget = widgetByName(planNode, "plan_json");
+    const runWidget = widgetByName(planNode, "run_name");
+    if (!planWidget || !runWidget) {
+        throw new Error("Connect this Review Gate to an H3 Chain Plan and Loop Start.");
+    }
+    const plan = parsePlanJson(String(planWidget.value ?? ""));
+    const runName = String(runWidget.value ?? "").trim();
+    if (!runName) throw new Error("The H3 Chain Plan run_name is empty.");
+    return {runName, clipCount: plan.shots.length};
+}
+
+function updatePlan(reviewNode, index, prompt, seed, length) {
+    const planNode = upstreamPlanNode(reviewNode);
+    const widget = planNode?.widgets?.find((item) => item.name === "plan_json");
+    if (!widget) return false;
+    const sceneIndex = Number(index) - 1;
+    const plan = applyReviewEdit(
+        parsePlanJson(String(widget.value ?? "")), index, prompt, seed, length,
+    );
+    const value = planToJson(plan);
+    widget.value = value;
+    widget.callback?.(value);
+    refreshRestoredPlanEditors(planNode);
+    planNode.graph?.setDirtyCanvas?.(true, true);
+    publishCompanionPrompt(
+        reviewNode,
+        planNode,
+        sceneIndex,
+        promptValueToText(plan.shots[sceneIndex]?.prompt),
+    );
+    return true;
+}
+
+function planScenePrompt(reviewNode, review) {
+    try {
+        const planNode = upstreamPlanNode(reviewNode);
+        const widget = widgetByName(planNode, "plan_json");
+        if (!widget) return null;
+        return reviewPlanScenePrompt(
+            parsePlanJson(String(widget.value ?? "")),
+            review?.clip_index,
+            review?.shot_id,
+        );
+    } catch (_error) {
+        return null;
+    }
+}
+
+function updatePlanFromCheckpointRevisions(reviewNode, revisions) {
+    const planNode = upstreamPlanNode(reviewNode);
+    const widget = planNode?.widgets?.find((item) => item.name === "plan_json");
+    if (!widget) return false;
+    const plan = applyCheckpointRevisionSet(
+        parsePlanJson(String(widget.value ?? "")), revisions,
+    );
+    const value = planToJson(plan);
+    widget.value = value;
+    widget.callback?.(value);
+    refreshRestoredPlanEditors(planNode);
+    planNode.graph?.setDirtyCanvas?.(true, true);
+    for (const revision of revisions ?? []) {
+        const sceneIndex = Number(revision?.scene) - 1;
+        if (sceneIndex < 0 || sceneIndex >= plan.shots.length) continue;
+        publishCompanionPrompt(
+            reviewNode,
+            planNode,
+            sceneIndex,
+            promptValueToText(plan.shots[sceneIndex]?.prompt),
+        );
+    }
+    return true;
+}
+
+function restoreSavedPlanInputs(reviewNode, inputs, policyInputs = {}) {
+    const planNode = upstreamPlanNode(reviewNode);
+    if (!planNode || !inputs || typeof inputs !== "object") {
+        throw new Error("The saved run has no Plan inputs to restore.");
+    }
+    const names = Object.keys(inputs).sort((left, right) =>
+        Number(left === "plan_json") - Number(right === "plan_json"));
+    const applied = [];
+    const unavailable = [];
+    const graph = planNode.graph ?? app.graph;
+    graph?.beforeChange?.();
+    try {
+        for (const name of names) {
+            const widget = widgetByName(planNode, name);
+            if (!widget) {
+                unavailable.push(name);
+                continue;
+            }
+            widget.value = inputs[name];
+            widget.callback?.(inputs[name]);
+            applied.push(name);
+        }
+    } finally {
+        graph?.afterChange?.();
+    }
+    if (!applied.includes("plan_json")) {
+        throw new Error("The connected Plan does not expose an editable plan_json widget.");
+    }
+    const planWidget = widgetByName(planNode, "plan_json");
+    const plan = parsePlanJson(String(planWidget?.value ?? ""));
+    const policies = restoreConnectedPolicyInputs(
+        planNode, policyInputs, inputs);
+    refreshRestoredPlanEditors(planNode);
+    app.graph?.setDirtyCanvas?.(true, true);
+    for (const [sceneIndex, shot] of plan.shots.entries()) {
+        publishCompanionPrompt(
+            reviewNode,
+            planNode,
+            sceneIndex,
+            promptValueToText(shot.prompt),
+        );
+    }
+    return {sceneCount: plan.shots.length, unavailable, policies};
+}
+
+function formatBytes(value) {
+    let size = Math.max(0, Number(value) || 0);
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    let unit = 0;
+    while (size >= 1024 && unit < units.length - 1) {
+        size /= 1024;
+        unit += 1;
+    }
+    const digits = unit === 0 || size >= 100 ? 0 : size >= 10 ? 1 : 2;
+    return `${size.toFixed(digits)} ${units[unit]}`;
+}
+
+function checkpointRevisionLabel(revision) {
+    const active = revision.active ? "Active · " : "";
+    const date = revision.createdAt
+        ? new Date(revision.createdAt).toLocaleString() : "unknown time";
+    const seed = revision.seed ? ` · seed ${revision.seed}` : "";
+    return `${active}${date} · ${revision.revision.slice(0, 8)}${seed} · ${formatBytes(revision.sizeBytes)}`;
+}
+
+function prepareResume(reviewNode, nextIndex, endIndex = null, clipCount = null) {
+    const startNode = findUpstreamNode(reviewNode, "MiniMaxH3ChainLoopStart") ??
+        allNodes(app.graph).find((item) => nodeType(item) === "MiniMaxH3ChainLoopStart");
+    const widget = startNode?.widgets?.find((item) => item.name === "start_clip");
+    if (!widget) return false;
+    widget.value = nextIndex;
+    widget.callback?.(nextIndex);
+    // An explicit range overrides start_clip in the backend. Checkpoint loads
+    // clear it; immediate candidate acceptance preserves a shorter active
+    // range while advancing to its next scene.
+    const rangeWidget = startNode.widgets?.find((item) => item.name === "scene_range");
+    if (rangeWidget) {
+        const end = Number(endIndex);
+        const total = Number(clipCount);
+        const range = Number.isInteger(end) && Number.isInteger(total) &&
+                nextIndex <= end && end < total
+            ? nextIndex === end ? String(nextIndex) : `${nextIndex}:${end}`
+            : "";
+        rangeWidget.value = range;
+        rangeWidget.callback?.(range);
+    }
+    startNode.graph?.setDirtyCanvas?.(true, true);
+    return true;
+}
+
+async function activateAcceptedCandidate(reviewNode, submittedReview, body) {
+    const endClip = Number(submittedReview.end_clip ?? submittedReview.clip_count);
+    const clipIndex = Number(submittedReview.clip_index);
+    if (!Number.isInteger(endClip) || clipIndex >= endClip) {
+        return {
+            immediate: false,
+            message: "This is the last scene in the active range, so the current " +
+                "take must reach Loop End before the selected checkpoint can finish it.",
+        };
+    }
+    const execution = activeSceneExecutions.get(sceneExecutionKey(
+        submittedReview.run_name, clipIndex));
+    if (!execution?.promptId) {
+        return {
+            immediate: false,
+            message: "The exact running prompt could not be identified; the " +
+                "selection is armed and will stop at the next safe boundary.",
+        };
+    }
+    const revisions = Array.isArray(body.resume_revisions)
+        ? body.resume_revisions : [];
+    if (revisions.length !== clipIndex) {
+        return {
+            immediate: false,
+            message: "The selected checkpoint lineage could not be activated " +
+                "immediately; the selection remains armed at the safe boundary.",
+        };
+    }
+    const saved = updatePlan(
+        reviewNode, clipIndex, body.scene_prompt, body.seed, body.length);
+    if (!saved) {
+        return {
+            immediate: false,
+            message: "The connected Plan could not be updated; the selection " +
+                "remains armed at the safe boundary.",
+        };
+    }
+    const activationResponse = await api.fetchApi(
+        "/minimax_h3_context_loop/checkpoint-revisions/restore", {
+            method: "POST",
+            headers: {"Content-Type": "application/json"},
+            body: JSON.stringify({
+                run_name: submittedReview.run_name,
+                resume_scene: Number(body.resume_scene),
+                revisions,
+                activate_only: true,
+            }),
+        },
+    );
+    const activation = await activationResponse.json().catch(() => ({}));
+    if (!activationResponse.ok) {
+        return {
+            immediate: false,
+            message: `${activation.error || `HTTP ${activationResponse.status}`} ` +
+                "The selection remains armed at the safe boundary.",
+        };
+    }
+
+    if (execution.terminal === "success") {
+        return {
+            immediate: false,
+            message: "The speculative prompt already completed; its Review " +
+                "boundary is applying the armed selection now.",
+        };
+    }
+    if (execution.terminal !== "interrupted" && execution.terminal !== "error") {
+        const waiter = waitForReviewInterruption(execution.promptId);
+        const cancelResponse = await api.fetchApi(
+            `/api/jobs/${encodeURIComponent(execution.promptId)}/cancel`,
+            {method: "POST"},
+        );
+        const cancelled = await cancelResponse.json().catch(() => ({}));
+        if (!cancelResponse.ok) {
+            waiter.cancel();
+            return {
+                immediate: false,
+                message: `${cancelled.error ||
+                    `Targeted cancellation failed (HTTP ${cancelResponse.status}).`} ` +
+                    "The selection remains armed at the safe boundary.",
+            };
+        }
+        if (!cancelled.cancelled) {
+            waiter.cancel();
+            return {
+                immediate: false,
+                message: "The speculative take finished during cancellation; the " +
+                    "armed selection will be applied by Review Gate now.",
+            };
+        }
+        await waiter.promise;
+    }
+    const nextIndex = clipIndex + 1;
+    if (!prepareResume(
+        reviewNode, nextIndex, endClip, Number(submittedReview.clip_count))) {
+        throw new Error(
+            `Candidate accepted and sampling stopped, but Loop Start could not ` +
+            `be armed for scene ${nextIndex}. Queue it manually from that scene.`);
+    }
+
+    let cleanupWarning = "";
+    try {
+        const finalizeResponse = await api.fetchApi(
+            "/minimax_h3_context_loop/review-candidate-batch", {
+                method: "POST",
+                headers: {"Content-Type": "application/json"},
+                body: JSON.stringify({
+                    token: submittedReview.token,
+                    action: "finalize",
+                    candidate_revision: body.candidate_revision,
+                }),
+            },
+        );
+        const finalize = await finalizeResponse.json().catch(() => ({}));
+        if (!finalizeResponse.ok) {
+            cleanupWarning = ` Candidate cleanup warning: ${finalize.error ||
+                `HTTP ${finalizeResponse.status}`}`;
+        } else if (Array.isArray(finalize.cleanup_warnings) &&
+                finalize.cleanup_warnings.length) {
+            cleanupWarning = ` Candidate cleanup warning: ${
+                finalize.cleanup_warnings.join(" ")}`;
+        }
+    } catch (error) {
+        cleanupWarning = ` Candidate cleanup warning: ${error.message}`;
+    }
+    await app.queuePrompt(0, 1);
+    return {immediate: true, nextIndex, saved, cleanupWarning};
+}
+
+function fetchPending() {
+    if (pendingFetchPromise) return pendingFetchPromise;
+    pendingFetchPromise = (async () => {
+        try {
+            const response = await api.fetchApi("/minimax_h3_context_loop/reviews");
+            if (!response.ok) return 0;
+            const body = await response.json();
+            const reviews = body.reviews ?? [];
+            for (const review of reviews) routeReview(review);
+            return reviews.length;
+        } catch (error) {
+            console.warn("[H3 Chain Review] Could not recover pending reviews:", error);
+            return 0;
+        } finally {
+            pendingFetchPromise = null;
+        }
+    })();
+    return pendingFetchPromise;
+}
+
+function planRunNameTrusted(planNode) {
+    // Project Assets replaces Plan.run_name server-side while the plan editor
+    // deliberately leaves that now-hidden widget unchanged. Psylent_Gamer
+    // (4090) identified this Review Gate routing split through Banodoco.
+    if (!planNode) return true;
+    const input = planNode.inputs?.find((item) => item.name === "project_assets");
+    return input?.link === null || input?.link === undefined;
+}
+
+function deliverReview(node, data) {
+    if (!node || nodeType(node) !== NODE_NAME) return false;
+    const expectedRun = String(data?.run_name ?? "").trim();
+    if (expectedRun) {
+        const planNode = findUpstreamNode(node, PLAN_NAMES);
+        if (planRunNameTrusted(planNode)) {
+            const actualRun = String(
+                widgetByName(planNode, "run_name")?.value ?? "",
+            ).trim();
+            if (actualRun && actualRun !== expectedRun) return false;
+        }
+    }
+    if (typeof node._h3ReviewHandler === "function") {
+        node._h3ReviewHandler(data);
+    } else {
+        // A websocket event can arrive between node creation and the DOM
+        // widget's deferred mount. Preserve it instead of leaving a live
+        // backend future with no token in the browser.
+        node._h3QueuedReview = data;
+    }
+    return true;
+}
+
+function reviewFallbackNode(data) {
+    const gates = [...new Set([
+        ...allNodes(app.graph).filter((item) => nodeType(item) === NODE_NAME),
+        ...[...mountedReviewNodes].filter((item) => nodeType(item) === NODE_NAME),
+    ])];
+    const expectedRun = String(data?.run_name ?? "").trim();
+    if (expectedRun) {
+        const matchingRun = gates.filter((item) => {
+            const planNode = findUpstreamNode(item, PLAN_NAMES);
+            if (!planRunNameTrusted(planNode)) return false;
+            return String(widgetByName(planNode, "run_name")?.value ?? "").trim() ===
+                expectedRun;
+        });
+        if (matchingRun.length === 1) return matchingRun[0];
+    }
+    // GraphBuilder execution ids use dots while subgraph-qualified display
+    // ids use colons. The visible LiteGraph node is always the final leaf.
+    const leaf = String(data?.node_id ?? "").split(/[.:]/).at(-1);
+    const matchingLeaf = gates.filter((item) => String(item.id) === leaf);
+    if (matchingLeaf.length === 1) return matchingLeaf[0];
+    return gates.length === 1 ? gates[0] : null;
+}
+
+function routeReview(data) {
+    const exact = findNodeByQualifiedId(data?.node_id);
+    if (deliverReview(exact, data)) return true;
+    const fallback = reviewFallbackNode(data);
+    if (deliverReview(fallback, data)) {
+        console.warn(
+            `[H3 Chain Review] Display node ${data?.node_id} was not directly ` +
+            "resolvable; routed the pending review to the only matching gate.",
+        );
+        return true;
+    }
+    console.warn(
+        `[H3 Chain Review] Pending token ${data?.token ?? "?"} could not be ` +
+        `routed to display node ${data?.node_id ?? "?"}.`,
+    );
+    return false;
+}
+
+function routeReviewResolved(data) {
+    const exact = findNodeByQualifiedId(data?.node_id);
+    const node = nodeType(exact) === NODE_NAME ? exact : reviewFallbackNode(data);
+    node?._h3ReviewResolvedHandler?.(data);
+}
+
+function updatePendingPolling() {
+    if (mountedReviewNodes.size > 0 && pendingPollTimer == null) {
+        // send_sync targets the browser session that queued the prompt. A
+        // reconnect, reverse proxy, sleeping tab, or websocket race can miss
+        // that event even though the backend review remains healthy. Polling
+        // this tiny in-memory endpoint makes the pending token recoverable.
+        pendingPollTimer = window.setInterval(() => {
+            if (document.visibilityState !== "hidden") fetchPending();
+        }, 2000);
+    } else if (mountedReviewNodes.size === 0 && pendingPollTimer != null) {
+        window.clearInterval(pendingPollTimer);
+        pendingPollTimer = null;
+    }
+}
+
+function mount(node) {
+    if (node._h3ReviewMounted || typeof node.addDOMWidget !== "function") return;
+    node._h3ReviewMounted = true;
+    injectStyles();
+
+    const root = document.createElement("div");
+    root.className = "h3r-root";
+    root.tabIndex = 0;
+    root.title = "Review each persisted H3 scene with synchronized sound, then approve, retry, reroll, stop, or arm a saved checkpoint for resume.";
+    // LiteGraph listens to pointer events on the canvas. Shield the complete
+    // pointer sequence, not only mousedown: Firefox can otherwise let the
+    // canvas capture pointerdown before a DOM-widget button receives click.
+    for (const eventName of [
+        "pointerdown", "pointerup", "mousedown", "mouseup", "click", "dblclick",
+    ]) {
+        root.addEventListener(eventName, (event) => event.stopPropagation());
+    }
+    root.addEventListener("wheel", (event) => event.stopPropagation());
+
+    const head = document.createElement("div");
+    head.className = "h3r-head";
+    const title = document.createElement("span");
+    title.className = "h3r-title";
+    title.textContent = "H3 Segment Review";
+    const badge = document.createElement("span");
+    badge.className = "h3r-badge";
+    badge.textContent = "waiting for segment…";
+    head.append(title, badge);
+
+    const video = document.createElement("video");
+    video.className = "h3r-video";
+    video.controls = true;
+    video.preload = "metadata";
+    video.playsInline = true;
+    video.title = "Saved delivered scene preview. Review motion, continuity, and synchronized audio before choosing an action.";
+    const videoPanel = document.createElement("div");
+    videoPanel.className = "h3r-video-panel";
+    videoPanel.title = "Resizable saved-scene preview.";
+    const videoGrip = document.createElement("div");
+    videoGrip.className = "h3r-video-grip";
+    videoGrip.title = "Drag vertically to resize the video preview. Double-click to reset.";
+    videoGrip.setAttribute("role", "separator");
+    videoGrip.setAttribute("aria-label", "Resize video preview");
+    videoGrip.setAttribute("aria-orientation", "horizontal");
+    videoPanel.append(video, videoGrip);
+
+    node.properties ??= {};
+    const savedVideoHeight = Number(node.properties[VIDEO_HEIGHT_PROPERTY]);
+    const initialVideoHeight = Number.isFinite(savedVideoHeight)
+        ? Math.max(MIN_VIDEO_HEIGHT, Math.min(MAX_VIDEO_HEIGHT, savedVideoHeight))
+        : DEFAULT_VIDEO_HEIGHT;
+    videoPanel.style.height = `${initialVideoHeight}px`;
+
+    let videoResize = null;
+    function setVideoHeight(height, persist = false) {
+        const next = Math.round(Math.max(
+            MIN_VIDEO_HEIGHT,
+            Math.min(MAX_VIDEO_HEIGHT, Number(height) || DEFAULT_VIDEO_HEIGHT),
+        ));
+        videoPanel.style.height = `${next}px`;
+        videoGrip.setAttribute("aria-valuenow", String(next));
+        if (persist) {
+            node.properties[VIDEO_HEIGHT_PROPERTY] = next;
+            node.graph?.setDirtyCanvas?.(true, true);
+            app.graph?.setDirtyCanvas?.(true, true);
+        }
+    }
+    setVideoHeight(initialVideoHeight);
+    videoGrip.addEventListener("pointerdown", (event) => {
+        event.preventDefault();
+        const layoutHeight = videoPanel.offsetHeight;
+        const visualHeight = videoPanel.getBoundingClientRect().height;
+        const displayScale = layoutHeight > 0 && visualHeight > 0
+            ? visualHeight / layoutHeight : 1;
+        videoResize = {
+            pointerId: event.pointerId,
+            startY: event.clientY,
+            startHeight: layoutHeight || DEFAULT_VIDEO_HEIGHT,
+            displayScale,
+        };
+        videoGrip.setPointerCapture?.(event.pointerId);
+    });
+    videoGrip.addEventListener("pointermove", (event) => {
+        if (!videoResize || event.pointerId !== videoResize.pointerId) return;
+        event.preventDefault();
+        setVideoHeight(videoResize.startHeight
+            + (event.clientY - videoResize.startY) / videoResize.displayScale);
+    });
+    function finishVideoResize(event) {
+        if (!videoResize || event.pointerId !== videoResize.pointerId) return;
+        videoResize = null;
+        // offsetHeight is an unscaled layout value. getBoundingClientRect()
+        // includes ComfyUI canvas zoom and caused every release to compound a
+        // smaller screen-space height into the saved CSS height.
+        setVideoHeight(videoPanel.offsetHeight, true);
+        videoGrip.releasePointerCapture?.(event.pointerId);
+    }
+    videoGrip.addEventListener("pointerup", finishVideoResize);
+    videoGrip.addEventListener("pointercancel", finishVideoResize);
+    videoGrip.addEventListener("dblclick", (event) => {
+        event.preventDefault();
+        setVideoHeight(DEFAULT_VIDEO_HEIGHT, true);
+    });
+
+    const prefix = document.createElement("pre");
+    prefix.className = "h3r-prefix";
+    prefix.hidden = true;
+    prefix.title = "Shared prompt prepended to every scene. It is shown for context and is not changed by retrying this scene.";
+
+    const promptLabel = document.createElement("label");
+    promptLabel.className = "h3r-label";
+    promptLabel.append("Scene prompt (used when retrying)");
+    const prompt = document.createElement("textarea");
+    prompt.className = "h3r-prompt";
+    prompt.title = "The connected Prompt Editor and this fallback field share the current Plan scene. Retry regenerates it from the same accepted predecessor.";
+    promptLabel.append(prompt);
+    let promptEditedInGate = false;
+    prompt.addEventListener("input", () => { promptEditedInGate = true; });
+
+    const promptNotice = document.createElement("div");
+    promptNotice.className = "h3r-prompt-notice";
+    promptNotice.textContent = "Prompt editing in Review Gate is disabled by default in 0.5. Use Scene Prompt Editor or Rich Scene Prompt Editor, then Retry or Reroll here.\n\nTo restore the old field: ComfyUI Settings → MiniMax H3 Context Loop → Interface → Review Gate.";
+
+    function refreshPromptEditorSetting() {
+        const enabled = reviewPromptEditorEnabled();
+        promptLabel.hidden = !enabled;
+        prompt.disabled = !enabled;
+        promptNotice.hidden = enabled;
+    }
+    node._h3ReviewRefreshPromptSetting = refreshPromptEditorSetting;
+    refreshPromptEditorSetting();
+
+    let promptResizeObserver = null;
+    function applySavedLayout() {
+        node.properties ??= {};
+        const restoredVideoHeight = Number(node.properties[VIDEO_HEIGHT_PROPERTY]);
+        setVideoHeight(Number.isFinite(restoredVideoHeight)
+            ? restoredVideoHeight : DEFAULT_VIDEO_HEIGHT);
+        const restoredPromptHeight = Number(node.properties[PROMPT_HEIGHT_PROPERTY]);
+        if (Number.isFinite(restoredPromptHeight) && restoredPromptHeight >= 120) {
+            prompt.style.height = `${Math.round(restoredPromptHeight)}px`;
+        } else {
+            prompt.style.removeProperty("height");
+        }
+    }
+    if (typeof ResizeObserver === "function") {
+        let initialized = false;
+        promptResizeObserver = new ResizeObserver(() => {
+            if (!prompt.isConnected) return;
+            const next = Math.round(prompt.offsetHeight);
+            if (!Number.isFinite(next) || next < 120) return;
+            if (!initialized) {
+                initialized = true;
+                return;
+            }
+            if (Number(node.properties?.[PROMPT_HEIGHT_PROPERTY]) === next) return;
+            node.properties ??= {};
+            node.properties[PROMPT_HEIGHT_PROPERTY] = next;
+            node.graph?.setDirtyCanvas?.(true, true);
+            app.graph?.setDirtyCanvas?.(true, true);
+        });
+        promptResizeObserver.observe(prompt);
+    }
+    node._h3ReviewApplyLayout = applySavedLayout;
+    applySavedLayout();
+
+    const seedRow = document.createElement("div");
+    seedRow.className = "h3r-row";
+    const seedField = document.createElement("label");
+    seedField.className = "h3r-field h3r-field-seed";
+    seedField.append("Seed");
+    const seed = document.createElement("input");
+    seed.className = "h3r-seed";
+    seed.inputMode = "numeric";
+    seed.title = "Unsigned 64-bit seed for the current scene. Edit it before Retry, or use Reroll seed to generate a new value automatically.";
+    seedField.append(seed);
+    const durationField = document.createElement("label");
+    durationField.className = "h3r-field h3r-field-duration";
+    durationField.append("Duration (s)");
+    const duration = document.createElement("input");
+    duration.className = "h3r-duration";
+    duration.type = "number";
+    duration.inputMode = "decimal";
+    duration.min = String(5 / 24);
+    duration.max = String(3592 / 24);
+    duration.step = String(17 / 24);
+    duration.title = "Generated scene duration. Retry and Reroll round this upward to H3's exact 17k+5 frame grid, revise the full Plan, and retime downstream scenes. Prompt wording and written timestamps are not changed.";
+    durationField.append(duration);
+    seedRow.append(seedField, durationField);
+
+    const candidateRow = document.createElement("div");
+    candidateRow.className = "h3r-candidates";
+    candidateRow.hidden = true;
+    candidateRow.title = "Preview each saved take. The active candidate's exact video and audio continuation tensors become the next scene's checkpoint state; checked alternatives remain in history.";
+    const candidateNav = document.createElement("div");
+    candidateNav.className = "h3r-candidate-nav";
+    const candidatePrevious = document.createElement("button");
+    candidatePrevious.type = "button";
+    candidatePrevious.className = "h3r-button h3r-candidate-arrow";
+    candidatePrevious.textContent = "←";
+    candidatePrevious.title = "Preview the previous saved candidate.";
+    const candidateTitle = document.createElement("span");
+    candidateTitle.className = "h3r-candidate-title";
+    candidateTitle.textContent = "Candidate";
+    const candidateNext = document.createElement("button");
+    candidateNext.type = "button";
+    candidateNext.className = "h3r-button h3r-candidate-arrow";
+    candidateNext.textContent = "→";
+    candidateNext.title = "Preview the next saved candidate.";
+    candidateNav.append(candidatePrevious, candidateTitle, candidateNext);
+    const candidateMeta = document.createElement("div");
+    candidateMeta.className = "h3r-candidate-meta";
+    const candidateKeepLabel = document.createElement("label");
+    candidateKeepLabel.className = "h3r-candidate-keep";
+    const candidateKeep = document.createElement("input");
+    candidateKeep.type = "checkbox";
+    candidateKeep.title = "Retain this take in checkpoint history even if another take becomes active. The active continuation is always retained; other unchecked alternatives are deleted after acceptance.";
+    candidateKeepLabel.append(candidateKeep, "Keep as alternative");
+    const candidateProgress = document.createElement("span");
+    candidateProgress.className = "h3r-candidate-progress";
+    candidateMeta.append(candidateKeepLabel, candidateProgress);
+    const candidateDots = document.createElement("div");
+    candidateDots.className = "h3r-candidate-dots";
+    candidateDots.setAttribute("role", "tablist");
+    candidateRow.append(candidateNav, candidateMeta, candidateDots);
+
+    const actions = document.createElement("div");
+    actions.className = "h3r-actions";
+    const actionButtons = [];
+    function actionButton(label, className, action) {
+        const button = document.createElement("button");
+        button.className = `h3r-button ${className}`;
+        button.textContent = label;
+        button.type = "button";
+        button.title = {
+            approve: "Accept this saved scene and continue the loop with the next scene.",
+            next_candidate: "Keep any marked takes, resume the workflow, and generate the next candidate for this scene.",
+            retry: "Reject this attempt and regenerate the same scene using the active Plan prompt, seed, and duration.",
+            reroll: "Reject this attempt, assign a new random seed, and regenerate the same scene using the active Plan prompt and duration.",
+            stop: "Accept this scene but stop before the next one. Optionally assemble a partial joined MP4 and arm the next scene for resume.",
+        }[action] ?? "Submit this review decision.";
+        // Keep actions clickable while waiting. If a websocket event or node-id
+        // route was missed, submit() can recover the live token through the
+        // pending-review endpoint and perform the requested action immediately.
+        button.disabled = false;
+        button.addEventListener("click", (event) => {
+            event.preventDefault();
+            event.stopPropagation();
+            void submit(action);
+        });
+        actions.append(button);
+        actionButtons.push(button);
+        return button;
+    }
+    const approveButton = actionButton(
+        "Approve & continue", "h3r-approve", "approve");
+    const nextCandidateButton = actionButton(
+        "Generate next candidate", "h3r-retry", "next_candidate");
+    nextCandidateButton.hidden = true;
+    const retryButton = actionButton(
+        "Retry scene / seed / length", "h3r-retry", "retry");
+    const rerollButton = actionButton(
+        "Reroll seed", "h3r-retry", "reroll");
+    const stopButton = actionButton(
+        "Approve & stop", "h3r-stop", "stop");
+
+    const status = document.createElement("div");
+    status.className = "h3r-status";
+    status.textContent = "The loop will pause here after each saved segment.";
+
+    const resume = document.createElement("section");
+    resume.className = "h3r-resume";
+    const resumeTitle = document.createElement("div");
+    resumeTitle.className = "h3r-resume-title";
+    resumeTitle.textContent = "Resume from saved checkpoint";
+    const resumeRow = document.createElement("div");
+    resumeRow.className = "h3r-resume-row";
+    const resumeSelect = document.createElement("select");
+    resumeSelect.className = "h3r-resume-select";
+    resumeSelect.title = "Choose the next scene to render. Its immediately preceding saved checkpoint supplies the visual and AV continuation state.";
+    const refreshResume = document.createElement("button");
+    refreshResume.type = "button";
+    refreshResume.className = "h3r-button";
+    refreshResume.textContent = "Refresh";
+    refreshResume.title = "Scan this run's checkpoint folder again and list valid resume positions.";
+    const loadResume = document.createElement("button");
+    loadResume.type = "button";
+    loadResume.className = "h3r-button h3r-approve";
+    loadResume.textContent = "Load checkpoint";
+    loadResume.title = "Restore the saved run's full Plan, preview the selected predecessor checkpoint, and set H3 Chain Loop Start to the chosen resume scene. Queue the workflow afterward to actually resume.";
+    const resumeStatus = document.createElement("div");
+    resumeStatus.className = "h3r-resume-status";
+    resumeStatus.textContent = "Refresh to discover saved scenes for this run.";
+    const revisionsPanel = document.createElement("div");
+    revisionsPanel.className = "h3r-revisions";
+    revisionsPanel.hidden = true;
+    const revisionsTitle = document.createElement("div");
+    revisionsTitle.className = "h3r-revisions-title";
+    revisionsTitle.textContent = "Checkpoint history";
+    const revisionsHint = document.createElement("div");
+    revisionsHint.className = "h3r-resume-status";
+    revisionsHint.textContent = "All saved scenes are listed. Only scenes before the selected resume position are restored.";
+    const revisionsRows = document.createElement("div");
+    revisionsRows.className = "h3r-revision-rows";
+    revisionsPanel.append(revisionsTitle, revisionsHint, revisionsRows);
+    resumeRow.append(resumeSelect, refreshResume, loadResume);
+    resume.append(resumeTitle, resumeRow, resumeStatus, revisionsPanel);
+
+    root.append(
+        head, videoPanel, prefix, promptNotice, promptLabel,
+        seedRow, candidateRow, actions, status, resume,
+    );
+
+    let current = null;
+    let countdownTimer = null;
+    let resumeChoices = [];
+    let checkpointRevisions = [];
+    let revisionChain = [];
+    let planClipCount = 0;
+    let resumeRefreshToken = 0;
+    let activeCandidateRevision = "";
+    let keptCandidateRevisions = new Set();
+    let previewLoadRevision = 0;
+    let acceptedPreviewPin = null;
+
+    function setReviewVideo(item, preservePosition = false) {
+        if (!item?.filename) return false;
+        const source = videoUrl(item);
+        if (video.dataset.source === source) return false;
+        const savedTime = preservePosition && Number.isFinite(video.currentTime)
+            ? Math.max(0, video.currentTime) : 0;
+        const resumePlayback = preservePosition && !video.paused;
+        const revision = ++previewLoadRevision;
+        video.dataset.source = source;
+        video.src = source;
+        video.load();
+        if (preservePosition) {
+            video.addEventListener("loadedmetadata", () => {
+                if (revision !== previewLoadRevision ||
+                        video.dataset.source !== source) return;
+                const limit = Number.isFinite(video.duration)
+                    ? Math.max(0, video.duration - .02) : savedTime;
+                try { video.currentTime = Math.min(savedTime, limit); }
+                catch (_error) {}
+                if (resumePlayback) void video.play().catch(() => {});
+            }, {once:true});
+        }
+        return true;
+    }
+
+    function showAcceptedPreview() {
+        if (!acceptedPreviewPin?.video) return;
+        activeCandidateRevision = acceptedPreviewPin.revision;
+        setReviewVideo(acceptedPreviewPin.video, true);
+        badge.textContent = `accepted scene ${acceptedPreviewPin.clipIndex} · ` +
+            `revision ${acceptedPreviewPin.revision.slice(0, 8)}`;
+    }
+
+    function pinAcceptedPreview(review, candidate) {
+        if (!candidate?.video || !candidate?.revision) return;
+        acceptedPreviewPin = {
+            runName: String(review?.run_name ?? ""),
+            clipIndex: Number(review?.clip_index),
+            token: String(review?.token ?? ""),
+            revision: String(candidate.revision),
+            video: candidate.video,
+        };
+        showAcceptedPreview();
+    }
+
+    function setActionsEnabled(enabled) {
+        for (const button of actionButtons) button.disabled = !enabled;
+        if (enabled && current?.candidate_batch_active) {
+            retryButton.disabled = true;
+            rerollButton.disabled = true;
+            stopButton.disabled = true;
+        }
+    }
+
+    function selectedCandidate() {
+        const candidates = Array.isArray(current?.candidates)
+            ? current.candidates : [];
+        return candidates.find(
+            (candidate) => candidate.revision === activeCandidateRevision,
+        ) ?? candidates.at(-1) ?? null;
+    }
+
+    function showCandidate(candidate, announce = false) {
+        if (!candidate) return;
+        const sameCandidate = activeCandidateRevision === candidate.revision;
+        activeCandidateRevision = candidate.revision;
+        if (candidate.video) {
+            setReviewVideo(candidate.video, sameCandidate);
+        }
+        seed.value = String(candidate.seed ?? seed.value);
+        candidateTitle.textContent = `Candidate ${candidate.number}/${current.candidate_count} · ` +
+            `seed ${candidate.seed} · ${candidate.revision.slice(0, 8)}`;
+        candidateKeep.checked = keptCandidateRevisions.has(candidate.revision);
+        const candidates = Array.isArray(current?.candidates)
+            ? current.candidates : [];
+        const selectedIndex = Math.max(0, candidates.indexOf(candidate));
+        candidatePrevious.disabled = selectedIndex <= 0;
+        candidateNext.disabled = selectedIndex >= candidates.length - 1;
+        badge.textContent = `clip ${current.clip_index}/${current.clip_count} · ` +
+            `candidate ${candidate.number}/${current.candidate_count} · ${current.shot_id}`;
+        renderCandidateDots();
+        renderCandidateProgress();
+        if (announce) {
+            status.className = `h3r-status${candidate.warning ? " h3r-warning" : ""}`;
+            status.textContent = candidate.warning ||
+                `Previewing candidate ${candidate.number}/${current.candidate_count}, seed ${candidate.seed}.`;
+        }
+    }
+
+    function renderCandidateDots() {
+        const candidates = Array.isArray(current?.candidates)
+            ? current.candidates : [];
+        candidateDots.replaceChildren();
+        for (const candidate of candidates) {
+            const dot = document.createElement("button");
+            dot.type = "button";
+            dot.className = "h3r-candidate-dot";
+            if (candidate.revision === activeCandidateRevision) {
+                dot.classList.add("h3r-selected");
+            }
+            if (keptCandidateRevisions.has(candidate.revision)) {
+                dot.classList.add("h3r-kept");
+            }
+            dot.title = `Preview candidate ${candidate.number}, seed ${candidate.seed}` +
+                (keptCandidateRevisions.has(candidate.revision) ? " (kept)" : "");
+            dot.setAttribute("aria-label", dot.title);
+            dot.addEventListener("click", () => showCandidate(candidate, true));
+            candidateDots.append(dot);
+        }
+    }
+
+    function renderCandidateProgress() {
+        const generated = Array.isArray(current?.candidates)
+            ? current.candidates.length : 0;
+        const target = Number(current?.candidate_count) || generated;
+        const remaining = Math.max(0, target - generated);
+        candidateProgress.textContent = `${generated}/${target} generated · ` +
+            `${keptCandidateRevisions.size} marked to keep` +
+            (remaining ? ` · ${remaining} remaining` : " · complete");
+    }
+
+    function renderCandidateCarousel() {
+        const candidates = Array.isArray(current?.candidates)
+            ? current.candidates : [];
+        const batch = Number(current?.candidate_count) > 1;
+        candidateRow.hidden = !batch;
+        const complete = Boolean(current?.candidate_generation_complete) ||
+            candidates.length >= Number(current?.candidate_count);
+        const running = Boolean(current?.candidate_batch_active) && !complete;
+        nextCandidateButton.hidden = !running && (
+            !batch || complete || !current?.review_each_candidate);
+        nextCandidateButton.textContent = running
+            ? "Pause candidate run" : "Generate next candidate";
+        nextCandidateButton.title = running
+            ? "Let the current in-flight take finish, then pause before another candidate starts."
+            : "Keep any marked takes, resume the workflow, and generate the next candidate for this scene.";
+        approveButton.textContent = batch
+            ? running ? "Use this take & stop batch"
+                : complete ? "Use this take & continue" : "Accept now & continue"
+            : "Approve & continue";
+        approveButton.title = running
+            ? "Accept this saved take now, cancel only the speculative in-flight " +
+                "H3 prompt, activate its checkpoint, and continue at the next scene."
+            : "Accept this saved scene and continue the loop with the next scene.";
+        if (!batch || !candidates.length) return null;
+        if (!candidates.some(
+            (candidate) => candidate.revision === activeCandidateRevision)) {
+            activeCandidateRevision = candidates.at(-1).revision;
+        }
+        const selected = selectedCandidate();
+        renderCandidateDots();
+        renderCandidateProgress();
+        return selected;
+    }
+
+    function moveCandidate(offset) {
+        const candidates = Array.isArray(current?.candidates)
+            ? current.candidates : [];
+        const index = candidates.findIndex(
+            (candidate) => candidate.revision === activeCandidateRevision);
+        const candidate = candidates[index + offset];
+        if (candidate) showCandidate(candidate, true);
+    }
+
+    candidatePrevious.addEventListener("click", () => moveCandidate(-1));
+    candidateNext.addEventListener("click", () => moveCandidate(1));
+    root.addEventListener("keydown", (event) => {
+        if (candidateRow.hidden || event.altKey || event.ctrlKey || event.metaKey) return;
+        if (["INPUT", "TEXTAREA", "SELECT", "BUTTON"].includes(
+            event.target?.tagName)) return;
+        if (event.key !== "ArrowLeft" && event.key !== "ArrowRight") return;
+        event.preventDefault();
+        moveCandidate(event.key === "ArrowLeft" ? -1 : 1);
+    });
+    candidateKeep.addEventListener("change", () => {
+        const candidate = selectedCandidate();
+        if (!candidate) return;
+        if (candidateKeep.checked) keptCandidateRevisions.add(candidate.revision);
+        else keptCandidateRevisions.delete(candidate.revision);
+        renderCandidateDots();
+        renderCandidateProgress();
+        if (current?.candidate_batch_active && current?.token) {
+            void api.fetchApi(
+                "/minimax_h3_context_loop/review-candidate-batch", {
+                    method: "POST",
+                    headers: {"Content-Type": "application/json"},
+                    body: JSON.stringify({
+                        token: current.token,
+                        action: "update",
+                        candidate_revisions: [...keptCandidateRevisions],
+                    }),
+                },
+            ).then(async (response) => {
+                if (response.ok) return;
+                const body = await response.json().catch(() => ({}));
+                throw new Error(body.error || `HTTP ${response.status}`);
+            }).catch((error) => {
+                status.className = "h3r-status h3r-warning";
+                status.textContent = `Could not retain the live keep marks: ${error.message}`;
+            });
+        }
+    });
+
+    function selectedRevisionChain() {
+        const selectedResumeScene = Number(resumeSelect.value);
+        if (!Number.isInteger(selectedResumeScene) || selectedResumeScene < 2) {
+            return [];
+        }
+        return revisionChain.map((group) => {
+            const select = revisionsRows.querySelector(
+                `select[data-scene="${group.scene}"]`,
+            );
+            const revision = group.revisions.find(
+                (item) => item.revision === select?.value,
+            );
+            return revision ?? group.revisions[0];
+        }).filter((revision) => revision.scene < selectedResumeScene);
+    }
+
+    function showRevisionPreview(revision) {
+        if (!revision?.video) return;
+        acceptedPreviewPin = null;
+        setReviewVideo(revision.video);
+        badge.textContent = `saved scene ${revision.scene} · revision ${revision.revision.slice(0, 8)}`;
+    }
+
+    async function deleteRevision(revision) {
+        if (!revision || revision.active) return;
+        try {
+            const context = planResumeContext(node);
+            const previewResponse = await api.fetchApi(
+                "/minimax_h3_context_loop/checkpoint-revisions/delete-preview", {
+                    method: "POST",
+                    headers: {"Content-Type": "application/json"},
+                    body: JSON.stringify({
+                        run_name: context.runName,
+                        scene: revision.scene,
+                        revision: revision.revision,
+                    }),
+                },
+            );
+            const preview = await previewResponse.json();
+            if (!previewResponse.ok) {
+                throw new Error(preview.error || `HTTP ${previewResponse.status}`);
+            }
+            if (!preview.allowed) {
+                throw new Error((preview.blockers ?? []).join(" ") ||
+                    "This checkpoint revision cannot be deleted safely.");
+            }
+            const confirmed = window.confirm(
+                `Permanently delete scene ${revision.scene} revision ` +
+                `${revision.revision.slice(0, 8)} and its ` +
+                `${preview.owned_file_count} owned files ` +
+                `(${formatBytes(preview.reclaimed_bytes)})? Run archives, ` +
+                "references, prompt history, and assembled exports are kept. " +
+                "This cannot be undone.",
+            );
+            if (!confirmed) return;
+            const response = await api.fetchApi(
+                "/minimax_h3_context_loop/checkpoint-revisions/delete", {
+                    method: "POST",
+                    headers: {"Content-Type": "application/json"},
+                    body: JSON.stringify({
+                        run_name: context.runName,
+                        scene: revision.scene,
+                        revision: revision.revision,
+                        snapshot: preview.snapshot,
+                    }),
+                },
+            );
+            const body = await response.json();
+            if (!response.ok) throw new Error(body.error || `HTTP ${response.status}`);
+            await refreshResumeOptions();
+            resumeStatus.textContent = `${body.message} Reclaimed ${formatBytes(body.reclaimed_bytes)}.`;
+        } catch (error) {
+            resumeStatus.textContent = error.message;
+        }
+    }
+
+    function renderRevisionChoices() {
+        revisionsRows.replaceChildren();
+        revisionChain = checkpointRevisionChain(
+            checkpointRevisions, planClipCount + 1,
+        );
+        const hasHistory = revisionChain.length > 0;
+        revisionsPanel.hidden = !hasHistory;
+        if (!hasHistory) {
+            loadResume.textContent = "Load checkpoint";
+            return;
+        }
+        for (const group of revisionChain) {
+            const row = document.createElement("div");
+            row.className = "h3r-revision-row";
+            const label = document.createElement("span");
+            label.className = "h3r-revision-label";
+            label.textContent = `Scene ${group.scene}`;
+            const select = document.createElement("select");
+            select.className = "h3r-revision-select";
+            select.dataset.scene = String(group.scene);
+            for (const revision of group.revisions) {
+                const option = document.createElement("option");
+                option.value = revision.revision;
+                option.textContent = checkpointRevisionLabel(revision);
+                select.append(option);
+            }
+            const remove = document.createElement("button");
+            remove.type = "button";
+            remove.className = "h3r-button h3r-delete";
+            remove.textContent = "Delete";
+            remove.title = "Permanently delete the selected inactive revision and only its owned files.";
+            const update = (preview = false) => {
+                const revision = group.revisions.find(
+                    (item) => item.revision === select.value,
+                );
+                remove.disabled = !revision || revision.active;
+                loadResume.textContent = selectedRevisionChain().some(
+                    (item) => !item.active,
+                ) ? "Restore & load" : "Load checkpoint";
+                if (preview) showRevisionPreview(revision);
+            };
+            select.addEventListener("change", () => update(true));
+            remove.addEventListener("click", () => {
+                const revision = group.revisions.find(
+                    (item) => item.revision === select.value,
+                );
+                void deleteRevision(revision);
+            });
+            row.append(label, select, remove);
+            revisionsRows.append(row);
+            update();
+        }
+    }
+
+    async function refreshResumeOptions() {
+        const refreshToken = ++resumeRefreshToken;
+        const previousResumeScene = Number(resumeSelect.value);
+        resumeSelect.replaceChildren();
+        resumeChoices = [];
+        checkpointRevisions = [];
+        revisionChain = [];
+        revisionsRows.replaceChildren();
+        revisionsPanel.hidden = true;
+        loadResume.disabled = true;
+        try {
+            const context = planResumeContext(node);
+            planClipCount = context.clipCount;
+            const query = new URLSearchParams({run_name: context.runName});
+            const response = await api.fetchApi(
+                `/minimax_h3_context_loop/checkpoints?${query.toString()}`,
+            );
+            const body = await response.json();
+            if (refreshToken !== resumeRefreshToken) return;
+            if (!response.ok) throw new Error(body.error || `HTTP ${response.status}`);
+            resumeChoices = checkpointResumeOptions(
+                body.checkpoints, context.clipCount);
+            checkpointRevisions = body.revisions ?? [];
+            for (const option of resumeChoices) {
+                const element = document.createElement("option");
+                element.value = String(option.resumeScene);
+                element.textContent = `Resume scene ${option.resumeScene} — checkpoint ${option.savedScene} · ${option.sceneId}`;
+                resumeSelect.append(element);
+            }
+            if (resumeChoices.some(
+                    (option) => option.resumeScene === previousResumeScene)) {
+                resumeSelect.value = String(previousResumeScene);
+            }
+            renderRevisionChoices();
+            loadResume.disabled = resumeChoices.length === 0;
+            const complete = (body.checkpoints ?? []).filter((item) => item.ready).length;
+            resumeStatus.textContent = resumeChoices.length
+                ? `${complete} saved checkpoint${complete === 1 ? "" : "s"} found. Select the scene to resume.`
+                : complete >= context.clipCount
+                    ? `All ${context.clipCount} scenes are saved; there is no later scene to resume.`
+                    : "No usable predecessor checkpoint was found for a later scene.";
+        } catch (error) {
+            if (refreshToken !== resumeRefreshToken) return;
+            resumeStatus.textContent = error.message;
+        }
+    }
+
+    refreshResume.addEventListener("click", refreshResumeOptions);
+    resumeSelect.addEventListener("change", renderRevisionChoices);
+    node._h3RefreshResume = refreshResumeOptions;
+    loadResume.addEventListener("click", async () => {
+        const resumeScene = Number(resumeSelect.value);
+        if (!Number.isInteger(resumeScene)) return;
+        try {
+            const context = planResumeContext(node);
+            const selections = selectedRevisionChain();
+            const changed = selections.some((item) => !item.active);
+            let restored = [];
+            if (changed) {
+                const changedScenes = selections.filter(
+                    (item) => !item.active,
+                ).map((item) => item.scene).join(", ");
+                const confirmed = window.confirm(
+                    `Restore the selected checkpoint revisions through scene ` +
+                    `${resumeScene - 1} (changed scenes: ${changedScenes})? ` +
+                    "The current revisions will remain available in revision history.",
+                );
+                if (!confirmed) return;
+            }
+            const runQuery = new URLSearchParams({
+                run_name: context.runName,
+                include_assets: "false",
+            });
+            const runResponse = await api.fetchApi(
+                `/minimax_h3_context_loop/run?${runQuery.toString()}`,
+            );
+            const runBody = await runResponse.json();
+            if (!runResponse.ok) throw new Error(
+                runBody.error || `HTTP ${runResponse.status}`,
+            );
+            let restoredPolicyInputs = runBody.policy_inputs;
+            if (selections.length) {
+                const response = await api.fetchApi(
+                    "/minimax_h3_context_loop/checkpoint-revisions/restore", {
+                        method: "POST",
+                        headers: {"Content-Type": "application/json"},
+                        body: JSON.stringify({
+                            run_name: context.runName,
+                            resume_scene: resumeScene,
+                            revisions: selections.map((item) => ({
+                                scene: item.scene,
+                                revision: item.revision,
+                            })),
+                        }),
+                    },
+                );
+                const body = await response.json();
+                if (!response.ok) throw new Error(
+                    body.error || `HTTP ${response.status}`,
+                );
+                restored = body.restored ?? [];
+                restoredPolicyInputs = body.policy_inputs
+                    ?? restoredPolicyInputs;
+            }
+            const savedPlan = restoreSavedPlanInputs(
+                node, runBody.plan_inputs, restoredPolicyInputs);
+            if (savedPlan.sceneCount < resumeScene) {
+                throw new Error(
+                    `The saved Plan has ${savedPlan.sceneCount} scenes and cannot resume scene ${resumeScene}.`,
+                );
+            }
+            if (restored.length &&
+                    !updatePlanFromCheckpointRevisions(node, restored)) {
+                throw new Error(
+                    "Checkpoint files were restored, but the connected Plan editor could not be updated.",
+                );
+            }
+            if (!prepareResume(node, resumeScene)) {
+                throw new Error("Could not find the connected H3 Chain Loop Start node.");
+            }
+            const choice = resumeChoices.find(
+                (item) => item.resumeScene === resumeScene);
+            const selectedPredecessor = selections.find(
+                (item) => item.scene === resumeScene - 1,
+            );
+            const preview = selectedPredecessor?.video
+                ?? choice?.partialVideo ?? choice?.video;
+            if (preview) {
+                acceptedPreviewPin = null;
+                setReviewVideo(preview);
+                badge.textContent = selectedPredecessor
+                    ? `saved scene ${selectedPredecessor.scene} · revision ${selectedPredecessor.revision.slice(0, 8)}`
+                    : choice?.partialVideo
+                    ? `partial through checkpoint ${choice.savedScene}`
+                    : `saved scene ${choice.savedScene} · ${choice.sceneId}`;
+            }
+            const unavailable = savedPlan.unavailable.length
+                ? ` Current Plan has no ${savedPlan.unavailable.join(", ")} control. ` : " ";
+            const unavailablePolicies = savedPlan.policies.unavailable.length
+                ? ` Could not restore ${savedPlan.policies.unavailable.join(", ")}. ` : "";
+            const finalStatus = `Restored the saved ${savedPlan.sceneCount}-scene Plan and ${restored.length} checkpoint scene${restored.length === 1 ? "" : "s"}.` +
+                unavailable + unavailablePolicies +
+                `Checkpoint ${resumeScene - 1} loaded for preview. Loop Start is armed for scene ${resumeScene}; queue the workflow to validate and resume.`;
+            if (changed) await refreshResumeOptions();
+            resumeStatus.textContent = finalStatus;
+        } catch (error) {
+            resumeStatus.textContent = error.message;
+        }
+    });
+
+    function stopCountdown() {
+        if (countdownTimer != null) clearInterval(countdownTimer);
+        countdownTimer = null;
+    }
+
+    function renderWaitingStatus() {
+        if (!current) return;
+        const generated = Array.isArray(current.candidates)
+            ? current.candidates.length : 0;
+        const target = Number(current.candidate_count) || generated;
+        const complete = Boolean(current.candidate_generation_complete) ||
+            generated >= target;
+        const batchCommand = current.candidate_batch_command_pending;
+        const message = batchCommand
+            ? batchCommand === "accept"
+                ? "Selected take is being activated; Review Gate is stopping the speculative take."
+                : "Pause queued. The current in-flight candidate will finish, then Review Gate will wait here."
+            : current.warning || (target > 1
+            ? complete
+                ? `All ${target} candidates are saved. Choose the active continuation and mark every take you want to retain.`
+                : current.review_each_candidate
+                    ? `Candidate ${generated}/${target} is ready in per-candidate review mode. Keep it if wanted, accept a take now, or generate the next candidate.`
+                    : `Candidate ${generated}/${target} is ready in the live carousel. Candidate ${generated + 1} is generating automatically; choose a take to stop early or pause the run.`
+            : "Review the synchronized picture and sound, then choose an action.");
+        const countdown = reviewCountdown(current.local_deadline);
+        status.className = `h3r-status${current.warning ? " h3r-warning" : ""}`;
+        status.textContent = countdown ?
+            `${message}\nAuto-continue in ${countdown.text}.` : message;
+        if (countdown?.seconds === 0) {
+            root.classList.add("h3r-busy");
+            setActionsEnabled(false);
+            status.textContent = `${message}\nTimeout reached — continuing…`;
+            stopCountdown();
+        }
+    }
+
+    function startCountdown() {
+        stopCountdown();
+        renderWaitingStatus();
+        if (reviewCountdown(current?.local_deadline)?.seconds > 0) {
+            countdownTimer = setInterval(renderWaitingStatus, 250);
+        }
+    }
+
+    async function submit(action) {
+        if (!current?.token) {
+            status.className = "h3r-status h3r-warning";
+            status.textContent = "No live review token is attached. Checking the server…";
+            await fetchPending();
+            if (!current?.token) {
+                status.textContent = "No pending review is available for this project yet.";
+                return;
+            }
+        }
+        try {
+            // Freeze one coherent review edit before yielding to the server.
+            // Websocket recovery can replace `current`, and a companion UI can
+            // refresh the live controls, while this request is in flight.
+            const submittedReview = current;
+            const submittedToken = submittedReview.token;
+            const submittedIndex = submittedReview.clip_index;
+            const submittedCandidate = selectedCandidate();
+            const liveCandidateBatch = Boolean(
+                submittedReview.candidate_batch_active) &&
+                !submittedReview.candidate_generation_complete;
+            const candidateBatchAction = liveCandidateBatch
+                ? action === "approve" ? "accept"
+                    : action === "next_candidate" ? "pause" : ""
+                : "";
+            if (liveCandidateBatch && !candidateBatchAction) return;
+            const submittedPrompt = reviewPromptEditorEnabled() && promptEditedInGate
+                ? prompt.value
+                : (planScenePrompt(node, submittedReview)
+                    ?? submittedReview.scene_prompt
+                    ?? prompt.value);
+            const normalizedSeed = action === "retry" ? reviewSeed(seed.value) : seed.value;
+            const normalizedDuration = action === "retry" || action === "reroll"
+                ? reviewDuration(duration.value) : null;
+            stopCountdown();
+            root.classList.add("h3r-busy");
+            setActionsEnabled(false);
+            status.className = "h3r-status";
+            status.textContent = candidateBatchAction === "accept"
+                ? "Activating this checkpoint and cancelling the speculative take…"
+                : candidateBatchAction === "pause"
+                    ? "Queuing a pause after the in-flight candidate…"
+                : action === "approve" ? "Sending approval…" :
+                action === "next_candidate" ? "Resuming to generate the next candidate…" :
+                action === "stop" ? "Sending stop decision…" : "Sending retry decision…";
+            const response = await api.fetchApi(candidateBatchAction
+                ? "/minimax_h3_context_loop/review-candidate-batch"
+                : "/minimax_h3_context_loop/review", {
+                method: "POST",
+                headers: {"Content-Type": "application/json"},
+                body: JSON.stringify({
+                    token: submittedToken,
+                    action: candidateBatchAction || action,
+                    scene_prompt: submittedPrompt,
+                    seed: normalizedSeed,
+                    length: normalizedDuration?.length,
+                    candidate_revision: (candidateBatchAction === "accept" ||
+                            action === "approve" || action === "stop") &&
+                            Number(submittedReview.candidate_count) > 1
+                        ? submittedCandidate?.revision ?? "" : "",
+                    candidate_revisions: [...keptCandidateRevisions],
+                }),
+            });
+            const body = await response.json();
+            if (!response.ok) throw new Error(body.error || `HTTP ${response.status}`);
+            if (candidateBatchAction) {
+                if (current?.token === submittedToken) {
+                    current.candidate_batch_command_pending = candidateBatchAction;
+                }
+                if (candidateBatchAction === "accept") {
+                    pinAcceptedPreview(submittedReview, submittedCandidate);
+                    const result = await activateAcceptedCandidate(
+                        node, submittedReview, body);
+                    showAcceptedPreview();
+                    if (result.immediate) {
+                        status.textContent =
+                            `Candidate ${body.candidate_number}/${body.candidate_count} ` +
+                            `is active. The unwanted take was cancelled; scene ` +
+                            `${result.nextIndex} was queued immediately.` +
+                            (result.saved ? " The Plan seed was updated." : "") +
+                            (result.cleanupWarning || "");
+                    } else {
+                        status.textContent =
+                            `Candidate ${body.candidate_number}/${body.candidate_count} ` +
+                            `selected. ${result.message}`;
+                    }
+                } else {
+                    status.textContent = "Pause queued. The current in-flight take " +
+                        "will finish, then the carousel will wait for you.";
+                }
+            } else if (action === "next_candidate") {
+                status.textContent = `Candidate ${submittedReview.candidates.length}/` +
+                    `${submittedReview.candidate_count} reviewed — generating the next take ` +
+                    `with seed ${body.seed}. ${body.kept_candidate_count} marked take` +
+                    `${body.kept_candidate_count === 1 ? " is" : "s are"} retained.`;
+            } else if (action === "approve") {
+                const selected = Number(body.candidate_count) > 1;
+                const saved = selected && updatePlan(
+                    node, submittedIndex, body.scene_prompt, body.seed, body.length);
+                status.textContent = submittedReview.unload_models_while_waiting
+                    ? "Approval received — workflow is resuming and reloading the model stack."
+                    : "Approval received — workflow resumed.";
+                if (selected) {
+                    status.textContent += ` Candidate ${body.candidate_number}/${body.candidate_count} is now active.` +
+                        ` ${body.kept_candidate_count} take${body.kept_candidate_count === 1 ? "" : "s"} kept.` +
+                        (saved ? " The Plan seed was updated." : "");
+                }
+            } else if (action === "retry" || action === "reroll") {
+                const acceptedPrompt = typeof body.scene_prompt === "string"
+                    ? body.scene_prompt : submittedPrompt.trim();
+                const acceptedDuration = reviewDurationText(body.length);
+                const saved = updatePlan(
+                    node, submittedIndex, acceptedPrompt, body.seed, body.length);
+                if (current?.token === submittedToken) {
+                    prompt.value = acceptedPrompt;
+                    promptEditedInGate = false;
+                    seed.value = body.seed;
+                    duration.value = acceptedDuration;
+                }
+                status.textContent = `Retrying scene with seed ${body.seed} at ${body.length} frames (${acceptedDuration}s).` +
+                    (saved ? " The Plan editor was updated." : "");
+            } else if (action === "stop") {
+                const selected = Number(body.candidate_count) > 1;
+                const saved = selected && updatePlan(
+                    node, submittedIndex, body.scene_prompt, body.seed, body.length);
+                const prepared = submittedReview.clip_index < submittedReview.clip_count &&
+                    prepareResume(node, submittedReview.clip_index + 1);
+                status.textContent = (submittedReview.assemble_partial_on_stop
+                    ? "Stop accepted — assembling the partial video…"
+                    : "Stopped at the accepted checkpoint.") +
+                    (selected ? ` Candidate ${body.candidate_number}/${body.candidate_count} is now active.` : "") +
+                    (selected ? ` ${body.kept_candidate_count} take${body.kept_candidate_count === 1 ? "" : "s"} kept.` : "") +
+                    (saved ? " The Plan seed was updated." : "") +
+                    (prepared ? ` Loop Start is ready at clip ${submittedReview.clip_index + 1}.` : "");
+                setTimeout(refreshResumeOptions, 0);
+            }
+        } catch (error) {
+            root.classList.remove("h3r-busy");
+            setActionsEnabled(Boolean(current?.token));
+            status.className = "h3r-status h3r-warning";
+            status.textContent = error.message;
+            if (reviewCountdown(current?.local_deadline)?.seconds > 0) {
+                countdownTimer = setInterval(renderWaitingStatus, 250);
+            }
+        }
+    }
+
+    node._h3ReviewHandler = (data) => {
+        const acceptedDisposition = acceptedPreviewDisposition(
+            acceptedPreviewPin, data);
+        if (acceptedDisposition === "ignore") return;
+        if (acceptedDisposition === "release") acceptedPreviewPin = null;
+        const sameToken = Boolean(current?.token) && current.token === data?.token;
+        const carriesCandidateBatch = !sameToken &&
+            String(current?.run_name ?? "") === String(data?.run_name ?? "") &&
+            Number(current?.clip_index) === Number(data?.clip_index) &&
+            Number(current?.candidate_count) > 1;
+        const carriedActiveCandidateRevision = carriesCandidateBatch
+            ? activeCandidateRevision : "";
+        const carriedKeepRevisions = carriesCandidateBatch
+            ? [...keptCandidateRevisions] : [];
+        const previousRevision = Number(current?.preview_revision ?? 0);
+        const incomingRevision = Number(data?.preview_revision ?? 0);
+        if (sameToken && incomingRevision <= previousRevision) return;
+        const localDeadline = sameToken ? current.local_deadline :
+            reviewLocalDeadline(data?.deadline, data?.server_now);
+        current = sameToken ? {
+            ...current,
+            ...data,
+            local_deadline: current.local_deadline,
+        } : {
+            ...data,
+            local_deadline: localDeadline,
+        };
+        if (!sameToken) {
+            root.classList.remove("h3r-busy");
+            setActionsEnabled(true);
+            activeCandidateRevision = (data.candidates ?? []).some(
+                (candidate) => candidate.revision ===
+                    carriedActiveCandidateRevision,
+            ) ? carriedActiveCandidateRevision : "";
+            keptCandidateRevisions = new Set(
+                [
+                    ...(Array.isArray(data.kept_candidate_revisions)
+                        ? data.kept_candidate_revisions : []),
+                    ...carriedKeepRevisions,
+                ].filter((revision) => (data.candidates ?? []).some(
+                    (candidate) => candidate.revision === revision)),
+            );
+            // The scene is persisted before Review Gate receives its token.
+            // Refresh here so the current (including final) checkpoint appears
+            // in history without requiring the user to press Refresh.
+            setTimeout(refreshResumeOptions, 0);
+        }
+        if (!sameToken) {
+            prompt.value = data.scene_prompt ?? "";
+            promptEditedInGate = false;
+            seed.value = data.seed ?? "";
+            duration.value = reviewDurationText(data.raw_frames);
+            prefix.textContent = data.prompt_prefix ?
+                `Shared prompt (unchanged)\n${data.prompt_prefix}` : "";
+            prefix.hidden = !data.prompt_prefix;
+            startCountdown();
+            if (data.play_notification_sound && !notifiedTokens.has(data.token)) {
+                notifiedTokens.add(data.token);
+                playReviewChime().catch((error) => {
+                    console.warn("[H3 Chain Review] Browser blocked notification sound:", error);
+                });
+            }
+        } else if (!root.classList.contains("h3r-busy")) {
+            renderWaitingStatus();
+        }
+        const candidate = renderCandidateCarousel();
+        if (candidate) {
+            showCandidate(candidate);
+        } else {
+            badge.textContent = `clip ${data.clip_index}/${data.clip_count} · ${data.shot_id}`;
+            setReviewVideo(data.video, sameToken);
+        }
+        if (acceptedDisposition === "hold") showAcceptedPreview();
+        const planNode = upstreamPlanNode(node);
+        if (planNode) {
+            publishPlanCompanionScene(node, planNode, Number(data.clip_index) - 1);
+        }
+    };
+
+    node._h3PromptCompanionSetScenePrompt = (planNode, index, text) => {
+        if (root.classList.contains("h3r-busy")
+                || planNode !== upstreamPlanNode(node)
+                || Number(index) !== Number(current?.clip_index) - 1) {
+            return false;
+        }
+        prompt.value = String(text ?? "").replace(/\r\n?/g, "\n");
+        promptEditedInGate = false;
+        return true;
+    };
+
+    node._h3ReviewResolvedHandler = (data) => {
+        if (!current || data?.token !== current.token) return;
+        stopCountdown();
+        root.classList.add("h3r-busy");
+        setActionsEnabled(false);
+        status.className = "h3r-status";
+        status.textContent = data.status || "Review resolved; continuing…";
+        if (data.action === "candidate_batch_approve") {
+            const saved = updatePlan(
+                node, Number(data.clip_index), data.scene_prompt,
+                data.seed, data.raw_frames);
+            if (saved) status.textContent += " The Plan seed was updated.";
+        }
+        const completedVideo = data.final_video ?? data.partial_video;
+        if (completedVideo) {
+            setReviewVideo(completedVideo);
+            badge.textContent = data.final_video
+                ? "final assembled video"
+                : "partial joined video";
+        }
+        if (data.action === "approve" || data.action === "stop" ||
+                data.action === "candidate_batch_approve") {
+            setTimeout(refreshResumeOptions, 0);
+        }
+    };
+
+    const widget = node.addDOMWidget("h3_chain_review", "h3-chain-review", root, {
+        serialize: false,
+        hideOnZoom: false,
+        getMinHeight: () => 500,
+    });
+    widget.serialize = false;
+    mountedReviewNodes.add(node);
+    updatePendingPolling();
+    const removed = node.onRemoved;
+    node.onRemoved = function () {
+        stopCountdown();
+        promptResizeObserver?.disconnect();
+        delete this._h3PromptCompanionSetScenePrompt;
+        mountedReviewNodes.delete(this);
+        updatePendingPolling();
+        return removed?.apply(this, arguments);
+    };
+    node.setSize?.([Math.max(node.size?.[0] ?? 540, 540), Math.max(node.size?.[1] ?? 650, 650)]);
+    const queuedReview = node._h3QueuedReview;
+    delete node._h3QueuedReview;
+    if (queuedReview) node._h3ReviewHandler(queuedReview);
+    setTimeout(fetchPending, 0);
+    setTimeout(refreshResumeOptions, 0);
+}
+
+api.addEventListener("minimax_h3_context_loop_review", (event) => routeReview(event.detail));
+api.addEventListener("minimax_h3_context_loop_review_resolved", (event) =>
+    routeReviewResolved(event.detail));
+api.addEventListener("executed", (event) =>
+    trackActiveSceneExecution(event.detail));
+api.addEventListener("execution_interrupted", (event) =>
+    finishTrackedReviewExecution("interrupted", event.detail));
+api.addEventListener("execution_success", (event) =>
+    finishTrackedReviewExecution("success", event.detail));
+api.addEventListener("execution_error", (event) =>
+    finishTrackedReviewExecution("error", event.detail));
+// A status event is sent when ComfyUI's websocket connects or reconnects.
+api.addEventListener("status", fetchPending);
+window.addEventListener("focus", fetchPending);
+document.addEventListener("visibilitychange", () => {
+    if (document.visibilityState !== "hidden") fetchPending();
+});
+
+app.registerExtension({
+    name: "minimax_h3_context_loop.chain_review",
+    init() {
+        app.ui?.settings?.addSetting?.({
+            id: PROMPT_EDITOR_SETTING,
+            category: ["MiniMax H3 Context Loop", "Interface", "Review Gate"],
+            name: "Enable prompt editing inside Review Gate",
+            tooltip: "Disabled by default in 0.5. Keep prompt authoring in Scene Prompt Editor or Rich Scene Prompt Editor. Enable this only to restore the legacy Review Gate textarea.",
+            type: "boolean",
+            defaultValue: false,
+            onChange() {
+                for (const node of mountedReviewNodes) {
+                    node._h3ReviewRefreshPromptSetting?.();
+                }
+            },
+        });
+    },
+    async beforeRegisterNodeDef(nodeType, nodeData) {
+        if (nodeData.name !== NODE_NAME) return;
+        const created = nodeType.prototype.onNodeCreated;
+        nodeType.prototype.onNodeCreated = function () {
+            const result = created?.apply(this, arguments);
+            setTimeout(() => mount(this), 0);
+            return result;
+        };
+        const configured = nodeType.prototype.onConfigure;
+        nodeType.prototype.onConfigure = function () {
+            const result = configured?.apply(this, arguments);
+            setTimeout(() => this._h3ReviewApplyLayout?.(), 0);
+            return result;
+        };
+        const graphConfigured = nodeType.prototype.onGraphConfigured;
+        nodeType.prototype.onGraphConfigured = function () {
+            const result = graphConfigured?.apply(this, arguments);
+            setTimeout(() => this._h3ReviewApplyLayout?.(), 0);
+            return result;
+        };
+    },
+    async nodeCreated(node) {
+        // Official per-instance hook. Keep the prototype hook above for older
+        // frontends; mount() is idempotent, so supporting both closes the
+        // timing gap without creating two widgets.
+        if (nodeType(node) === NODE_NAME) mount(node);
+    },
+    async afterConfigureGraph() {
+        await fetchPending();
+        for (const node of allNodes(app.graph)) {
+            if (nodeType(node) === NODE_NAME) node._h3RefreshResume?.();
+            if (nodeType(node) === NODE_NAME) node._h3ReviewApplyLayout?.();
+        }
+    },
+});
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_rich_scene_prompt_editor.js b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_rich_scene_prompt_editor.js
new file mode 100644
index 0000000000000000000000000000000000000000..713a636a903be33d53a1b44eb92230961301ecab
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_rich_scene_prompt_editor.js
@@ -0,0 +1,2465 @@
+import {app} from "/scripts/app.js";
+import {api} from "/scripts/api.js";
+import {
+    parsePlanJson,
+    planToJson,
+    promptTextToLines,
+    promptValueToText,
+    sharedPrompt,
+} from "./h3_chain_plan_core.mjs?v=0.6.5";
+import {
+    buildPromptAssistantContext,
+    makePromptAssistRequest,
+} from "./h3_prompt_assistant_core.mjs?v=0.6.5";
+import {PromptAssistantClient} from "./h3_prompt_assistant_client.mjs?v=0.6.2";
+import {
+    directOptimizerConfigurationError,
+    makeDirectPromptOptimizeRequest,
+} from "./h3_prompt_optimizer_core.mjs?v=0.6.2";
+import {
+    openPromptOptimizerSettings,
+    promptOptimizerBackend,
+    promptOptimizerDirectConfig,
+    promptOptimizerMcpProvider,
+} from "./h3_prompt_optimizer_settings.js";
+import {
+    promptRevisionHelp,
+    promptRevisionLabel,
+    promptRevisionNavigation,
+    promptRevisionTree,
+} from "./h3_prompt_history_core.mjs?v=0.6.2";
+import {
+    availableReferenceRecords,
+    convertTaggedPictureReference,
+    referenceReplacementToken,
+    replacePromptReferenceOccurrence,
+    taggedPictureReferenceMode,
+    taggedPictureReferenceToken,
+} from "./h3_reference_preview_core.mjs?v=0.6.2";
+import {
+    PromptUndoHistory,
+    RICH_PROMPT_GUIDES,
+    normalizeRichGuide,
+    optimizerSource,
+    promptUndoDirection,
+    richGenerationMode,
+    richGuideInstruction,
+    tokenizeRichPrompt,
+} from "./h3_rich_prompt_editor_core.mjs?v=0.6.5";
+import {createPromptCompletionController} from "./h3_prompt_completion_core.mjs?v=0.6.5";
+import {bindPromptMarkerInteractions} from "./h3_prompt_marker_ui.mjs?v=0.6.5";
+import {isWorkflowSaveShortcut, promptEditorRichText} from "./h3_prompt_editor_settings_core.mjs?v=0.6.5";
+import {promptEditorPreferences} from "./h3_prompt_editor_settings.js";
+import {createH3PromptSchemaController} from "./h3_prompt_schema_ui.mjs?v=0.6.5";
+import * as promptCompanionSync from "./h3_prompt_companion_sync.mjs?v=0.6.2";
+import {
+    PROJECT_ASSET_CATALOG_CHANGED_EVENT,
+} from "./h3_project_asset_sync_core.mjs?v=0.6.2";
+
+const {
+    publishCompanionScene,
+    rebaseScenePrompt,
+} = promptCompanionSync;
+const activeSceneIndexAfterRefresh =
+    typeof promptCompanionSync.activeSceneIndexAfterRefresh === "function"
+        ? promptCompanionSync.activeSceneIndexAfterRefresh
+        : (_previousPlan, nextPlan, sceneIndex) => Math.min(
+            Math.max(0, Math.trunc(Number(sceneIndex) || 0)),
+            Math.max(0, (nextPlan?.shots?.length ?? 1) - 1),
+        );
+const planHasNonPromptChanges =
+    typeof promptCompanionSync.planHasNonPromptChanges === "function"
+        ? promptCompanionSync.planHasNonPromptChanges
+        : () => true;
+function publishCompanionPrompt(...args) {
+    return promptCompanionSync.publishCompanionPrompt?.(...args) ?? 0;
+}
+
+// The rich mention presentation and compact optimizer interaction are inspired
+// by nkxx188/ComfyUI-MiniMaxH3-Easy (MIT). Graph discovery, scene scheduling,
+// revision storage, and Codex/Hermes bridge integration are implemented here.
+
+const NODE_NAME = "MiniMaxH3ChainRichScenePromptEditor";
+const PLAN_NAME = "MiniMaxH3ChainPlan";
+const PLAN_NAMES = new Set([PLAN_NAME, "MiniMaxH3ChainPlanModern"]);
+const ACTIVE_PROPERTY = "h3_rich_prompt_active_scene";
+const FONT_PROPERTY = "h3_rich_prompt_font_size";
+const GUIDE_PROPERTY = "h3_rich_prompt_guide";
+const PRESENTATION_PROPERTY = "h3_rich_prompt_rich_text";
+const DEFAULT_FONT = 17;
+const MIN_FONT = 12;
+const MAX_FONT = 32;
+const PROMPT_SYNC_DELAY_MS = 140;
+const PROMPT_ANALYSIS_DELAY_MS = 90;
+
+const ICONS = Object.freeze({
+    picture: '<svg viewBox="0 0 24 24" aria-hidden="true"><rect x="3" y="4" width="18" height="16" rx="2"/><circle cx="8.5" cy="9" r="1.5"/><path d="m5 17 4.5-4.5 3.2 3.2 2.3-2.3 4 3.6"/></svg>',
+    video: '<svg viewBox="0 0 24 24" aria-hidden="true"><rect x="3" y="5" width="13" height="14" rx="2"/><path d="m16 10 5-3v10l-5-3z"/></svg>',
+    audio: '<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M4 13v-2M8 17V7M12 20V4M16 16V8M20 13v-2"/></svg>',
+    subject: '<svg viewBox="0 0 24 24" aria-hidden="true"><circle cx="12" cy="8" r="4"/><path d="M5 21c.8-4.2 3.1-6.3 7-6.3s6.2 2.1 7 6.3"/></svg>',
+    dialogue: '<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M5 5h14v11H9l-4 3z"/><path d="M8 9h8M8 12h6"/></svg>',
+    reference: '<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M10 13a5 5 0 0 0 7.1.1l2-2a5 5 0 0 0-7.1-7.1l-1.1 1.1"/><path d="M14 11a5 5 0 0 0-7.1-.1l-2 2A5 5 0 0 0 12 20l1.1-1.1"/></svg>',
+    section: '<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M5 5h14M5 12h14M5 19h14"/></svg>',
+    flow: '<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M4 7h11M12 4l3 3-3 3M20 17H9M12 14l-3 3 3 3"/></svg>',
+    speaker: '<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M4 10v4h4l5 4V6L8 10z"/><path d="M16 9c1.5 1.5 1.5 4.5 0 6"/></svg>',
+    sparkle: '<svg viewBox="0 0 24 24" aria-hidden="true"><path d="m12 2 1.4 5.1L18 9l-4.6 1.9L12 16l-1.4-5.1L6 9l4.6-1.9zM19 15l.7 2.3L22 18l-2.3.7L19 21l-.7-2.3L16 18l2.3-.7z"/></svg>',
+    stop: '<svg viewBox="0 0 24 24" aria-hidden="true"><rect x="6" y="6" width="12" height="12" rx="1"/></svg>',
+});
+
+function injectStyles() {
+    if (document.getElementById("h3-rich-prompt-editor-style")) return;
+    const style = document.createElement("style");
+    style.id = "h3-rich-prompt-editor-style";
+    style.textContent = `
+      .h3rp-root { --h3rp-bg:color-mix(in srgb,var(--comfy-menu-bg,#202124) 94%,#101727);
+        --h3rp-panel:color-mix(in srgb,var(--comfy-input-bg,#111827) 86%,#26334d);
+        --h3rp-border:color-mix(in srgb,var(--border-color,#555) 70%,#7591bd);
+        --h3rp-text:var(--input-text,#edf2fa); --h3rp-muted:color-mix(in srgb,var(--h3rp-text) 57%,transparent);
+        /* Theme-aware semantic colors remain pastel on dark ComfyUI themes
+           and gain enough foreground contrast on light themes. */
+        --h3rp-accent:color-mix(in srgb,var(--h3rp-text) 38%,#4f83ff);
+        --h3rp-token-picture:color-mix(in srgb,var(--h3rp-text) 42%,#139be8);
+        --h3rp-token-video:color-mix(in srgb,var(--h3rp-text) 42%,#9355d6);
+        --h3rp-token-audio:color-mix(in srgb,var(--h3rp-text) 42%,#d47700);
+        --h3rp-token-subject:color-mix(in srgb,var(--h3rp-text) 42%,#26934a);
+        --h3rp-token-dialogue:color-mix(in srgb,var(--h3rp-text) 42%,#cf3976);
+        --h3rp-token-section:color-mix(in srgb,var(--h3rp-text) 38%,#5f87ff);
+        --h3rp-token-flow:color-mix(in srgb,var(--h3rp-text) 42%,#00a99d);
+        --h3rp-token-speaker:color-mix(in srgb,var(--h3rp-text) 42%,#d268b7);
+        --h3rp-token-danger:color-mix(in srgb,var(--h3rp-text) 42%,#d44747);
+        --h3rp-font-size:17px; box-sizing:border-box; width:100%; height:100%;
+        min-height:560px; display:flex; flex-direction:column; gap:8px; overflow:hidden; padding:10px;
+        border:1px solid var(--h3rp-border); border-radius:9px; background:var(--h3rp-bg);
+        color:var(--h3rp-text); font:12px/1.35 system-ui,sans-serif; }
+      .h3rp-root *, .h3rp-root *::before, .h3rp-root *::after { box-sizing:border-box; }
+      .h3rp-row,.h3rp-head,.h3rp-nav,.h3rp-toolbar,.h3rp-footer,.h3rp-history { display:flex; align-items:center; gap:6px; }
+      .h3rp-head { justify-content:space-between; }
+      .h3rp-title { color:var(--h3rp-accent); font-size:15px; font-weight:760; }
+      .h3rp-context,.h3rp-muted { color:var(--h3rp-muted); }
+      .h3rp-context { overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+      .h3rp-root button,.h3rp-root select { min-height:30px; color:var(--h3rp-text); font:inherit;
+        border:1px solid var(--h3rp-border); border-radius:6px; background:var(--comfy-input-bg,#171a21); }
+      .h3rp-root button { display:inline-flex; align-items:center; justify-content:center; gap:5px; padding:5px 8px;
+        cursor:pointer; white-space:nowrap; }
+      .h3rp-root button:hover,.h3rp-root button:focus-visible { border-color:var(--h3rp-accent); outline:none; }
+      .h3rp-root button:disabled,.h3rp-root select:disabled { opacity:.42; cursor:not-allowed; }
+      .h3rp-root select { min-width:0; padding:4px 7px; }
+      .h3rp-nav select { flex:1; }
+      .h3rp-icon { width:16px; height:16px; display:inline-flex; flex:0 0 16px; color:currentColor; }
+      .h3rp-icon svg { width:100%; height:100%; fill:none; stroke:currentColor; stroke-width:1.7;
+        stroke-linecap:round; stroke-linejoin:round; }
+      .h3rp-editor-shell { position:relative; flex:1 1 auto; min-height:300px; overflow:hidden;
+        border:1px solid var(--h3rp-border); border-radius:8px; background:var(--comfy-input-bg,#11141a); }
+      .h3rp-editor-shell:focus-within { border-color:var(--h3rp-accent);
+        box-shadow:0 0 0 1px color-mix(in srgb,var(--h3rp-accent) 40%,transparent); }
+      .h3rp-editor { width:100%; height:100%; min-height:300px; overflow:auto; padding:13px 14px;
+        outline:none; white-space:pre-wrap; overflow-wrap:anywhere; caret-color:var(--h3rp-text);
+        font:var(--h3rp-font-size)/1.58 ui-monospace,SFMono-Regular,Consolas,monospace; }
+      .h3rp-editor:empty::before { content:attr(data-placeholder); color:var(--h3rp-muted); pointer-events:none; }
+      .h3rp-editor[contenteditable="false"] { opacity:.68; cursor:wait; }
+      .h3rp-token { display:inline-flex; align-items:center; gap:3px; max-width:320px; margin:0 1px;
+        padding:1px 4px 1px 2px; border:1px solid currentColor; border-radius:5px; vertical-align:1px;
+        line-height:1.25; cursor:pointer; user-select:all;
+        background:color-mix(in srgb,currentColor 14%,transparent); }
+      .h3rp-token-picture { color:var(--h3rp-token-picture); }
+      .h3rp-token-video { color:var(--h3rp-token-video); }
+      .h3rp-token-audio { color:var(--h3rp-token-audio); }
+      .h3rp-token-subject { color:var(--h3rp-token-subject); }
+      .h3rp-token-dialogue { color:var(--h3rp-token-dialogue); }
+      .h3rp-token-section { display:inline; margin:0; padding:0; border:0; border-radius:0;
+        color:var(--h3rp-token-section); background:none; font-weight:650; cursor:text; user-select:text; }
+      .h3rp-token-flow { color:var(--h3rp-token-flow); }
+      .h3rp-token-speaker { color:var(--h3rp-token-speaker); }
+      .h3rp-token-unknown,.h3rp-token-inactive { color:var(--h3rp-token-danger); border-style:dashed; }
+      .h3rp-presentation-active { border-color:var(--h3rp-accent) !important;
+        color:var(--h3rp-accent) !important; }
+      .h3rp-token-thumb { width:18px; height:18px; flex:0 0 18px; object-fit:cover; border-radius:3px;
+        background:rgba(255,255,255,.09); }
+      .h3rp-token-label { overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+      .h3rp-toolbar { flex-wrap:wrap; }
+      .h3rp-toolbar .h3rp-guide { min-width:150px; }
+      .h3rp-toolbar-spacer { flex:1; }
+      .h3rp-status { min-width:0; color:var(--h3rp-muted); overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+      .h3rp-status-error { color:#ffaaaa; }
+      .h3rp-status-success { color:#9bdab0; }
+      .h3rp-spinner .h3rp-icon { animation:h3rp-spin .9s linear infinite; }
+      @keyframes h3rp-spin { to { transform:rotate(360deg); } }
+      .h3rp-ref-tray { display:none; max-height:260px; overflow:auto; padding:8px; gap:6px;
+        border:1px solid var(--h3rp-border); border-radius:7px; background:var(--h3rp-panel); }
+      .h3rp-ref-tray.h3rp-open { display:grid; grid-template-columns:repeat(auto-fill,minmax(205px,1fr)); }
+      .h3rp-ref-help { grid-column:1/-1; color:var(--h3rp-muted); }
+      .h3rp-ref-card { justify-content:flex-start !important; min-width:0; text-align:left; }
+      .h3rp-ref-card-shell { display:grid; grid-template-columns:minmax(0,1fr) auto; gap:4px;
+        align-items:stretch; min-width:0; }
+      .h3rp-ref-mode { display:flex; flex-direction:column; gap:2px; }
+      .h3rp-ref-mode button { min-width:38px !important; min-height:0 !important; padding:2px 5px !important;
+        font-size:10px !important; }
+      .h3rp-ref-mode button.h3rp-selected { border-color:var(--h3rp-accent) !important;
+        color:var(--h3rp-accent) !important; }
+      .h3rp-ref-card.h3rp-inactive { opacity:.46; }
+      .h3rp-ref-card-copy { min-width:0; overflow:hidden; }
+      .h3rp-ref-card-title,.h3rp-ref-card-detail { overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+      .h3rp-ref-card-title { font-weight:700; }
+      .h3rp-ref-card-detail { color:var(--h3rp-muted); font-size:10px; }
+      .h3rp-footer { display:grid; grid-template-columns:minmax(0,1fr) auto minmax(0,1fr); color:var(--h3rp-muted); }
+      .h3rp-footer-status { text-align:right; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+      .h3rp-history { justify-content:center; }
+      .h3rp-history-nav { display:flex; align-items:center; border:1px solid var(--h3rp-border); border-radius:999px; padding:1px 3px; }
+      .h3rp-history-nav button { min-width:25px; min-height:22px; padding:1px 5px; border:0; border-radius:999px; background:transparent; }
+      .h3rp-history-count { min-width:43px; text-align:center; color:var(--h3rp-text); font-variant-numeric:tabular-nums; }
+      .h3rp-history-meta { max-width:240px; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; font-size:11px; }
+      .h3rp-history-tree { position:relative; flex:0 0 auto; }
+      .h3rp-history-tree > summary { list-style:none; cursor:pointer; padding:3px 7px;
+        border:1px solid var(--h3rp-border); border-radius:999px; background:var(--comfy-input-bg,#11141a);
+        color:var(--h3rp-text); user-select:none; }
+      .h3rp-history-tree > summary::-webkit-details-marker { display:none; }
+      .h3rp-history-tree[open] > summary { border-color:var(--h3rp-accent); }
+      .h3rp-history-tree-panel { position:absolute; z-index:20; bottom:calc(100% + 7px); left:50%;
+        transform:translateX(-50%); width:min(440px,calc(100vw - 30px)); max-height:310px; overflow:auto;
+        padding:7px; border:1px solid var(--h3rp-border); border-radius:8px; background:var(--h3rp-bg);
+        box-shadow:0 14px 36px rgba(0,0,0,.48); }
+      .h3rp-history-tree-row { display:flex; align-items:center; gap:4px; min-width:0; margin:2px 0; border-radius:5px; }
+      .h3rp-history-tree-row.h3rp-history-active { background:rgba(142,181,255,.12); }
+      .h3rp-history-tree-row.h3rp-history-archived { opacity:.58; }
+      .h3rp-history-tree-select { flex:1 1 auto; min-width:0; justify-content:flex-start !important;
+        min-height:26px !important; padding:3px 6px !important; border-color:transparent !important;
+        background:transparent !important; text-align:left; }
+      .h3rp-history-branch { flex:0 0 auto; color:var(--h3rp-muted); }
+      .h3rp-history-tree-label { min-width:0; overflow:hidden; text-overflow:ellipsis; white-space:nowrap;
+        color:var(--h3rp-text); }
+      .h3rp-history-tree-badge { flex:0 0 auto; color:var(--h3rp-muted); font-size:10px; }
+      .h3rp-history-tree-action { min-width:25px !important; min-height:25px !important; padding:2px 5px !important; }
+      .h3rp-history-tree-tools { display:flex; justify-content:space-between; align-items:center; gap:8px;
+        margin-top:6px; padding-top:6px; border-top:1px solid var(--h3rp-border);
+        color:var(--h3rp-muted); font-size:10px; }
+      .h3rp-history-tree-tools button { min-height:24px; padding:2px 6px; }
+      .h3rp-error { padding:12px; border:1px solid #a76565; border-radius:7px; color:#ffb3b3; background:#351f24; white-space:pre-wrap; }
+      .h3rp-popover { position:fixed; z-index:100000; width:min(360px,calc(100vw - 24px)); padding:9px;
+        border:1px solid #60718c; border-radius:9px; background:#171a20; color:#eef2f8;
+        box-shadow:0 14px 38px rgba(0,0,0,.48); font:12px/1.4 system-ui,sans-serif; }
+      .h3rp-popover[hidden] { display:none; }
+      .h3rp-popover-title { margin-bottom:6px; font-weight:750; }
+      .h3rp-popover-media { display:block; width:100%; max-height:240px; object-fit:contain; border-radius:6px; background:#08090c; }
+      .h3rp-popover audio.h3rp-popover-media { height:42px; background:transparent; }
+      .h3rp-popover-detail { margin-top:6px; color:rgba(238,242,248,.62); white-space:pre-wrap; overflow-wrap:anywhere; }
+      .h3rp-popover-editor { display:grid; gap:8px; }
+      .h3rp-popover-field { display:grid; grid-template-columns:82px minmax(0,1fr); align-items:center; gap:7px; }
+      .h3rp-popover-field > span { color:rgba(238,242,248,.68); }
+      .h3rp-popover-field select,.h3rp-popover-field input { width:100%; min-width:0; padding:5px 7px;
+        border:1px solid #60718c; border-radius:5px; background:#0e1117; color:#eef2f8; }
+      .h3rp-popover-actions { display:flex; justify-content:flex-end; gap:6px; }
+      .h3rp-popover-actions button { min-height:0; padding:4px 9px; }
+    `;
+    document.head.append(style);
+}
+
+function element(tag, className = "", text) {
+    const item = document.createElement(tag);
+    if (className) item.className = className;
+    if (text !== undefined) item.textContent = text;
+    return item;
+}
+
+function icon(kind) {
+    const item = element("span", "h3rp-icon");
+    item.innerHTML = ICONS[kind] ?? ICONS.reference;
+    return item;
+}
+
+function button(label, title, action, iconKind = null) {
+    const item = element("button");
+    item.type = "button";
+    item.title = title;
+    if (iconKind) item.append(icon(iconKind));
+    if (label) item.append(document.createTextNode(label));
+    // Pointer-clicking a toolbar or reference control must not discard the
+    // contenteditable selection it is about to operate on. Keyboard focus via
+    // Tab remains available because only pointer default behavior is blocked.
+    item.addEventListener("pointerdown", (event) => event.preventDefault());
+    item.addEventListener("click", action);
+    return item;
+}
+
+function nodeType(node) {
+    return node?.comfyClass ?? node?.type ?? null;
+}
+
+function allNodes(graph, output = []) {
+    for (const node of graph?._nodes ?? []) {
+        output.push(node);
+        if (node.subgraph) allNodes(node.subgraph, output);
+    }
+    return output;
+}
+
+function upstreamPlanNode(start) {
+    const queue = [start];
+    const seen = new Set();
+    while (queue.length) {
+        const candidate = queue.shift();
+        if (!candidate || seen.has(candidate)) continue;
+        seen.add(candidate);
+        if (candidate !== start && PLAN_NAMES.has(nodeType(candidate))) return candidate;
+        for (const input of candidate.inputs ?? []) {
+            const link = input.link == null ? null : candidate.graph?.links?.[input.link];
+            const parent = link ? candidate.graph?.getNodeById?.(link.origin_id) : null;
+            if (parent) queue.push(parent);
+        }
+    }
+    return null;
+}
+
+function inputSource(node, name) {
+    const input = node?.inputs?.find((item) => item.name === name);
+    const link = input?.link == null ? null : node.graph?.links?.[input.link];
+    return link ? node.graph?.getNodeById?.(link.origin_id) ?? null : null;
+}
+
+function mediaExtension(kind) {
+    if (kind === "image") return /\.(?:avif|bmp|gif|jpe?g|png|webp)$/i;
+    if (kind === "video") return /\.(?:m4v|mkv|mov|mp4|webm)$/i;
+    return /\.(?:aac|flac|m4a|mp3|ogg|opus|wav)$/i;
+}
+
+function widgetAsset(value, kind) {
+    if (value && typeof value === "object" && value.filename) {
+        return {filename:String(value.filename), subfolder:String(value.subfolder ?? ""), type:String(value.type ?? "input")};
+    }
+    let text = typeof value === "string" ? value.trim() : "";
+    if (!text) return null;
+    if (/^(?:blob:|data:|https?:|\/api\/view\?|\/view\?)/i.test(text)) return {url:text};
+    let type = "input";
+    const annotated = text.match(/\s+\[(input|output|temp)\]\s*$/i);
+    if (annotated) {
+        type = annotated[1].toLowerCase();
+        text = text.slice(0, annotated.index).trim();
+    }
+    text = text.replaceAll("\\", "/").replace(/^\/+/, "");
+    if (!mediaExtension(kind).test(text)) return null;
+    const slash = text.lastIndexOf("/");
+    return {filename:slash >= 0 ? text.slice(slash + 1) : text, subfolder:slash >= 0 ? text.slice(0, slash) : "", type};
+}
+
+function assetUrl(asset) {
+    if (!asset) return null;
+    if (asset.url) return asset.url;
+    const query = new URLSearchParams({filename:asset.filename, subfolder:asset.subfolder ?? "", type:asset.type ?? "input"});
+    return api.apiURL(`/view?${query.toString()}`);
+}
+
+function previewFromNode(node, kind) {
+    if (kind === "image") {
+        const rendered = node?.imgs?.[0];
+        const src = typeof rendered === "string" ? rendered : rendered?.src;
+        if (src) return src;
+    }
+    for (const widget of node?.widgets ?? []) {
+        const asset = widgetAsset(widget.value, kind);
+        if (asset) return assetUrl(asset);
+    }
+    return null;
+}
+
+function findMediaPreview(start, kind) {
+    const queue = [start];
+    const seen = new Set();
+    while (queue.length) {
+        const candidate = queue.shift();
+        if (!candidate || seen.has(candidate)) continue;
+        seen.add(candidate);
+        const url = previewFromNode(candidate, kind);
+        if (url) return {url, source:candidate};
+        for (const input of candidate.inputs ?? []) {
+            const parent = inputSource(candidate, input.name);
+            if (parent) queue.push(parent);
+        }
+    }
+    return {url:null, source:start};
+}
+
+function referenceMediaPreview(record, kind) {
+    if (record?.previewUrl) {
+        return {
+            url: api.apiURL(record.previewUrl),
+            source: record.source ?? record.node ?? null,
+        };
+    }
+    return findMediaPreview(record?.source, kind);
+}
+
+function findMediaAsset(start, kind) {
+    const queue = [start];
+    const seen = new Set();
+    while (queue.length) {
+        const candidate = queue.shift();
+        if (!candidate || seen.has(candidate)) continue;
+        seen.add(candidate);
+        for (const widget of candidate.widgets ?? []) {
+            const asset = widgetAsset(widget.value, kind);
+            if (asset && !asset.url) {
+                return {
+                    filename:asset.filename,
+                    subfolder:asset.subfolder ?? "",
+                    storage:asset.type ?? "input",
+                };
+            }
+        }
+        for (const input of candidate.inputs ?? []) {
+            const parent = inputSource(candidate, input.name);
+            if (parent) queue.push(parent);
+        }
+    }
+    return null;
+}
+
+function clamp(value, minimum, maximum, fallback) {
+    const numeric = Number(value);
+    return Number.isFinite(numeric) ? Math.max(minimum, Math.min(maximum, Math.round(numeric))) : fallback;
+}
+
+function editorPlainText(editor, {trimFinalNewline = true} = {}) {
+    function read(node, root) {
+        if (node.nodeType === Node.TEXT_NODE) return node.textContent ?? "";
+        if (node.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+            let text = "";
+            for (const child of node.childNodes) text += read(child, root);
+            return text;
+        }
+        if (node.nodeType !== Node.ELEMENT_NODE) return "";
+        if (node.classList?.contains("h3rp-token")) return node.dataset.token ?? node.textContent ?? "";
+        if (node.tagName === "BR") return "\n";
+        let text = "";
+        for (const child of node.childNodes) text += read(child, root);
+        if (["DIV", "P"].includes(node.tagName) && node !== root && !text.endsWith("\n")) text += "\n";
+        return text;
+    }
+    const text = read(editor, editor);
+    return trimFinalNewline ? text.replace(/\n$/, "") : text;
+}
+
+function selectedEditorPlainText(editor) {
+    const selection = globalThis.getSelection?.();
+    if (!selection?.rangeCount || selection.isCollapsed) return null;
+    const inside = (node) => node === editor || editor.contains(node);
+    if (!inside(selection.anchorNode) || !inside(selection.focusNode)) return null;
+    const fragment = selection.getRangeAt(0).cloneContents();
+    return editorPlainText(fragment);
+}
+
+function copyEditorSelection(editor, event, cut = false) {
+    const text = selectedEditorPlainText(editor);
+    if (text == null || !event.clipboardData) return false;
+    // A decorated tag contains icons/thumbnails as well as its visible label.
+    // Copy its canonical data-token value so another prompt editor receives
+    // exactly the original prompt markup rather than browser-generated HTML.
+    event.clipboardData.setData("text/plain", text);
+    event.preventDefault();
+    if (cut) {
+        const selection = globalThis.getSelection?.();
+        const range = selection.getRangeAt(0);
+        range.deleteContents();
+        range.collapse(true);
+        selection.removeAllRanges();
+        selection.addRange(range);
+        editor.dispatchEvent(new Event("input", {bubbles:true}));
+    }
+    return true;
+}
+
+function editorPointTextOffset(editor, node, offset) {
+    if (!node || (node !== editor && !editor.contains(node))) return null;
+    const range = document.createRange();
+    range.selectNodeContents(editor);
+    try {
+        range.setEnd(node, offset);
+    } catch (_error) {
+        return null;
+    }
+    return editorPlainText(range.cloneContents()).length;
+}
+
+function editorSelectionOffsets(editor) {
+    const selection = globalThis.getSelection?.();
+    if (!selection?.rangeCount) return null;
+    const selected = selection.getRangeAt(0);
+    const start = editorPointTextOffset(
+        editor, selected.startContainer, selected.startOffset,
+    );
+    const end = editorPointTextOffset(
+        editor, selected.endContainer, selected.endOffset,
+    );
+    return start == null || end == null ? null : {start, end};
+}
+
+function selectionTextOffset(editor) {
+    const selection = globalThis.getSelection?.();
+    const offset = selection?.rangeCount
+        ? editorPointTextOffset(editor, selection.focusNode, selection.focusOffset)
+        : null;
+    return offset == null ? editorPlainText(editor).length : offset;
+}
+
+function restoreCaret(editor, requested) {
+    const target = Math.max(0, Number(requested) || 0);
+    const range = document.createRange();
+    const selection = globalThis.getSelection?.();
+    let consumed = 0;
+    let placed = false;
+    function visit(node) {
+        if (placed) return;
+        if (node.nodeType === Node.TEXT_NODE) {
+            const length = node.textContent?.length ?? 0;
+            if (target <= consumed + length) {
+                range.setStart(node, Math.max(0, target - consumed));
+                placed = true;
+                return;
+            }
+            consumed += length;
+            return;
+        }
+        if (node.nodeType !== Node.ELEMENT_NODE) return;
+        if (node.classList?.contains("h3rp-token")) {
+            const length = String(node.dataset.token ?? "").length;
+            if (target <= consumed + length) {
+                if (target <= consumed) range.setStartBefore(node);
+                else range.setStartAfter(node);
+                placed = true;
+                return;
+            }
+            consumed += length;
+            return;
+        }
+        for (const child of node.childNodes) visit(child);
+    }
+    visit(editor);
+    if (!placed) range.selectNodeContents(editor), range.collapse(false);
+    else range.collapse(true);
+    selection?.removeAllRanges();
+    selection?.addRange(range);
+}
+
+function restoreTextSelection(editor, requestedStart, requestedEnd) {
+    const start = Math.max(0, Number(requestedStart) || 0);
+    const end = Math.max(start, Number(requestedEnd) || start);
+    let consumed = 0;
+    let startPoint = null;
+    let endPoint = null;
+    function visit(node) {
+        if (startPoint && endPoint) return;
+        if (node.nodeType === Node.TEXT_NODE) {
+            const length = node.textContent?.length ?? 0;
+            if (!startPoint && start >= consumed && start <= consumed + length) {
+                startPoint = [node, start - consumed];
+            }
+            if (!endPoint && end >= consumed && end <= consumed + length) {
+                endPoint = [node, end - consumed];
+            }
+            consumed += length;
+            return;
+        }
+        if (node.nodeType !== Node.ELEMENT_NODE) return;
+        if (node.classList?.contains("h3rp-token")) {
+            consumed += String(node.dataset.token ?? "").length;
+            return;
+        }
+        for (const child of node.childNodes) visit(child);
+    }
+    visit(editor);
+    if (!startPoint || !endPoint) {
+        restoreCaret(editor, end);
+        return;
+    }
+    const range = document.createRange();
+    range.setStart(...startPoint);
+    range.setEnd(...endPoint);
+    const selection = globalThis.getSelection?.();
+    selection?.removeAllRanges();
+    selection?.addRange(range);
+}
+
+function insertPlainText(editor, text) {
+    editor.focus();
+    const selection = globalThis.getSelection?.();
+    const range = selection?.rangeCount && editor.contains(selection.anchorNode)
+        ? selection.getRangeAt(0) : document.createRange();
+    if (!selection?.rangeCount || !editor.contains(selection.anchorNode)) {
+        range.selectNodeContents(editor);
+        range.collapse(false);
+    }
+    range.deleteContents();
+    const textNode = document.createTextNode(String(text ?? ""));
+    range.insertNode(textNode);
+    range.setStartAfter(textNode);
+    range.collapse(true);
+    selection?.removeAllRanges();
+    selection?.addRange(range);
+    editor.dispatchEvent(new Event("input", {bubbles:true}));
+}
+
+function promptAssistantIdentityKey(node) {
+    const workflow = app.extensionManager?.workflow?.activeWorkflow;
+    const workflowIdentity = workflow?.path ?? workflow?.activeState?.id ?? workflow?.filename ?? "legacy-workflow";
+    return `rich-workflow-${workflowIdentity}-node-${node.id ?? "new"}`;
+}
+
+function mount(node) {
+    if (node._h3RichPromptMounted || typeof node.addDOMWidget !== "function") return;
+    node._h3RichPromptMounted = true;
+    injectStyles();
+    node.properties ??= {};
+
+    const root = element("div", "h3rp-root");
+    root.title = "Edits only the selected scene prompt in the connected H3 Chain Plan.";
+    for (const eventName of ["pointerdown", "pointerup", "mousedown", "mouseup", "click", "dblclick"]) {
+        root.addEventListener(eventName, (event) => event.stopPropagation());
+    }
+    // Keep ComfyUI/LiteGraph's canvas shortcuts from claiming Ctrl/Cmd+V (and
+    // the other native editing shortcuts) while focus is inside this DOM
+    // widget. stopPropagation deliberately preserves the browser's default
+    // contenteditable action; preventDefault here would break paste.
+    for (const eventName of ["keydown", "keyup", "keypress", "copy", "cut", "paste"]) {
+        root.addEventListener(eventName, (event) => {
+            // Saving the workflow must remain available while typing; all
+            // editing/undo shortcuts keep their existing scene-local routing.
+            if (isWorkflowSaveShortcut(event)) {
+                if (event.type === "keydown") flushPlanEffects();
+                return;
+            }
+            event.stopPropagation();
+        });
+    }
+    root.addEventListener("wheel", (event) => event.stopPropagation());
+
+    const state = {
+        plan:null, planNode:null, planWidget:null, lastValue:"", lastRunName:"",
+        active:Math.max(0, Number(node.properties[ACTIVE_PROPERTY]) || 0),
+        fontSize:clamp(node.properties[FONT_PROPERTY], MIN_FONT, MAX_FONT, DEFAULT_FONT),
+        guide:normalizeRichGuide(node.properties[GUIDE_PROPERTY]),
+        decorated:promptEditorRichText(node.properties, PRESENTATION_PROPERTY, promptEditorPreferences()),
+        records:[], referenceMode:null, editor:null, refs:null, status:null, optimizerStatus:null,
+        referenceSyntax:new Map(),
+        promptSelection:null,
+        completion:null, schema:null,
+        history:{sceneKey:"", data:null, revisionId:null, host:null, loadToken:0, loadPromise:null,
+            saveTimer:null, pendingDraft:null, savePromise:null, error:"", treeOpen:false,
+            showArchived:false},
+        optimizer:{client:null, preparing:false, requestId:null, meta:null, origins:new Map(), providers:null,
+            abortController:null, activeBackend:null, error:"", message:"", pendingResult:null},
+        undoByScene:new Map(), promptUndo:null,
+        popover:null, popoverTimer:null, popoverPinned:false, pollTimer:null,
+        planSyncTimer:null, planSyncPending:null, analysisTimer:null,
+        applyPromptHistoryShortcut:null, ownsPromptHistoryTarget:null,
+        disposed:false,
+    };
+    node._h3RichPromptState = state;
+
+    // Own prompt undo during capture so ComfyUI's workflow-level Ctrl/Cmd+Z
+    // never sees the gesture first and restores an older active-scene
+    // property. The callback is replaced whenever the active scene renders.
+    root.addEventListener("keydown", (event) => {
+        const direction = promptUndoDirection(event);
+        if (!direction || !state.ownsPromptHistoryTarget?.(event.target)) return;
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        state.applyPromptHistoryShortcut?.(direction);
+    }, true);
+
+    function dirty() {
+        node.graph?.setDirtyCanvas?.(true, true);
+        app.graph?.setDirtyCanvas?.(true, true);
+    }
+
+    function persistView() {
+        node.properties[ACTIVE_PROPERTY] = state.active;
+        node.properties[FONT_PROPERTY] = state.fontSize;
+        node.properties[GUIDE_PROPERTY] = state.guide;
+        node.properties[PRESENTATION_PROPERTY] = state.decorated;
+        dirty();
+    }
+
+    function rebaseActivePromptOntoLivePlan() {
+        if (!state.plan || !state.planWidget) return false;
+        let live;
+        try { live = parsePlanJson(String(state.planWidget.value ?? "")); }
+        catch (_error) { return false; }
+        const index = rebaseScenePrompt(state.plan, live, state.active);
+        if (index < 0) return false;
+        state.active = index;
+        node.properties[ACTIVE_PROPERTY] = index;
+        return true;
+    }
+
+    function planRunName() {
+        return String(state.planNode?.widgets?.find((item) => item.name === "run_name")?.value ?? "").trim();
+    }
+
+    function flushPlanEffects() {
+        if (state.planSyncTimer != null) {
+            window.clearTimeout(state.planSyncTimer);
+            state.planSyncTimer = null;
+        }
+        const pending = state.planSyncPending;
+        state.planSyncPending = null;
+        if (!pending || !state.planWidget || !state.planNode) return;
+        const liveValue = String(state.planWidget.value ?? "");
+        if (liveValue !== pending.value) {
+            if (!rebaseActivePromptOntoLivePlan()) {
+                if (state.status) {
+                    state.status.textContent =
+                        "Plan structure changed; waiting to resynchronize";
+                }
+                return;
+            }
+            pending.value = planToJson(state.plan);
+            pending.sceneIndex = state.active;
+            pending.prompt = promptValueToText(
+                state.plan.shots[state.active]?.prompt,
+            );
+            state.lastValue = pending.value;
+            state.planWidget.value = pending.value;
+        }
+        if (typeof state.planWidget.callback === "function") {
+            state.planWidget.callback(pending.value);
+        } else {
+            state.planNode._h3ChainEditorRefresh?.();
+        }
+        state.planNode.graph?.setDirtyCanvas?.(true, true);
+        publishCompanionPrompt(
+            node, state.planNode, pending.sceneIndex, pending.prompt,
+        );
+        if (state.status) state.status.textContent = pending.message;
+        dirty();
+    }
+
+    function schedulePlanEffects(pending) {
+        if (state.disposed) return;
+        state.planSyncPending = pending;
+        if (state.planSyncTimer != null) {
+            window.clearTimeout(state.planSyncTimer);
+        }
+        state.planSyncTimer = window.setTimeout(
+            flushPlanEffects, PROMPT_SYNC_DELAY_MS,
+        );
+        if (state.status) state.status.textContent = "Editing…";
+    }
+
+    function schedulePromptAnalysis() {
+        if (state.disposed) return;
+        if (state.analysisTimer != null) {
+            window.clearTimeout(state.analysisTimer);
+        }
+        state.analysisTimer = window.setTimeout(() => {
+            state.analysisTimer = null;
+            state.schema?.refresh();
+        }, PROMPT_ANALYSIS_DELAY_MS);
+    }
+
+    function flushPromptAnalysis() {
+        if (state.analysisTimer == null) return;
+        window.clearTimeout(state.analysisTimer);
+        state.analysisTimer = null;
+        state.schema?.refresh();
+    }
+
+    function writePlan(
+        message = "Saved to connected Plan", {deferEffects = false} = {},
+    ) {
+        if (!state.plan || !state.planWidget || !state.planNode) return;
+        // Rich Editor owns only the selected prompt. Rebase when another UI
+        // changed the live Plan; consecutive keystrokes already share the
+        // latest Plan value and should not repeatedly parse the full JSON.
+        const liveValue = String(state.planWidget.value ?? "");
+        if (liveValue !== state.lastValue && !rebaseActivePromptOntoLivePlan()) {
+            if (state.status) state.status.textContent = "Plan structure changed; waiting to resynchronize";
+            return;
+        }
+        const value = planToJson(state.plan);
+        state.lastValue = value;
+        state.planWidget.value = value;
+        const pending = {
+            value,
+            sceneIndex:state.active,
+            prompt:promptValueToText(state.plan.shots[state.active]?.prompt),
+            message,
+        };
+        if (deferEffects) schedulePlanEffects(pending);
+        else {
+            state.planSyncPending = pending;
+            flushPlanEffects();
+        }
+    }
+
+    function historySceneKey(runName, shotId) {
+        return `${runName}\u0000${shotId}`;
+    }
+
+    function promptUndoForScene(shotId, text, {external = false} = {}) {
+        const key = historySceneKey(planRunName(), shotId);
+        let history = state.undoByScene.get(key);
+        if (!history) {
+            history = new PromptUndoHistory(text);
+            state.undoByScene.set(key, history);
+        } else if (external) {
+            // Plan Studio republishes the active prompt after non-prompt edits.
+            // Preserve undo when that synchronized text did not actually change.
+            history.align(text);
+        } else {
+            history.align(text);
+        }
+        return history;
+    }
+
+    function recordPromptReplacement(sceneIndex, shot, text) {
+        const shotId = String(
+            shot?.id || `clip_${String(sceneIndex + 1).padStart(4, "0")}`,
+        );
+        const current = promptValueToText(
+            shot?.prompt, `Scene ${sceneIndex + 1} prompt`,
+        );
+        const history = promptUndoForScene(shotId, current);
+        history.record(text, {inputType:"insertReplacementText"});
+        if (sceneIndex === state.active) state.promptUndo = history;
+        return history;
+    }
+
+    async function historyRequest(query = {}, body = null) {
+        const suffix = new URLSearchParams(query).toString();
+        const response = await api.fetchApi(`/minimax_h3_context_loop/prompt-history${suffix ? `?${suffix}` : ""}`,
+            body == null ? undefined : {method:"POST", headers:{"Content-Type":"application/json"}, body:JSON.stringify(body)});
+        let payload = {};
+        try { payload = await response.json(); } catch (_error) { /* proxy error */ }
+        if (!response.ok) throw new Error(payload.error || `Prompt history request failed (HTTP ${response.status}).`);
+        return payload;
+    }
+
+    function renderHistory() {
+        const history = state.history;
+        if (!history.host) return;
+        history.host.replaceChildren();
+        if (history.error) {
+            history.host.append(element("span", "h3rp-history-meta h3rp-status-error", history.error));
+            return;
+        }
+        if (!history.data) {
+            history.host.append(element("span", "h3rp-history-meta", "Loading versions…"));
+            return;
+        }
+        const navigation = promptRevisionNavigation(history.data, history.revisionId);
+        const controls = element("span", "h3rp-history-nav");
+        const previous = button("‹", "Activate previous prompt version in the Plan", () => navigation.previous && void selectHistoryRevision(navigation.previous.id));
+        const count = element("span", "h3rp-history-count", `Active ${navigation.position} / ${navigation.total}`);
+        const next = button("›", "Activate next prompt version in the Plan", () => navigation.next && void selectHistoryRevision(navigation.next.id));
+        previous.disabled = !navigation.previous;
+        next.disabled = !navigation.next;
+        controls.append(previous, count, next);
+        const treeDetails = renderHistoryTree();
+        const metadata = element("span", "h3rp-history-meta", promptRevisionLabel(navigation));
+        metadata.title = promptRevisionHelp(navigation);
+        history.host.append(controls, treeDetails, metadata);
+    }
+
+    function renderHistoryTree() {
+        const history = state.history;
+        const details = element("details", "h3rp-history-tree");
+        details.open = history.treeOpen;
+        const tree = promptRevisionTree(history.data, {includeArchived:history.showArchived});
+        const summary = element("summary", "", `History (${tree.rows.length})`);
+        summary.title = "Show prompt ancestry, labels, and revision actions";
+        const panel = element("div", "h3rp-history-tree-panel");
+        for (const row of tree.rows) {
+            const rowHost = element("div",
+                `h3rp-history-tree-row${row.isActive ? " h3rp-history-active" : ""}${row.isArchived ? " h3rp-history-archived" : ""}`);
+            rowHost.style.paddingLeft = `${row.depth * 15}px`;
+            const select = button("", `Activate ${row.displayLabel} in the Plan`, () => {
+                if (!row.isActive) void selectHistoryRevision(row.revision.id);
+            });
+            select.className = "h3rp-history-tree-select";
+            select.disabled = row.isActive;
+            select.append(
+                element("span", "h3rp-history-branch", row.depth ? "↳" : "●"),
+                element("span", "h3rp-history-tree-label", row.displayLabel),
+                element("span", "h3rp-history-tree-badge",
+                    row.isArchived ? "Archived"
+                        : row.isActive ? "Active"
+                            : row.isExecuted ? "Executed" : "Draft"),
+            );
+            const rename = button("Label", `Label ${row.displayLabel}`, () => {
+                const label = window.prompt(
+                    "Short label for this prompt revision (leave blank to clear):",
+                    String(row.revision.label ?? ""),
+                );
+                if (label != null) void mutateHistoryRevision("label", row.revision.id, {label});
+            });
+            rename.className = "h3rp-history-tree-action";
+            rowHost.append(select, rename);
+            if (row.canRestore) {
+                const restore = button("Restore", `Restore ${row.displayLabel} to visible history`, () => {
+                    void mutateHistoryRevision("archive", row.revision.id, {archived:false});
+                });
+                restore.className = "h3rp-history-tree-action";
+                rowHost.append(restore);
+            } else if (row.canArchive) {
+                const archive = button("Archive", `Archive ${row.displayLabel}`, () => {
+                    void mutateHistoryRevision("archive", row.revision.id, {archived:true});
+                });
+                archive.className = "h3rp-history-tree-action";
+                rowHost.append(archive);
+            }
+            if (row.canDelete) {
+                const remove = button("Delete", `Delete unexecuted leaf ${row.displayLabel}`, () => {
+                    if (window.confirm(`Delete ${row.displayLabel}? This cannot be undone.`)) {
+                        void mutateHistoryRevision("delete", row.revision.id);
+                    }
+                });
+                remove.className = "h3rp-history-tree-action";
+                rowHost.append(remove);
+            }
+            panel.append(rowHost);
+        }
+        if (!tree.rows.length) panel.append(element("div", "h3rp-history-tree-tools", "No visible revisions"));
+        const tools = element("div", "h3rp-history-tree-tools");
+        tools.append(element("span", "", "↳ shows parent → child progression"));
+        if (tree.archivedCount) {
+            tools.append(button(
+                history.showArchived ? "Hide archived" : `Show archived (${tree.archivedCount})`,
+                "Toggle archived prompt revisions",
+                () => {
+                    history.showArchived = !history.showArchived;
+                    history.treeOpen = true;
+                    renderHistory();
+                },
+            ));
+        }
+        panel.append(tools);
+        details.append(summary, panel);
+        details.addEventListener("toggle", () => { history.treeOpen = details.open; });
+        return details;
+    }
+
+    async function mutateHistoryRevision(action, revisionId, fields = {}) {
+        await flushHistoryDraft();
+        const history = state.history;
+        const shot = state.plan?.shots?.[state.active];
+        if (!shot) return;
+        const shotId = String(shot.id || `clip_${String(state.active + 1).padStart(4, "0")}`);
+        const runName = planRunName();
+        const key = historySceneKey(runName, shotId);
+        try {
+            const payload = await historyRequest({}, {
+                action, run_name:runName, scene_id:shotId, revision:revisionId, ...fields,
+            });
+            if (history.sceneKey !== key) return;
+            history.data = payload.history;
+            history.revisionId = payload.history?.active_revision ?? history.revisionId;
+            history.error = "";
+            renderHistory();
+        } catch (error) {
+            if (history.sceneKey !== key) return;
+            history.error = error?.message || String(error);
+            renderHistory();
+        }
+    }
+
+    async function loadHistory(shotId, prompt, synchronize = true) {
+        const runName = planRunName();
+        const history = state.history;
+        const key = historySceneKey(runName, shotId);
+        const token = ++history.loadToken;
+        history.sceneKey = key;
+        history.data = null;
+        history.revisionId = null;
+        history.error = "";
+        renderHistory();
+        if (!runName) {
+            history.error = "Set run_name for prompt history.";
+            renderHistory();
+            return;
+        }
+        const request = synchronize
+            ? historyRequest({}, {action:"save", run_name:runName, scene_id:shotId, prompt, parent_revision:null})
+            : historyRequest({run_name:runName, scene_id:shotId});
+        history.loadPromise = request;
+        try {
+            const payload = await request;
+            if (token !== history.loadToken || history.sceneKey !== key) return;
+            history.data = payload.history ?? payload;
+            history.revisionId = payload.revision?.id ?? history.data.active_revision ?? null;
+        } catch (error) {
+            if (token === history.loadToken && history.sceneKey === key) history.error = error?.message || String(error);
+        } finally {
+            if (history.loadPromise === request) history.loadPromise = null;
+            if (token === history.loadToken && history.sceneKey === key) renderHistory();
+        }
+    }
+
+    function scheduleHistoryDraft(shotId, prompt) {
+        if (state.disposed) return;
+        const runName = planRunName();
+        if (!runName) return;
+        const history = state.history;
+        history.pendingDraft = {key:historySceneKey(runName, shotId), runName, shotId, prompt};
+        if (history.saveTimer != null) window.clearTimeout(history.saveTimer);
+        history.saveTimer = window.setTimeout(() => { history.saveTimer = null; void flushHistoryDraft(); }, 650);
+    }
+
+    async function flushHistoryDraft() {
+        const history = state.history;
+        if (history.saveTimer != null) window.clearTimeout(history.saveTimer), history.saveTimer = null;
+        if (history.savePromise) {
+            await history.savePromise;
+            return history.pendingDraft ? flushHistoryDraft() : undefined;
+        }
+        const draft = history.pendingDraft;
+        if (!draft) return;
+        history.pendingDraft = null;
+        if (history.loadPromise && history.sceneKey === draft.key) await history.loadPromise;
+        const parent = history.sceneKey === draft.key ? history.revisionId : null;
+        const request = historyRequest({}, {action:"save", run_name:draft.runName, scene_id:draft.shotId,
+            prompt:draft.prompt, parent_revision:parent});
+        history.savePromise = request;
+        try {
+            const payload = await request;
+            if (history.sceneKey === draft.key) {
+                history.data = payload.history;
+                history.revisionId = payload.revision?.id ?? payload.history?.active_revision;
+                history.error = "";
+                renderHistory();
+            }
+        } catch (error) {
+            if (history.sceneKey === draft.key) history.error = error?.message || String(error), renderHistory();
+        } finally {
+            if (history.savePromise === request) history.savePromise = null;
+        }
+        if (history.pendingDraft) await flushHistoryDraft();
+    }
+
+    async function selectHistoryRevision(revisionId) {
+        await flushHistoryDraft();
+        const shot = state.plan?.shots?.[state.active];
+        if (!shot || !state.editor) return;
+        const shotId = String(shot.id || `clip_${String(state.active + 1).padStart(4, "0")}`);
+        const key = historySceneKey(planRunName(), shotId);
+        try {
+            const payload = await historyRequest({}, {action:"activate", run_name:planRunName(), scene_id:shotId, revision:revisionId});
+            if (state.history.sceneKey !== key) return;
+            state.history.data = payload.history;
+            state.history.revisionId = payload.revision.id;
+            const text = String(payload.revision.prompt ?? "");
+            recordPromptReplacement(state.active, shot, text);
+            shot.prompt = promptTextToLines(text);
+            renderEditorText(text);
+            writePlan("Loaded prompt version");
+            renderHistory();
+            state.editor.focus();
+        } catch (error) {
+            if (state.history.sceneKey === key) state.history.error = error?.message || String(error), renderHistory();
+        }
+    }
+
+    function ensurePopover() {
+        if (state.popover) return state.popover;
+        const popover = element("div", "h3rp-popover");
+        popover.hidden = true;
+        popover.addEventListener("mouseenter", () => {
+            if (state.popoverTimer != null) window.clearTimeout(state.popoverTimer), state.popoverTimer = null;
+        });
+        popover.addEventListener("mouseleave", scheduleHidePopover);
+        for (const eventName of [
+            "pointerdown", "pointerup", "mousedown", "mouseup", "click", "dblclick",
+            "keydown", "keyup", "keypress", "wheel",
+        ]) {
+            popover.addEventListener(eventName, (event) => event.stopPropagation());
+        }
+        document.body.append(popover);
+        state.popover = popover;
+        return popover;
+    }
+
+    function hidePopover(force = false) {
+        if (state.popoverPinned && !force) return;
+        state.popoverPinned = false;
+        if (!state.popover) return;
+        for (const media of state.popover.querySelectorAll("audio,video")) media.pause?.();
+        state.popover.hidden = true;
+    }
+
+    function scheduleHidePopover() {
+        if (state.popoverPinned) return;
+        if (state.popoverTimer != null) window.clearTimeout(state.popoverTimer);
+        state.popoverTimer = window.setTimeout(() => { state.popoverTimer = null; hidePopover(); }, 220);
+    }
+
+    function positionPopover(popover, anchor) {
+        popover.hidden = false;
+        const rect = anchor.getBoundingClientRect();
+        const width = Math.min(360, globalThis.innerWidth - 24);
+        const left = Math.max(12, Math.min(globalThis.innerWidth - width - 12, rect.left));
+        popover.style.left = `${left}px`;
+        popover.style.top = `${Math.max(12, Math.min(
+            globalThis.innerHeight - popover.offsetHeight - 12, rect.bottom + 7,
+        ))}px`;
+    }
+
+    function showPopover(record, anchor) {
+        if (!record || state.popoverPinned) return;
+        if (state.popoverTimer != null) window.clearTimeout(state.popoverTimer), state.popoverTimer = null;
+        const popover = ensurePopover();
+        popover.replaceChildren();
+        const syntax = selectedReferenceSyntax(record);
+        const displayToken = syntax === "semantic"
+            ? taggedPictureReferenceToken(record.tag, "semantic")
+            : record.token;
+        const title = (state.referenceMode === "scheduled" || state.referenceMode === "tagged") && record.label
+            ? `${displayToken} → ${record.label}` : displayToken;
+        popover.append(element("div", "h3rp-popover-title", title));
+        const mediaKind = record.kind === "picture" ? "image" : record.kind;
+        const media = referenceMediaPreview(record, mediaKind);
+        if (media.url) {
+            const mediaElement = element(mediaKind === "image" ? "img" : mediaKind);
+            mediaElement.className = "h3rp-popover-media";
+            mediaElement.src = media.url;
+            if (mediaKind !== "image") mediaElement.controls = true, mediaElement.preload = "metadata";
+            else mediaElement.alt = `Preview for ${record.token}`;
+            popover.append(mediaElement);
+        } else {
+            popover.append(element("div", "h3rp-muted", "No browser-playable file preview was found upstream."));
+        }
+        const sourceTitle = media.source?.title || nodeType(media.source) || "unresolved source";
+        popover.append(element("div", "h3rp-popover-detail",
+            `${record.kind.toUpperCase()} · ${record.selector === "prompt tag" ? "activated by prompt tag" : `scenes ${record.selector}`}\n${record.active ? "Active" : "Inactive"} in scene ${state.active + 1}\nSource: ${sourceTitle}`));
+        positionPopover(popover, anchor);
+    }
+
+    function recordSupportsNative(record) {
+        return record?.nativeToken !== null
+            && Boolean(String(record?.nativeToken ?? record?.token ?? ""));
+    }
+
+    function recordSupportsSemantic(record) {
+        return record?.kind === "picture" && Boolean(record?.tag)
+            && Boolean(record?.supportsSemantic || record?.semanticOnly);
+    }
+
+    function inlineReferenceCandidates(part) {
+        return state.records.filter((record) => {
+            if (state.referenceMode !== "tagged" && !record.active) return false;
+            return part.kind === "unknown" || record.kind === part.kind;
+        });
+    }
+
+    function showReferenceEditor(part, start, end, anchor) {
+        const candidates = inlineReferenceCandidates(part);
+        if (!candidates.length) return;
+        hidePopover(true);
+        state.popoverPinned = true;
+        const popover = ensurePopover();
+        const editor = element("div", "h3rp-popover-editor");
+        editor.append(element("div", "h3rp-popover-title", "Replace reference"));
+
+        const referenceField = element("label", "h3rp-popover-field");
+        referenceField.append(element("span", "", "Reference"));
+        const referenceSelect = element("select");
+        for (let index = 0; index < candidates.length; index += 1) {
+            const record = candidates[index];
+            const option = element("option", "", record.token);
+            option.value = String(index);
+            if (record.label && record.label !== record.token) {
+                option.textContent = `${record.token} → ${record.label}`;
+            }
+            referenceSelect.append(option);
+        }
+        const currentIndex = Math.max(0, candidates.findIndex(
+            (record) => record === part.record
+                || (record.tag && record.tag === part.record?.tag)
+                || record.token === part.record?.token,
+        ));
+        referenceSelect.value = String(currentIndex);
+        referenceField.append(referenceSelect);
+
+        const modeField = element("label", "h3rp-popover-field");
+        modeField.append(element("span", "", "Syntax"));
+        const modeSelect = element("select");
+        modeField.append(modeSelect);
+
+        const timestampField = element("label", "h3rp-popover-field");
+        timestampField.append(element("span", "", "Time (sec)"));
+        const timestampInput = element("input");
+        timestampInput.type = "number";
+        timestampInput.min = "0";
+        timestampInput.step = "0.01";
+        timestampInput.placeholder = "blank = untimed";
+        timestampInput.value = part.timestamp == null
+            ? "" : String(part.timestamp);
+        timestampField.append(timestampInput);
+
+        const updateModes = (preferred = modeSelect.value) => {
+            const record = candidates[Number(referenceSelect.value)];
+            const native = recordSupportsNative(record);
+            const semantic = recordSupportsSemantic(record);
+            modeSelect.replaceChildren();
+            if (native) {
+                const option = element("option", "", "@ native");
+                option.value = "native";
+                modeSelect.append(option);
+            }
+            if (semantic) {
+                const option = element("option", "", "# semantic (time optional)");
+                option.value = "semantic";
+                modeSelect.append(option);
+            }
+            modeSelect.value = [...modeSelect.options].some(
+                (option) => option.value === preferred,
+            ) ? preferred : semantic && !native ? "semantic" : "native";
+            timestampField.hidden = modeSelect.value !== "semantic";
+            modeField.hidden = modeSelect.options.length < 2;
+        };
+        referenceSelect.addEventListener("change", () => updateModes());
+        modeSelect.addEventListener("change", () => {
+            timestampField.hidden = modeSelect.value !== "semantic";
+        });
+        updateModes(part.semantic ? "semantic" : "native");
+        editor.append(referenceField, modeField, timestampField);
+
+        const actions = element("div", "h3rp-popover-actions");
+        const cancel = element("button", "", "Cancel");
+        cancel.type = "button";
+        cancel.addEventListener("click", () => hidePopover(true));
+        const apply = element("button", "", "Apply");
+        apply.type = "button";
+        apply.addEventListener("click", () => {
+            const record = candidates[Number(referenceSelect.value)];
+            const mode = modeSelect.value;
+            const timestampText = timestampInput.value.trim();
+            const timestamp = timestampText === ""
+                ? null : Number(timestampText);
+            const current = editorPlainText(state.editor);
+            if (current.slice(start, end) !== part.text) {
+                hidePopover(true);
+                renderEditorText(current);
+                return;
+            }
+            const next = replacePromptReferenceOccurrence(
+                current, start, end, record, mode, timestamp,
+            );
+            const replacement = referenceReplacementToken(
+                record, mode, timestamp,
+            );
+            hidePopover(true);
+            if (!state.editor || !replacement || next === current) return;
+            renderEditorText(next, start + replacement.length);
+            state.editor.dispatchEvent(new InputEvent("input", {
+                bubbles:true, inputType:"insertReplacementText",
+            }));
+            const referenceData = availableReferenceRecords(
+                node, state.active + 1, {
+                    includeInactive:true,
+                    prompt:[sharedPrompt(state.plan).text.trim(), next.trim()]
+                        .filter(Boolean).join("\n\n"),
+                },
+            );
+            state.records = referenceData.records;
+            state.referenceMode = referenceData.mode;
+            renderEditorText(next, start + replacement.length);
+            renderReferenceTray();
+            state.editor.focus();
+        });
+        actions.append(cancel, apply);
+        editor.append(actions);
+        editor.addEventListener("keydown", (event) => {
+            if (event.key === "Escape") {
+                event.preventDefault();
+                cancel.click();
+            } else if (event.key === "Enter") {
+                event.preventDefault();
+                apply.click();
+            }
+        });
+        popover.replaceChildren(editor);
+        positionPopover(popover, anchor);
+        referenceSelect.focus();
+    }
+
+    function makeToken(part, start, end) {
+        if (part.type === "text") return document.createTextNode(part.text);
+        const kind = part.type === "reference" ? part.kind : part.type;
+        const token = element("span", `h3rp-token h3rp-token-${kind}`);
+        token.contentEditable = "false";
+        token.dataset.token = part.text;
+        if (["subject", "speaker", "dialogue", "flow"].includes(part.type)) {
+            token.dataset.h3PromptMarker = "";
+            token.tabIndex = 0;
+            token.setAttribute("role", "button");
+            token.addEventListener("keydown", (event) => {
+                if (event.key !== "Enter" && event.key !== " ") return;
+                event.preventDefault();
+                event.stopPropagation();
+                token.click();
+            });
+        }
+        if (part.unresolved) token.classList.add("h3rp-token-unknown");
+        if (part.record && !part.record.active) token.classList.add("h3rp-token-inactive");
+        if (part.type === "section") {
+            token.append(element("span", "h3rp-token-label", part.text));
+            token.title = `H3 section · ${part.section}`;
+            return token;
+        }
+        const mediaKind = kind === "picture" ? "image" : kind;
+        const media = part.record
+            ? referenceMediaPreview(part.record, mediaKind) : null;
+        if (kind === "picture" && media?.url) {
+            const thumb = element("img", "h3rp-token-thumb");
+            thumb.src = media.url;
+            thumb.alt = "";
+            token.append(thumb);
+        } else {
+            token.append(icon(kind));
+        }
+        token.append(element("span", "h3rp-token-label", part.text));
+        if (part.record) {
+            token.title = part.type === "reference"
+                ? `${part.text} · click to replace or edit; hover for preview`
+                : `${part.text} · hover for ${kind} preview`;
+            token.addEventListener("mouseenter", () => showPopover(part.record, token));
+            token.addEventListener("mouseleave", scheduleHidePopover);
+            token.addEventListener("focus", () => showPopover(part.record, token));
+        } else {
+            token.title = part.type === "reference"
+                ? "Unresolved reference in this scene · click to replace"
+                : token.dataset.h3PromptMarker !== undefined
+                  ? "Click to replace or remove this prompt token" : part.text;
+        }
+        if (part.type === "reference") {
+            token.tabIndex = 0;
+            token.addEventListener("click", (event) => {
+                event.preventDefault();
+                event.stopPropagation();
+                showReferenceEditor(part, start, end, token);
+            });
+            token.addEventListener("keydown", (event) => {
+                if (event.key !== "Enter" && event.key !== " ") return;
+                event.preventDefault();
+                showReferenceEditor(part, start, end, token);
+            });
+        }
+        return token;
+    }
+
+    function renderEditorText(text, caret = null, editableSelection = null) {
+        if (!state.editor) return;
+        const scrollTop = state.editor.scrollTop;
+        const scrollLeft = state.editor.scrollLeft;
+        const source = String(text ?? "");
+        if (!state.decorated) {
+            state.editor.replaceChildren(document.createTextNode(source));
+            if (editableSelection?.selectionStart != null
+                    && editableSelection?.selectionEnd != null) {
+                restoreTextSelection(
+                    state.editor,
+                    editableSelection.selectionStart,
+                    editableSelection.selectionEnd,
+                );
+            } else if (caret != null) restoreCaret(state.editor, caret);
+            state.editor.scrollTop = scrollTop;
+            state.editor.scrollLeft = scrollLeft;
+            return;
+        }
+        const parts = tokenizeRichPrompt(source, state.records);
+        const fragment = document.createDocumentFragment();
+        let sourceOffset = 0;
+        for (let index = 0; index < parts.length; index += 1) {
+            const part = parts[index];
+            const partStart = sourceOffset;
+            const partEnd = partStart + part.text.length;
+            sourceOffset = partEnd;
+            // Leave an unfinished unknown @word as normal text while the user
+            // is still typing it; it becomes a red unresolved chip on blur or
+            // another explicit decoration pass.
+            const unfinished = part.type === "reference" && part.unresolved
+                && part.text.startsWith("@") && index === parts.length - 1
+                && document.activeElement === state.editor;
+            const editingSemanticTime = part.type === "reference" && part.semantic
+                && editableSelection?.selectionStart >= partStart
+                && editableSelection?.selectionEnd <= partEnd;
+            fragment.append(unfinished || editingSemanticTime
+                ? document.createTextNode(part.text)
+                : makeToken(part, partStart, partEnd));
+        }
+        state.editor.replaceChildren(fragment);
+        if (editableSelection?.selectionStart != null
+                && editableSelection?.selectionEnd != null) {
+            restoreTextSelection(
+                state.editor,
+                editableSelection.selectionStart,
+                editableSelection.selectionEnd,
+            );
+        } else if (caret != null) restoreCaret(state.editor, caret);
+        // Content decoration rebuilds the children and otherwise resets the
+        // editor viewport. Keep long prompts at the line the user was editing.
+        state.editor.scrollTop = scrollTop;
+        state.editor.scrollLeft = scrollLeft;
+    }
+
+    function saveEditorInput(event) {
+        const shot = state.plan?.shots?.[state.active];
+        if (!shot || !state.editor) return;
+        const shotId = String(shot.id || `clip_${String(state.active + 1).padStart(4, "0")}`);
+        const text = editorPlainText(state.editor);
+        state.promptUndo?.record(text, {inputType:event?.inputType});
+        shot.prompt = promptTextToLines(text);
+        writePlan("Saved to connected Plan", {deferEffects:true});
+        scheduleHistoryDraft(shotId, text);
+        // Keep the browser's live DOM intact while the user types. Existing
+        // chips remain atomic; newly typed raw labels are decorated on blur.
+        // The shared text-level undo survives later tag decoration and
+        // programmatic toolbar/menu insertions.
+    }
+
+    function rememberPromptSelection() {
+        const selected = state.editor ? editorSelectionOffsets(state.editor) : null;
+        if (selected) state.promptSelection = selected;
+    }
+
+    function insertDecoratedText(text, selectSemanticTimestamp = false) {
+        const inserted = String(text ?? "");
+        selectSemanticTimestamp = Boolean(
+            selectSemanticTimestamp && inserted.includes("[")
+            && inserted.includes("s]"));
+        const current = editorPlainText(state.editor);
+        const live = document.activeElement === state.editor
+            ? editorSelectionOffsets(state.editor) : null;
+        const selected = live ?? state.promptSelection ?? {
+            start:current.length, end:current.length,
+        };
+        const insertionStart = Math.max(
+            0, Math.min(current.length, Number(selected.start) || 0),
+        );
+        const insertionEnd = Math.max(
+            insertionStart,
+            Math.min(current.length, Number(selected.end) || insertionStart),
+        );
+        const next = current.slice(0, insertionStart)
+            + inserted + current.slice(insertionEnd);
+        if (state.referenceMode === "tagged") {
+            state.records = availableReferenceRecords(
+                node, state.active + 1, {
+                    includeInactive: true,
+                    prompt: [
+                        sharedPrompt(state.plan).text.trim(),
+                        next.trim(),
+                    ].filter(Boolean).join("\n\n"),
+                },
+            ).records;
+        }
+        if (selectSemanticTimestamp) {
+            const first = inserted.indexOf("[") + 1;
+            const last = inserted.lastIndexOf("s]");
+            renderEditorText(next, null, {
+                selectionStart: insertionStart + first,
+                selectionEnd: insertionStart + last,
+            });
+            state.promptSelection = {
+                start:insertionStart + first,
+                end:insertionStart + last,
+            };
+        } else {
+            const caret = insertionStart + inserted.length;
+            renderEditorText(next, caret);
+            state.promptSelection = {start:caret, end:caret};
+        }
+        state.editor.dispatchEvent(new InputEvent("input", {
+            bubbles:true, inputType:"insertText",
+        }));
+        state.editor.focus();
+    }
+
+    function referenceSyntaxKey(record) {
+        const shot = state.plan?.shots?.[state.active];
+        return `${String(shot?.id ?? state.active)}:${record.tag}`;
+    }
+
+    function selectedReferenceSyntax(record) {
+        if (state.referenceMode !== "tagged") return "native";
+        if (record.semanticOnly) return "semantic";
+        if (!record.supportsSemantic) return "native";
+        const promptMode = taggedPictureReferenceMode(
+            editorPlainText(state.editor), record.tag,
+        );
+        if (promptMode === "native" || promptMode === "semantic") {
+            return promptMode;
+        }
+        return state.referenceSyntax.get(referenceSyntaxKey(record)) ?? "native";
+    }
+
+    function refreshReferenceState(prompt = editorPlainText(state.editor)) {
+        if (!state.plan?.shots?.length) {
+            state.records = [];
+            state.referenceMode = null;
+            return {wrapper:null, mode:null, records:[]};
+        }
+        const referenceData = availableReferenceRecords(
+            node, state.active + 1, {
+                includeInactive:true,
+                prompt:[
+                    sharedPrompt(state.plan).text.trim(),
+                    String(prompt ?? "").trim(),
+                ].filter(Boolean).join("\n\n"),
+            },
+        );
+        state.records = referenceData.records;
+        state.referenceMode = referenceData.mode;
+        return referenceData;
+    }
+
+    function convertReferenceSyntax(record, mode) {
+        state.referenceSyntax.set(referenceSyntaxKey(record), mode);
+        const current = editorPlainText(state.editor);
+        const next = convertTaggedPictureReference(current, record.tag, mode);
+        if (next !== current) {
+            renderEditorText(next, next.length);
+            state.editor.dispatchEvent(new InputEvent("input", {
+                bubbles:true, inputType:"insertReplacementText",
+            }));
+            state.records = availableReferenceRecords(
+                node, state.active + 1, {
+                    includeInactive:true,
+                    prompt:[sharedPrompt(state.plan).text.trim(), next.trim()]
+                        .filter(Boolean).join("\n\n"),
+                },
+            ).records;
+        }
+        renderReferenceTray();
+    }
+
+    function insertReference(record) {
+        const mode = selectedReferenceSyntax(record);
+        const token = mode === "semantic"
+            ? taggedPictureReferenceToken(record.tag, "semantic")
+            : record.token;
+        insertDecoratedText(token, mode === "semantic");
+        state.refs?.classList.remove("h3rp-open");
+    }
+
+    function renderReferenceTray() {
+        const tray = state.refs;
+        if (!tray) return;
+        refreshReferenceState(editorPlainText(state.editor));
+        tray.replaceChildren();
+        if (!state.records.length) {
+            tray.append(element("div", "h3rp-ref-help", "No connected Tagged/Scheduled Ref2VA, core Ref2VA, or core I2V/FL2V references were found."));
+            return;
+        }
+        tray.append(element("div", "h3rp-ref-help",
+            state.referenceMode === "tagged"
+                ? "Picture previews can switch and convert between native @tag and Qwen-only #tag; add [time] for explicit placement. Video and audio stay native-only. Hover for a media preview; audio never autoplays."
+                : `Scene ${state.active + 1}: click an active reference to insert it. Hover for image, video, or audio preview. Audio never autoplays.`));
+        for (const record of state.records) {
+            const insertable = record.active || state.referenceMode === "tagged";
+            const mode = selectedReferenceSyntax(record);
+            const displayToken = mode === "semantic"
+                ? taggedPictureReferenceToken(record.tag, "semantic")
+                : record.token;
+            const shell = element("div", "h3rp-ref-card-shell");
+            const card = button("", insertable ? `Insert ${displayToken}` : `${record.token} is inactive in this scene`, () => {
+                if (!insertable) return;
+                insertReference(record);
+            });
+            card.classList.add("h3rp-ref-card");
+            if (!record.active) card.classList.add("h3rp-inactive");
+            const mediaKind = record.kind === "picture" ? "image" : record.kind;
+            const media = referenceMediaPreview(record, mediaKind);
+            if (record.kind === "picture" && media.url) {
+                const thumb = element("img", "h3rp-token-thumb");
+                thumb.src = media.url;
+                thumb.alt = "";
+                card.append(thumb);
+            } else card.append(icon(record.kind));
+            const copy = element("span", "h3rp-ref-card-copy");
+            copy.append(
+                element("div", "h3rp-ref-card-title", displayToken),
+                element("div", "h3rp-ref-card-detail", record.label && record.label !== record.token
+                    ? `${record.label} · ${record.selector === "prompt tag" ? "prompt activated" : `scenes ${record.selector}`}`
+                    : `${record.kind} · ${record.selector === "prompt tag" ? "insert to activate" : `scenes ${record.selector}`}`),
+            );
+            card.append(copy);
+            card.addEventListener("mouseenter", () => showPopover(record, card));
+            card.addEventListener("mouseleave", scheduleHidePopover);
+            shell.append(card);
+            if (state.referenceMode === "tagged" && record.supportsSemantic) {
+                const usedMode = taggedPictureReferenceMode(
+                    editorPlainText(state.editor), record.tag,
+                );
+                const modes = element("div", "h3rp-ref-mode");
+                const native = button("@", "Use native @tag; convert semantic anchors already in this scene", () => {
+                    convertReferenceSyntax(record, "native");
+                });
+                const semantic = button("#", "Use untimed Qwen-only #tag; add [time] for placement", () => {
+                    convertReferenceSyntax(record, "semantic");
+                });
+                native.classList.toggle(
+                    "h3rp-selected", mode === "native" || usedMode === "mixed",
+                );
+                semantic.classList.toggle(
+                    "h3rp-selected", mode === "semantic" || usedMode === "mixed",
+                );
+                modes.append(native, semantic);
+                shell.append(modes);
+            }
+            tray.append(shell);
+        }
+    }
+
+    function optimizerSceneKey(index = state.active) {
+        const shot = state.plan?.shots?.[index];
+        return `${index}:${String(shot?.id || `clip_${String(index + 1).padStart(4, "0")}`)}`;
+    }
+
+    function optimizerBusy() {
+        return Boolean(state.optimizer.preparing || state.optimizer.requestId);
+    }
+
+    function optimizerProviders() {
+        const advertised = Array.isArray(state.optimizer.providers)
+            ? state.optimizer.providers.filter((item) => item && typeof item.id === "string") : [];
+        return advertised;
+    }
+
+    function optimizerProviderLabel(id = promptOptimizerMcpProvider()) {
+        return optimizerProviders().find((item) => item.id === id)?.label || id;
+    }
+
+    function refreshOptimizerUi() {
+        const busy = optimizerBusy();
+        if (busy) state.completion?.hide();
+        if (state.editor) state.editor.contentEditable = busy ? "false" : "true";
+        for (const control of root.querySelectorAll("[data-h3rp-lock]")) control.disabled = busy;
+        const optimize = root.querySelector(".h3rp-optimize");
+        if (optimize) {
+            const backend = promptOptimizerBackend();
+            optimize.disabled = busy || backend === "disabled";
+            optimize.title = backend === "disabled"
+                ? "Prompt optimization is disabled in ComfyUI Settings → MiniMax H3 Context Loop → Prompt optimizer."
+                : `Optimize through ${backend === "mcp" ? `MCP agent (${promptOptimizerMcpProvider()})` : "the configured Direct API"}. The result becomes a reversible prompt revision.`;
+        }
+        const stop = root.querySelector(".h3rp-stop");
+        if (stop) stop.hidden = !state.optimizer.requestId;
+        const applyPending = root.querySelector(".h3rp-apply-pending");
+        if (applyPending) applyPending.hidden = !state.optimizer.pendingResult;
+        if (state.optimizerStatus) {
+            state.optimizerStatus.className = `h3rp-status${state.optimizer.error ? " h3rp-status-error" : state.optimizer.message ? " h3rp-status-success" : ""}`;
+            state.optimizerStatus.textContent = state.optimizer.error || state.optimizer.message || (busy ? "Optimizing…" : "");
+        }
+    }
+
+    function handleOptimizerFrame(frame) {
+        if (!frame || typeof frame !== "object") return;
+        if (frame.type === "prompt_assist_ready") {
+            state.optimizer.providers = Array.isArray(frame.providers) ? frame.providers : null;
+            return;
+        }
+        // A previously connected bridge may still emit a late frame while a
+        // Direct API request is active. Never let that frame cancel or replace
+        // the direct result.
+        if (state.optimizer.activeBackend !== "mcp") return;
+        if (frame.type === "prompt_assist_started" && frame.request_id === state.optimizer.requestId) {
+            state.optimizer.message = `Optimizing with ${optimizerProviderLabel()}…`;
+        } else if (frame.type === "prompt_assist_progress" && frame.request_id === state.optimizer.requestId) {
+            state.optimizer.message = "Agent is drafting…";
+        } else if (frame.type === "prompt_assist_result" && frame.request_id === state.optimizer.requestId) {
+            const meta = state.optimizer.meta;
+            state.optimizer.requestId = null;
+            state.optimizer.meta = null;
+            state.optimizer.activeBackend = null;
+            const result = typeof frame.rewritten_prompt === "string" ? frame.rewritten_prompt : null;
+            if (!result?.trim()) {
+                state.optimizer.error = "The optimizer returned no replacement prompt.";
+            } else {
+                const shot = state.plan?.shots?.[meta.sceneIndex];
+                const current = shot ? promptValueToText(shot.prompt) : "";
+                if (!shot || String(shot.id || "") !== meta.sceneId || current !== meta.currentAtRequest) {
+                    state.optimizer.pendingResult = {...meta, result};
+                    state.optimizer.error = "The scene changed while optimizing; the result was not applied.";
+                } else {
+                    recordPromptReplacement(meta.sceneIndex, shot, result);
+                    shot.prompt = promptTextToLines(result);
+                    state.optimizer.origins.set(meta.sceneKey, {source:meta.source, result});
+                    writePlan("Optimized prompt saved to Plan");
+                    if (state.active === meta.sceneIndex) {
+                        renderEditorText(result);
+                        scheduleHistoryDraft(meta.sceneId, result);
+                        void flushHistoryDraft();
+                    }
+                    state.optimizer.message = frame.message || "Optimized prompt saved as a new revision.";
+                    state.optimizer.error = "";
+                }
+            }
+        } else if (frame.type === "prompt_assist_error"
+                && (!frame.request_id || frame.request_id === state.optimizer.requestId)) {
+            state.optimizer.requestId = null;
+            state.optimizer.meta = null;
+            state.optimizer.activeBackend = null;
+            state.optimizer.error = String(frame.error || "Prompt optimization failed.");
+        } else if (frame.type === "prompt_assist_cancelled" && frame.request_id === state.optimizer.requestId) {
+            state.optimizer.requestId = null;
+            state.optimizer.meta = null;
+            state.optimizer.activeBackend = null;
+            state.optimizer.message = "Optimization stopped; the prompt was not changed.";
+        } else if (frame.type === "prompt_assist_cancel_ack" && frame.cancelled === false
+                && frame.request_id === state.optimizer.requestId) {
+            state.optimizer.requestId = null;
+            state.optimizer.meta = null;
+            state.optimizer.activeBackend = null;
+            state.optimizer.error = "The optimizer request is no longer active.";
+        }
+        refreshOptimizerUi();
+    }
+
+    function applyPendingOptimizerResult() {
+        const pending = state.optimizer.pendingResult;
+        if (!pending) return;
+        const shot = state.plan?.shots?.[pending.sceneIndex];
+        if (!shot || String(shot.id || "") !== pending.sceneId) {
+            state.optimizer.error = "The optimized result belongs to a scene that no longer exists.";
+            state.optimizer.pendingResult = null;
+            refreshOptimizerUi();
+            return;
+        }
+        recordPromptReplacement(pending.sceneIndex, shot, pending.result);
+        shot.prompt = promptTextToLines(pending.result);
+        state.optimizer.origins.set(pending.sceneKey, {source:pending.source, result:pending.result});
+        state.optimizer.pendingResult = null;
+        state.optimizer.error = "";
+        state.optimizer.message = "Changed source replaced explicitly; result saved as a new revision.";
+        writePlan("Optimized prompt saved to Plan");
+        if (state.active === pending.sceneIndex) {
+            renderEditorText(pending.result);
+            scheduleHistoryDraft(pending.sceneId, pending.result);
+            void flushHistoryDraft();
+        }
+        refreshOptimizerUi();
+    }
+
+    function optimizerInstruction(mode, refs) {
+        const referenceSummary = refs.records.length
+            ? refs.records.map((record) => {
+                const mapping = record.label && record.label !== record.token
+                    ? ` -> ${record.label}` : "";
+                return `${record.token}${mapping} (${record.kind}, ${record.active ? "active" : "inactive"})`;
+            }).join(", ")
+            : "none discovered";
+        return `${richGuideInstruction(state.guide, mode)} Connected scene references: ${referenceSummary}.`;
+    }
+
+    function optimizerMeta(sceneIndex, sceneId, sceneKey, source, current) {
+        return {sceneIndex, sceneId, sceneKey, source, currentAtRequest:current};
+    }
+
+    function optimizerResources(refs) {
+        return refs.records.filter((record) => record.active).map((record) => ({
+            type:record.kind === "picture" ? "image" : record.kind,
+            tag:record.token,
+            asset:findMediaAsset(
+                record.source, record.kind === "picture" ? "image" : record.kind),
+        })).filter((resource) => resource.asset);
+    }
+
+    function applyOptimizerResponse(result, message, meta) {
+        if (!result?.trim()) {
+            state.optimizer.error = "The optimizer returned no replacement prompt.";
+            return;
+        }
+        const shot = state.plan?.shots?.[meta.sceneIndex];
+        const current = shot ? promptValueToText(shot.prompt) : "";
+        if (!shot || String(shot.id || "") !== meta.sceneId || current !== meta.currentAtRequest) {
+            state.optimizer.pendingResult = {...meta, result};
+            state.optimizer.error = "The scene changed while optimizing; the result was not applied.";
+            return;
+        }
+        recordPromptReplacement(meta.sceneIndex, shot, result);
+        shot.prompt = promptTextToLines(result);
+        state.optimizer.origins.set(meta.sceneKey, {source:meta.source, result});
+        writePlan("Optimized prompt saved to Plan");
+        if (state.active === meta.sceneIndex) {
+            renderEditorText(result);
+            scheduleHistoryDraft(meta.sceneId, result);
+            void flushHistoryDraft();
+        }
+        state.optimizer.message = message || "Optimized prompt saved as a new revision.";
+        state.optimizer.error = "";
+    }
+
+    async function optimizeDirect(requestId, instruction, context, resources, meta, config) {
+        const abortController = new AbortController();
+        state.optimizer.abortController = abortController;
+        state.optimizer.requestId = requestId;
+        state.optimizer.preparing = false;
+        state.optimizer.activeBackend = "direct";
+        state.optimizer.meta = meta;
+        state.optimizer.message = "Optimizing with Direct API…";
+        refreshOptimizerUi();
+        try {
+            const body = makeDirectPromptOptimizeRequest({
+                config, instruction, context, resources,
+            });
+            const response = await api.fetchApi("/minimax_h3_context_loop/prompt-optimize", {
+                method:"POST", headers:{"Content-Type":"application/json"},
+                body:JSON.stringify(body), signal:abortController.signal,
+            });
+            const payload = await response.json().catch(() => ({}));
+            if (!response.ok) throw new Error(payload.error || `Direct prompt optimizer failed (HTTP ${response.status}).`);
+            if (state.optimizer.requestId !== requestId) return;
+            state.optimizer.requestId = null;
+            state.optimizer.meta = null;
+            state.optimizer.abortController = null;
+            state.optimizer.activeBackend = null;
+            applyOptimizerResponse(String(payload.prompt || ""), payload.message, meta);
+        } catch (error) {
+            if (state.optimizer.requestId !== requestId) return;
+            state.optimizer.requestId = null;
+            state.optimizer.meta = null;
+            state.optimizer.abortController = null;
+            state.optimizer.activeBackend = null;
+            if (error?.name === "AbortError") state.optimizer.message = "Optimization stopped; the prompt was not changed.";
+            else state.optimizer.error = error?.message || String(error);
+        }
+        refreshOptimizerUi();
+    }
+
+    async function optimizeMcp(requestId, instruction, context, meta) {
+        const provider = promptOptimizerMcpProvider();
+        await state.optimizer.client.connect();
+        const selected = state.optimizer.providers?.find((item) => item.id === provider);
+        if (!selected) throw new Error(`${provider} is not supported by this comfyui-mcp prompt bridge.`);
+        if (selected.available === false) {
+            throw new Error(`${selected.label || provider} is unavailable${selected.reason ? `: ${selected.reason}` : "."}`);
+        }
+        state.optimizer.client.reset();
+        const request = makePromptAssistRequest({
+            requestId,
+            conversationId:state.optimizer.client.conversationId,
+            provider,
+            mode:"rewrite",
+            instruction,
+            context,
+        });
+        state.optimizer.requestId = requestId;
+        state.optimizer.preparing = false;
+        state.optimizer.activeBackend = "mcp";
+        state.optimizer.meta = meta;
+        state.optimizer.message = `Optimizing with ${optimizerProviderLabel(provider)}…`;
+        refreshOptimizerUi();
+        await state.optimizer.client.send(request);
+    }
+
+    async function optimizePrompt() {
+        if (optimizerBusy() || !state.plan?.shots?.length || !state.editor) return;
+        const backend = promptOptimizerBackend();
+        if (backend === "disabled") return;
+        const directConfig = backend === "direct" ? promptOptimizerDirectConfig() : null;
+        const configurationError = directConfig
+            ? directOptimizerConfigurationError(directConfig) : "";
+        if (configurationError) {
+            state.optimizer.error = `${configurationError} Configure it in ComfyUI Settings → MiniMax H3 Context Loop → Prompt optimizer.`;
+            state.optimizer.message = "";
+            refreshOptimizerUi();
+            void openPromptOptimizerSettings();
+            return;
+        }
+        const sceneIndex = state.active;
+        const shot = state.plan.shots[sceneIndex];
+        const sceneId = String(shot.id || `clip_${String(sceneIndex + 1).padStart(4, "0")}`);
+        const sceneKey = optimizerSceneKey(sceneIndex);
+        const current = editorPlainText(state.editor);
+        const source = optimizerSource(current, state.optimizer.origins.get(sceneKey));
+        const refs = availableReferenceRecords(node, sceneIndex + 1, {
+            includeInactive: true,
+            prompt: [sharedPrompt(state.plan).text.trim(), source.trim()]
+                .filter(Boolean).join("\n\n"),
+        });
+        const mode = richGenerationMode(refs.mode);
+        const context = buildPromptAssistantContext(state.plan, sceneIndex, source, {
+            includeShared:true, includeAdjacent:true,
+        });
+        context.generation_mode = mode;
+        const requestId = `rich-${globalThis.crypto?.randomUUID?.() ?? `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`}`;
+        const instruction = optimizerInstruction(mode, refs);
+        const meta = optimizerMeta(sceneIndex, sceneId, sceneKey, source, current);
+        state.optimizer.error = "";
+        state.optimizer.pendingResult = null;
+        state.optimizer.message = backend === "mcp"
+            ? "Connecting to the isolated prompt agent…" : "Preparing Direct API request…";
+        state.optimizer.preparing = true;
+        state.optimizer.activeBackend = backend;
+        refreshOptimizerUi();
+        try {
+            if (backend === "direct") {
+                await optimizeDirect(
+                    requestId, instruction, context, optimizerResources(refs), meta, directConfig);
+            } else {
+                await optimizeMcp(requestId, instruction, context, meta);
+            }
+        } catch (error) {
+            state.optimizer.preparing = false;
+            state.optimizer.requestId = null;
+            state.optimizer.meta = null;
+            state.optimizer.abortController = null;
+            state.optimizer.activeBackend = null;
+            state.optimizer.error = error?.message || String(error);
+            refreshOptimizerUi();
+        }
+    }
+
+    function stopOptimizer() {
+        if (!state.optimizer.requestId) return;
+        if (state.optimizer.activeBackend === "direct") {
+            state.optimizer.requestId = null;
+            state.optimizer.meta = null;
+            state.optimizer.activeBackend = null;
+            state.optimizer.abortController?.abort();
+            state.optimizer.abortController = null;
+            state.optimizer.message = "Optimization stopped; the prompt was not changed.";
+        } else if (!state.optimizer.client.cancel(state.optimizer.requestId)) {
+            state.optimizer.error = "The bridge is disconnected; the request could not be cancelled.";
+        } else state.optimizer.message = "Stopping optimizer…";
+        refreshOptimizerUi();
+    }
+
+    function showFailure(message) {
+        state.completion?.destroy();
+        state.completion = null;
+        state.schema = null;
+        state.editor = null;
+        state.history.host = null;
+        root.replaceChildren(
+            element("div", "h3rp-title", "Rich Scene Prompt Editor"),
+            element("div", "h3rp-error", message),
+            element("div", "h3rp-context", "Connect the Plan output to this node's plan input."),
+        );
+    }
+
+    function navigate(offset, absolute = null, {synchronize = true, focus = true} = {}) {
+        if (!state.plan?.shots?.length || optimizerBusy()) return;
+        flushPlanEffects();
+        flushPromptAnalysis();
+        const pending = state.sceneNavigation;
+        const from = pending && pending.planNode === state.planNode
+                && pending.runName === planRunName() ? pending.index : state.active;
+        const requested = absolute == null ? from + offset : Number(absolute);
+        if (!Number.isFinite(requested)) return;
+        const index = Math.max(0, Math.min(state.plan.shots.length - 1, Math.trunc(requested)));
+        const selection = {
+            planNode:state.planNode, runName:planRunName(),
+            sceneId:String(state.plan.shots[index]?.id ?? ""), index,
+        };
+        state.sceneNavigation = selection;
+        void (async () => {
+            await flushHistoryDraft();
+            // History IO can complete out of order. Only the latest selection
+            // may move this editor or broadcast a scene to its companions.
+            if (state.disposed || state.sceneNavigation !== selection
+                    || state.planNode !== selection.planNode
+                    || planRunName() !== selection.runName) return;
+            state.sceneNavigation = null;
+            const target = selection.sceneId
+                    && String(state.plan.shots[selection.index]?.id ?? "") !== selection.sceneId
+                ? state.plan.shots.findIndex(shot => String(shot?.id ?? "") === selection.sceneId)
+                : selection.index;
+            if (!state.plan.shots[target]) return;
+            state.active = target;
+            persistView();
+            render();
+            if (synchronize) publishCompanionScene(node, state.planNode, state.active);
+            if (focus) state.editor?.focus();
+        })();
+    }
+
+    function render() {
+        hidePopover(true);
+        state.completion?.destroy();
+        state.completion = null;
+        state.schema = null;
+        if (!state.plan?.shots?.length) return showFailure("The connected Plan has no scenes.");
+        state.active = Math.max(0, Math.min(state.active, state.plan.shots.length - 1));
+        root.style.setProperty("--h3rp-font-size", `${state.fontSize}px`);
+        root.replaceChildren();
+        const shot = state.plan.shots[state.active];
+        const shotId = String(shot.id || `clip_${String(state.active + 1).padStart(4, "0")}`);
+        const referenceData = availableReferenceRecords(
+            node, state.active + 1, {
+                includeInactive: true,
+                prompt: [
+                    sharedPrompt(state.plan).text.trim(),
+                    promptValueToText(
+                        shot.prompt, `Scene ${state.active + 1} prompt`).trim(),
+                ].filter(Boolean).join("\n\n"),
+            },
+        );
+        state.records = referenceData.records;
+        state.referenceMode = referenceData.mode;
+
+        const head = element("div", "h3rp-head");
+        head.append(
+            element("span", "h3rp-title", "Rich Scene Prompt Editor"),
+            element("span", "h3rp-context", `${richGenerationMode(referenceData.mode)} · ${sharedPrompt(state.plan).text.trim() ? "shared prompt active" : "no shared prompt"}`),
+        );
+
+        const nav = element("div", "h3rp-nav");
+        const previous = button("←", "Previous scene (Alt+Left)", () => navigate(-1));
+        const next = button("→", "Next scene (Alt+Right)", () => navigate(1));
+        previous.disabled = state.active === 0;
+        next.disabled = state.active === state.plan.shots.length - 1;
+        previous.dataset.h3rpLock = "";
+        next.dataset.h3rpLock = "";
+        const sceneSelect = element("select");
+        sceneSelect.dataset.h3rpLock = "";
+        for (let index = 0; index < state.plan.shots.length; index += 1) {
+            const id = state.plan.shots[index].id || `clip_${String(index + 1).padStart(4, "0")}`;
+            const option = element("option", "", `Scene ${index + 1} — ${id}`);
+            option.value = String(index);
+            sceneSelect.append(option);
+        }
+        sceneSelect.value = String(state.active);
+        sceneSelect.addEventListener("change", () => navigate(0, sceneSelect.value));
+        const smaller = button("A−", "Decrease prompt font", () => {
+            state.fontSize = clamp(state.fontSize - 1, MIN_FONT, MAX_FONT, DEFAULT_FONT); persistView(); render();
+        });
+        const larger = button("A+", "Increase prompt font", () => {
+            state.fontSize = clamp(state.fontSize + 1, MIN_FONT, MAX_FONT, DEFAULT_FONT); persistView(); render();
+        });
+        smaller.dataset.h3rpLock = "";
+        larger.dataset.h3rpLock = "";
+        nav.append(previous, sceneSelect, next, smaller, element("span", "h3rp-muted", `${state.fontSize}px`), larger);
+
+        const toolbar = element("div", "h3rp-toolbar");
+        const refsButton = button("References", "Show connected references, miniatures, and media previews", () => {
+            state.completion?.hide();
+            renderReferenceTray();
+            state.refs.classList.toggle("h3rp-open");
+        }, "reference");
+        refsButton.addEventListener("pointerdown", rememberPromptSelection);
+        refsButton.dataset.h3rpLock = "";
+        const dialogue = button("Dialogue", "Wrap selected text in <d> tags", () => {
+            const selection = globalThis.getSelection?.();
+            const selected = selection?.rangeCount ? selection.toString() : "";
+            insertDecoratedText(`<d>${selected}</d>`);
+        }, "dialogue");
+        dialogue.dataset.h3rpLock = "";
+        const presentation = button(
+            state.decorated ? "Rich text" : "Plain text",
+            state.decorated
+                ? "Show the same prompt as plain text"
+                : "Color H3 sections, references, speakers, flow markers, and dialogue tags",
+            () => {
+                const text = editorPlainText(state.editor);
+                const caret = selectionTextOffset(state.editor);
+                state.decorated = !state.decorated;
+                persistView();
+                renderEditorText(text, caret);
+                state.editor.focus();
+            },
+        );
+        presentation.classList.toggle("h3rp-presentation-active", state.decorated);
+        presentation.dataset.h3rpLock = "";
+        const guide = element("select", "h3rp-guide");
+        guide.title = "Prompt Guide used by one-click optimization";
+        guide.dataset.h3rpLock = "";
+        for (const item of RICH_PROMPT_GUIDES) {
+            const option = element("option", "", item.label);
+            option.value = item.id;
+            guide.append(option);
+        }
+        guide.value = state.guide;
+        guide.addEventListener("change", () => { state.guide = normalizeRichGuide(guide.value); persistView(); });
+        const optimize = button("Optimize", "Optimize with the globally configured prompt backend.", () => void optimizePrompt(), "sparkle");
+        optimize.classList.add("h3rp-optimize");
+        const stop = button("Stop", "Cancel prompt optimization", stopOptimizer, "stop");
+        stop.classList.add("h3rp-stop");
+        stop.hidden = true;
+        const applyPending = button("Apply changed result", "Explicitly replace a scene that changed while optimization was running", applyPendingOptimizerResult, "sparkle");
+        applyPending.classList.add("h3rp-apply-pending");
+        applyPending.hidden = true;
+        const optimizerStatus = element("span", "h3rp-status");
+        state.optimizerStatus = optimizerStatus;
+        toolbar.replaceChildren(
+            refsButton, dialogue, presentation, guide,
+            optimize, stop, applyPending, optimizerStatus,
+        );
+
+        const refs = element("div", "h3rp-ref-tray");
+        state.refs = refs;
+        const editorShell = element("div", "h3rp-editor-shell");
+        const editor = element("div", "h3rp-editor");
+        editor.contentEditable = "true";
+        editor.spellcheck = true;
+        editor.tabIndex = 0;
+        editor.setAttribute("role", "textbox");
+        editor.setAttribute("aria-multiline", "true");
+        editor.dataset.placeholder = "Write this scene's action, camera, performance, dialogue, sound, and ending continuity…";
+        state.editor = editor;
+        const initialPrompt = promptValueToText(
+            shot.prompt, `Scene ${state.active + 1} prompt`,
+        );
+        state.promptUndo = promptUndoForScene(shotId, initialPrompt);
+        renderEditorText(initialPrompt);
+        state.promptSelection = {
+            start:initialPrompt.length, end:initialPrompt.length,
+        };
+        editor.addEventListener("input", (event) => {
+            saveEditorInput(event);
+            state.completion?.refresh();
+            schedulePromptAnalysis();
+        });
+        for (const eventName of ["focus", "pointerup", "keyup"]) {
+            editor.addEventListener(eventName, rememberPromptSelection);
+        }
+        editor.addEventListener("beforeinput", (event) => {
+            if (event.inputType === "insertParagraph" || event.inputType === "insertLineBreak") {
+                event.preventDefault(); insertPlainText(editor, "\n");
+            }
+        });
+        editor.addEventListener("paste", (event) => {
+            event.preventDefault(); insertPlainText(editor, event.clipboardData?.getData("text/plain") ?? "");
+            // Decorate pasted tokens now, retaining the existing text-level
+            // undo transaction and routing the save through the input handler.
+            renderEditorText(editorPlainText(editor, {trimFinalNewline:false}), selectionTextOffset(editor));
+            state.completion?.refresh();
+        });
+        editor.addEventListener("copy", (event) => copyEditorSelection(editor, event));
+        editor.addEventListener("cut", (event) => copyEditorSelection(editor, event, true));
+        const applyPromptUndo = (direction) => {
+            const text = state.promptUndo?.[direction]?.();
+            if (text == null) return false;
+            const scrollTop = editor.scrollTop;
+            const scrollLeft = editor.scrollLeft;
+            const caret = selectionTextOffset(editor);
+            renderEditorText(text, Math.min(caret, text.length));
+            shot.prompt = promptTextToLines(text);
+            writePlan(direction === "undo" ? "Undo saved to Plan" : "Redo saved to Plan");
+            scheduleHistoryDraft(shotId, text);
+            state.schema?.refresh();
+            editor.focus({preventScroll:true});
+            editor.scrollTop = scrollTop;
+            editor.scrollLeft = scrollLeft;
+            return true;
+        };
+        state.ownsPromptHistoryTarget = (target) => editor === target || editor.contains(target);
+        state.applyPromptHistoryShortcut = applyPromptUndo;
+        editor.addEventListener("keydown", (event) => {
+            if (state.completion?.handleKeydown(event)) return;
+            const undoDirection = promptUndoDirection(event);
+            if (undoDirection) {
+                event.preventDefault();
+                applyPromptUndo(undoDirection);
+            } else if (event.altKey && event.key === "ArrowLeft") event.preventDefault(), navigate(-1);
+            else if (event.altKey && event.key === "ArrowRight") event.preventDefault(), navigate(1);
+            else if (event.key === "Escape") refs.classList.remove("h3rp-open");
+        });
+        editor.addEventListener("blur", () => {
+            flushPlanEffects();
+            flushPromptAnalysis();
+            const text = editorPlainText(editor);
+            renderEditorText(text);
+        });
+        editorShell.append(editor);
+
+        const replacePromptText = (result, message = "H3 edit saved to Plan") => {
+            const text = String(result.text ?? "");
+            if (state.referenceMode === "tagged") {
+                const refreshed = availableReferenceRecords(
+                    node, state.active + 1, {
+                        includeInactive:true,
+                        prompt:[sharedPrompt(state.plan).text.trim(), text.trim()]
+                            .filter(Boolean).join("\n\n"),
+                    },
+                );
+                state.records = refreshed.records;
+                state.referenceMode = refreshed.mode;
+            }
+            state.promptUndo?.record(text, {inputType:"insertReplacementText"});
+            shot.prompt = promptTextToLines(text);
+            renderEditorText(text, result.caret, result);
+            writePlan(message);
+            scheduleHistoryDraft(shotId, text);
+            state.schema?.refresh();
+            editor.focus();
+        };
+
+        state.schema = createH3PromptSchemaController({
+            node,
+            propertyPrefix:"h3_rich_scene_prompt_editor",
+            getText:() => editorPlainText(editor),
+            replaceText:replacePromptText,
+            focusAt:(caret) => {
+                const text = editorPlainText(editor);
+                const position = Math.max(0, Math.min(text.length, Number(caret) || 0));
+                renderEditorText(text, position);
+                editor.focus();
+            },
+            getRecords:() => state.records,
+            defaultDuration:Number(shot.duration_seconds)
+                || Number(shot.length) / 24 || 6,
+            defaultMode:["tagged", "scheduled", "native"].includes(state.referenceMode)
+                ? "ref2va"
+                : state.referenceMode === "native_keyframes"
+                  ? state.records.filter((record) => record.active && record.kind === "picture").length >= 2
+                    ? "fl2va" : "i2va"
+                  : "auto",
+            scopeKey:shotId,
+            markDirty:dirty,
+        });
+        if (state.schema) toolbar.prepend(state.schema.modeSelect, state.schema.toggle);
+
+        state.completion = createPromptCompletionController({
+            input:editor,
+            maxItems:40,
+            getText:() => editorPlainText(editor),
+            getCaret:() => selectionTextOffset(editor),
+            getRecords:() => state.records,
+            getReferenceMode:() => state.referenceMode,
+            getMode:() => state.schema?.getMode() ?? "auto",
+            getAutomaticSuggestions:() => promptEditorPreferences().automaticSuggestions,
+            getAppendCompletionSpace:() => promptEditorPreferences().appendCompletionSpace,
+            getMarkerReplacement:() => promptEditorPreferences().markerReplacement,
+            replaceText:(result) => replacePromptText(result, "Completion saved to Plan"),
+        });
+        bindPromptMarkerInteractions({
+            input:editor, completion:state.completion,
+            getText:() => editorPlainText(state.editor),
+            getCaret:() => selectionTextOffset(editor),
+            readFragment:(fragment) => editorPlainText(fragment, {trimFinalNewline:false}),
+            restoreCaret:(position) => restoreCaret(editor, position),
+            getEnabled:() => promptEditorPreferences().markerReplacement,
+            getRecords:() => state.records,
+            beforeOpen:() => hidePopover(true),
+        });
+
+        const footer = element("div", "h3rp-footer");
+        const identity = element("span", "", `Scene ${state.active + 1}/${state.plan.shots.length} · ${shotId}`);
+        const historyHost = element("div", "h3rp-history");
+        const status = element("span", "h3rp-footer-status", "Synchronized with Plan");
+        footer.append(identity, historyHost, status);
+        state.history.host = historyHost;
+        state.status = status;
+
+        const completionHint = element(
+            "span", "h3rp-muted",
+            "Type @, #, <, or [; use ( for speakers · Ctrl/Cmd+Space for all H3 completions",
+        );
+        toolbar.append(completionHint);
+        if (state.schema) identity.append(document.createTextNode(" · "), state.schema.counts);
+        root.append(head, nav, toolbar);
+        if (state.schema) root.append(state.schema.panel);
+        root.append(refs, editorShell, footer);
+        refreshOptimizerUi();
+        void loadHistory(shotId, editorPlainText(editor));
+    }
+
+    function loadPlan(force = false) {
+        if (state.disposed) return;
+        const planNode = upstreamPlanNode(node);
+        const planWidget = planNode?.widgets?.find((item) => item.name === "plan_json");
+        if (!planNode || !planWidget) {
+            if (force || state.planNode) {
+                state.plan = null; state.planNode = null; state.planWidget = null;
+                state.lastValue = ""; state.lastRunName = "";
+                showFailure("No connected H3 Chain Plan was found.");
+            }
+            return;
+        }
+        const value = String(planWidget.value ?? "");
+        const runName = String(planNode.widgets?.find((item) => item.name === "run_name")?.value ?? "").trim();
+        if (!force && planNode === state.planNode && value === state.lastValue && runName === state.lastRunName) return;
+        try {
+            const previousPlan = state.plan;
+            const previousActive = state.active;
+            const nextPlan = parsePlanJson(value);
+            state.active = activeSceneIndexAfterRefresh(
+                previousPlan, nextPlan, previousActive,
+            );
+            node.properties[ACTIVE_PROPERTY] = state.active;
+            state.plan = nextPlan;
+            state.planNode = planNode;
+            state.planWidget = planWidget;
+            state.lastValue = value;
+            state.lastRunName = runName;
+            render();
+        } catch (error) {
+            showFailure(`Connected Plan JSON is invalid:\n${error.message}`);
+        }
+    }
+
+    state.optimizer.client = new PromptAssistantClient({
+        identityKey:promptAssistantIdentityKey(node),
+        onFrame:handleOptimizerFrame,
+        onStatus:(status, detail) => {
+            if (detail?.providers) {
+                state.optimizer.providers = detail.providers;
+            }
+            if (status === "disconnected" && state.optimizer.requestId
+                    && state.optimizer.activeBackend === "mcp") {
+                state.optimizer.error = "Prompt-agent bridge disconnected.";
+                state.optimizer.requestId = null;
+                state.optimizer.meta = null;
+                state.optimizer.activeBackend = null;
+            }
+            refreshOptimizerUi();
+        },
+    });
+    const onOptimizerSettingsChanged = () => refreshOptimizerUi();
+    globalThis.addEventListener?.("h3-prompt-optimizer-settings-changed", onOptimizerSettingsChanged);
+
+    const widget = node.addDOMWidget("h3_rich_scene_prompt_editor", "h3-rich-scene-prompt-editor", root,
+        {serialize:false, hideOnZoom:false, getMinHeight:() => 560});
+    widget.serialize = false;
+    node.setSize?.([Math.max(Number(node.size?.[0]) || 780, 780), Math.max(Number(node.size?.[1]) || 760, 760)]);
+
+    const connectionsChanged = node.onConnectionsChange;
+    node.onConnectionsChange = function () {
+        const result = connectionsChanged?.apply(this, arguments);
+        setTimeout(() => loadPlan(true), 0);
+        return result;
+    };
+    const onPromptExecuted = (event) => {
+        const values = event.detail?.output?.h3_chain_active_scene;
+        const scene = Array.isArray(values) ? values.at(-1) : null;
+        if (!scene || String(scene.run_name ?? "") !== planRunName()) return;
+        const shot = state.plan?.shots?.[state.active];
+        const shotId = String(shot?.id ?? "");
+        if (!shotId || String(scene.shot_id ?? "") !== shotId) return;
+        window.setTimeout(() => {
+            if (state.history.sceneKey === historySceneKey(planRunName(), shotId)) {
+                void loadHistory(shotId, promptValueToText(shot.prompt), false);
+            }
+        }, 50);
+    };
+    api.addEventListener("executed", onPromptExecuted);
+    const onProjectAssetCatalogChanged = (event) => {
+        const changedProject = String(event?.detail?.project ?? "").trim();
+        const currentProject = planRunName();
+        if (changedProject && currentProject && changedProject !== currentProject) return;
+        if (!state.plan?.shots?.length || !state.editor) return;
+        const prompt = editorPlainText(state.editor);
+        const selection = document.activeElement === state.editor
+            ? editorSelectionOffsets(state.editor) : null;
+        refreshReferenceState(prompt);
+        renderEditorText(prompt, null, selection ? {
+            selectionStart:selection.start,
+            selectionEnd:selection.end,
+        } : null);
+        if (state.refs?.classList.contains("h3rp-open")) renderReferenceTray();
+        state.completion?.refresh();
+        state.schema?.refresh();
+    };
+    globalThis.addEventListener?.(
+        PROJECT_ASSET_CATALOG_CHANGED_EVENT, onProjectAssetCatalogChanged,
+    );
+
+    const removed = node.onRemoved;
+    node.onRemoved = function () {
+        // Closing a workflow removes many nodes while ComfyUI is also saving
+        // its tab session. Never propagate Plan callbacks, analyze prompts, or
+        // start history requests from teardown: the edited Plan JSON was
+        // already assigned synchronously by writePlan().
+        state.disposed = true;
+        const cleanups = [
+            () => {
+                if (state.planSyncTimer != null) window.clearTimeout(state.planSyncTimer);
+                state.planSyncTimer = null;
+                state.planSyncPending = null;
+                if (state.analysisTimer != null) window.clearTimeout(state.analysisTimer);
+                state.analysisTimer = null;
+                if (state.history.saveTimer != null) window.clearTimeout(state.history.saveTimer);
+                state.history.saveTimer = null;
+                state.history.pendingDraft = null;
+                state.history.loadToken += 1;
+                state.history.host = null;
+            },
+            () => { if (state.pollTimer != null) window.clearInterval(state.pollTimer); },
+            () => { if (state.popoverTimer != null) window.clearTimeout(state.popoverTimer); },
+            () => hidePopover(true),
+            () => state.popover?.remove(),
+            () => state.completion?.destroy(),
+            () => api.removeEventListener("executed", onPromptExecuted),
+            () => globalThis.removeEventListener?.(
+                PROJECT_ASSET_CATALOG_CHANGED_EVENT, onProjectAssetCatalogChanged,
+            ),
+            () => state.optimizer.client?.close(),
+            () => state.optimizer.abortController?.abort(),
+            () => globalThis.removeEventListener?.(
+                "h3-prompt-optimizer-settings-changed", onOptimizerSettingsChanged,
+            ),
+        ];
+        for (const cleanup of cleanups) {
+            try { cleanup(); }
+            catch (error) { console.warn("H3 Rich Prompt Editor cleanup failed", error); }
+        }
+        state.completion = null;
+        delete node._h3PromptCompanionSetActiveScene;
+        delete node._h3PromptCompanionSetScenePrompt;
+        return removed?.apply(this, arguments);
+    };
+    node._h3PromptCompanionSetActiveScene = (planNode, index) => {
+        if (planNode !== state.planNode || !state.plan?.shots?.length || optimizerBusy()) return false;
+        navigate(0, index, {synchronize:false, focus:false});
+        return true;
+    };
+    node._h3PromptCompanionSetScenePrompt = (planNode, index, text) => {
+        if (planNode !== state.planNode || !state.plan?.shots?.[index]) return false;
+        const liveValue = String(state.planWidget?.value ?? "");
+        let livePlanParsed = false;
+        try {
+            const livePlan = parsePlanJson(liveValue);
+            livePlanParsed = true;
+            if (planHasNonPromptChanges(state.plan, livePlan)) {
+                loadPlan(true);
+                return true;
+            }
+        } catch (_error) {
+            // Leave lastValue untouched so normal polling reports invalid JSON.
+        }
+        state.plan.shots[index].prompt = promptTextToLines(text);
+        const shotId = String(
+            state.plan.shots[index].id
+            || `clip_${String(index + 1).padStart(4, "0")}`,
+        );
+        const promptUndo = promptUndoForScene(shotId, text, {external:true});
+        if (index === state.active) state.promptUndo = promptUndo;
+        if (index === state.active && state.editor) {
+            const current = editorPlainText(state.editor);
+            if (current !== text) {
+                const caret = document.activeElement === state.editor
+                    ? selectionTextOffset(state.editor) : null;
+                renderEditorText(text, caret == null ? null : Math.min(caret, text.length));
+                scheduleHistoryDraft(
+                    String(state.plan.shots[index].id || `clip_${String(index + 1).padStart(4, "0")}`),
+                    text);
+                state.schema?.refresh();
+            }
+        }
+        if (livePlanParsed) state.lastValue = liveValue;
+        return true;
+    };
+    node._h3RichPromptRefresh = () => loadPlan(true);
+    state.pollTimer = window.setInterval(() => loadPlan(false), 500);
+    loadPlan(true);
+}
+
+app.registerExtension({
+    name:"minimax_h3_context_loop.rich_scene_prompt_editor",
+    async beforeRegisterNodeDef(nodeTypeDefinition, nodeData) {
+        if (nodeData.name !== NODE_NAME) return;
+        const created = nodeTypeDefinition.prototype.onNodeCreated;
+        nodeTypeDefinition.prototype.onNodeCreated = function () {
+            const result = created?.apply(this, arguments);
+            setTimeout(() => mount(this), 0);
+            return result;
+        };
+    },
+    async nodeCreated(node) {
+        if (nodeType(node) === NODE_NAME) mount(node);
+    },
+    async afterConfigureGraph() {
+        for (const node of allNodes(app.graph)) {
+            if (nodeType(node) === NODE_NAME) setTimeout(() => node._h3RichPromptRefresh?.(), 0);
+        }
+    },
+});
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_run_manager.js b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_run_manager.js
new file mode 100644
index 0000000000000000000000000000000000000000..d23ff315a4c55f035fb495e1ec62a5d89eee240d
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_run_manager.js
@@ -0,0 +1,801 @@
+import {app} from "/scripts/app.js";
+import {api} from "/scripts/api.js";
+import {
+    ASSET_ROLES,
+    MAX_ASSET_BINDINGS,
+    applyAssetBinding,
+    assetInputNumber,
+    collectAssetBindings,
+    nodeType,
+} from "./h3_run_assets_core.mjs?v=0.6.2";
+import {
+    runArchiveOptionLabel,
+    runManagerIdentity,
+} from "./h3_run_manager_core.mjs?v=0.6.2";
+import {
+    refreshRestoredPlanEditors,
+    restoreConnectedPolicyInputs,
+} from "./h3_plan_restore_core.mjs?v=0.6.6";
+
+const NODE_NAME = "MiniMaxH3ChainRunManager";
+const PLAN_NAME = "MiniMaxH3ChainPlan";
+const PLAN_NAMES = new Set([PLAN_NAME, "MiniMaxH3ChainPlanModern"]);
+const ASSET_WIDGETS = [
+    "archive_images", "archive_audio", "archive_video", "asset_bindings_json",
+];
+
+function upstreamPlanNode(start) {
+    const queue = [start];
+    const seen = new Set();
+    while (queue.length) {
+        const node = queue.shift();
+        if (!node || seen.has(node)) continue;
+        seen.add(node);
+        if (node !== start && PLAN_NAMES.has(nodeType(node))) return node;
+        for (const input of node.inputs ?? []) {
+            if (input.link == null) continue;
+            const link = node.graph?.links?.[input.link];
+            const parent = link ? node.graph?.getNodeById?.(link.origin_id) : null;
+            if (parent) queue.push(parent);
+        }
+    }
+    return null;
+}
+
+function widgetByName(node, name) {
+    return node?.widgets?.find((item) => item.name === name);
+}
+
+function element(tag, className = "", text = undefined) {
+    const item = document.createElement(tag);
+    if (className) item.className = className;
+    if (text !== undefined) item.textContent = text;
+    return item;
+}
+
+function button(label, title, action) {
+    const item = element("button", "", label);
+    item.type = "button";
+    item.title = title;
+    item.addEventListener("click", action);
+    return item;
+}
+
+function injectStyles() {
+    if (document.getElementById("h3-run-manager-style")) return;
+    const style = document.createElement("style");
+    style.id = "h3-run-manager-style";
+    style.textContent = `
+        .h3rm-root { --h3rm-bg:color-mix(in srgb,var(--comfy-menu-bg,#202124) 91%,#111827);
+            --h3rm-panel:var(--comfy-input-bg,#15171d); --h3rm-border:var(--border-color,#586174);
+            --h3rm-text:var(--input-text,#eceef5); --h3rm-muted:color-mix(in srgb,var(--h3rm-text) 58%,transparent);
+            box-sizing:border-box; width:100%; height:100%; min-height:210px; display:flex;
+            flex-direction:column; gap:9px; overflow:auto; padding:10px; border:1px solid var(--h3rm-border);
+            border-radius:8px; background:var(--h3rm-bg); color:var(--h3rm-text);
+            font:12px/1.4 system-ui,sans-serif; }
+        .h3rm-root *, .h3rm-root *::before, .h3rm-root *::after { box-sizing:border-box; }
+        .h3rm-title { font-size:15px; font-weight:750; }
+        .h3rm-identity { display:grid; grid-template-columns:1fr 1fr; gap:6px; }
+        .h3rm-identity > span { min-width:0; padding:5px 7px; border:1px solid var(--h3rm-border);
+            border-radius:5px; overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+        .h3rm-identity-active { color:#b8d2ff; }
+        .h3rm-identity-selected { color:var(--h3rm-muted); }
+        .h3rm-identity-selected.h3rm-same { color:#a8e6b1; border-color:#4d8a58; }
+        .h3rm-section { padding:8px; border:1px solid color-mix(in srgb,var(--h3rm-border) 72%,transparent);
+            border-radius:6px; background:var(--h3rm-panel); }
+        .h3rm-section-title { display:flex; justify-content:space-between; align-items:center;
+            gap:8px; margin-bottom:6px; font-weight:700; }
+        .h3rm-policy { display:flex; flex-wrap:wrap; gap:8px; color:var(--h3rm-muted); font-weight:400; }
+        .h3rm-policy label { display:inline-flex; align-items:center; gap:4px; }
+        .h3rm-policy input { margin:0; }
+        .h3rm-assets { display:flex; flex-direction:column; gap:5px; }
+        .h3rm-asset { display:grid; grid-template-columns:minmax(120px,1fr) 125px;
+            align-items:center; gap:6px; min-width:0; }
+        .h3rm-asset-main { min-width:0; overflow:hidden; text-overflow:ellipsis;
+            white-space:nowrap; }
+        .h3rm-asset-path { display:block; color:var(--h3rm-muted); font-size:11px;
+            overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+        .h3rm-asset select { min-width:0; width:100%; padding:4px; border:1px solid var(--h3rm-border);
+            border-radius:5px; background:var(--h3rm-bg); color:var(--h3rm-text); }
+        .h3rm-empty { color:var(--h3rm-muted); }
+        .h3rm-select { width:100%; min-width:0; padding:7px 8px; border:1px solid var(--h3rm-border);
+            border-radius:6px; background:var(--h3rm-panel); color:var(--h3rm-text); }
+        .h3rm-details { min-height:48px; padding:8px; border:1px solid color-mix(in srgb,var(--h3rm-border) 72%,transparent);
+            border-radius:6px; background:var(--h3rm-panel); color:var(--h3rm-muted);
+            white-space:pre-wrap; overflow-wrap:anywhere; }
+        .h3rm-actions { display:flex; align-items:center; gap:6px; flex-wrap:wrap; }
+        .h3rm-actions button { padding:6px 9px; border:1px solid var(--h3rm-border); border-radius:6px;
+            background:var(--h3rm-panel); color:var(--h3rm-text); cursor:pointer; }
+        .h3rm-actions button:hover { border-color:#7fa8ff; }
+        .h3rm-actions button:disabled { cursor:not-allowed; opacity:.45; }
+        .h3rm-load { font-weight:700; border-color:#6d91d8 !important; }
+        .h3rm-status { min-width:0; flex:1 1 170px; color:var(--h3rm-muted); text-align:right;
+            white-space:pre-wrap; overflow-wrap:anywhere; }
+        .h3rm-error { color:#ffb3b3; }
+    `;
+    document.head.appendChild(style);
+}
+
+function formatBytes(value) {
+    const bytes = Number(value);
+    if (!Number.isFinite(bytes) || bytes < 1) return "0 KB";
+    if (bytes < 1024 * 1024) return `${Math.max(1, Math.round(bytes / 1024))} KB`;
+    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+
+function collapseWidget(widget) {
+    if (!widget) return;
+    widget._h3OriginalType ??= widget.type;
+    widget._h3OriginalComputeSize ??= widget.computeSize;
+    widget._h3OriginalDraw ??= widget.draw;
+    widget.hidden = true;
+    widget.type = "hidden";
+    widget.computeSize = () => [0, -4];
+    // Some ComfyUI canvas/front-end combinations still invoke draw() for a
+    // widget after its type and geometry have been collapsed. Keep the value
+    // serializable, but make the internal archive state visually inert.
+    widget.draw = () => {};
+    for (const item of new Set([widget.inputEl, widget.element])) {
+        if (!item?.style) continue;
+        item.style.setProperty("display", "none", "important");
+        item.style.setProperty("pointer-events", "none", "important");
+        item.setAttribute?.("aria-hidden", "true");
+    }
+    if (widget.element && widget.id && typeof widget.onRemove === "function") {
+        widget.onRemove();
+    }
+}
+
+function removeLegacyStatusOutput(node) {
+    const index = node.outputs?.findIndex((output) => output.name === "asset_status") ?? -1;
+    if (index >= 0) node.removeOutput?.(index);
+}
+
+function stabilizeAssetInputs(node) {
+    const connected = (node.inputs ?? []).filter((input) =>
+        assetInputNumber(input) != null && input.link != null);
+    const used = new Set(connected.map((input) => assetInputNumber(input)));
+    let next = 0;
+    while (used.has(next) && next < MAX_ASSET_BINDINGS) next += 1;
+    for (let index = (node.inputs?.length ?? 0) - 1; index >= 0; index -= 1) {
+        const input = node.inputs[index];
+        const number = assetInputNumber(input);
+        if (number != null && input.link == null && number !== next) {
+            node.removeInput(index);
+        }
+    }
+    if (next < MAX_ASSET_BINDINGS
+            && !node.inputs?.some((input) => input.name === `asset_${next}`)) {
+        node.addInput(`asset_${next}`, "*");
+    }
+    const empty = node.inputs?.find((input) =>
+        assetInputNumber(input) === next && input.link == null);
+    if (empty) empty.label = "Connect loader asset";
+    node.graph?.setDirtyCanvas?.(true, true);
+}
+
+function localTime(value) {
+    const date = new Date(value);
+    return Number.isFinite(date.getTime()) ? date.toLocaleString() : "unknown time";
+}
+
+async function jsonRequest(path) {
+    const response = await api.fetchApi(path);
+    let payload = {};
+    try {
+        payload = await response.json();
+    } catch (_error) {
+        // Preserve a useful HTTP error when a proxy emits a non-JSON body.
+    }
+    if (!response.ok) throw new Error(payload.error || `HTTP ${response.status}`);
+    return payload;
+}
+
+function applyPlanInputs(planNode, inputs, policyInputs = {}) {
+    if (!planNode) throw new Error("Connect this Run Manager to the active H3 Chain Plan.");
+    if (!inputs || typeof inputs !== "object") throw new Error("The saved run has no Plan inputs.");
+    const names = Object.keys(inputs).sort((left, right) =>
+        Number(left === "plan_json") - Number(right === "plan_json"));
+    const applied = [];
+    const unavailable = [];
+    const graph = planNode.graph;
+    if (!graph || graph.getNodeById?.(planNode.id) !== planNode) {
+        throw new Error("The target Plan is no longer in its workflow.");
+    }
+    graph?.beforeChange?.();
+    try {
+        for (const name of names) {
+            const widget = widgetByName(planNode, name);
+            if (!widget) {
+                unavailable.push(name);
+                continue;
+            }
+            widget.value = inputs[name];
+            widget.callback?.(inputs[name]);
+            applied.push(name);
+        }
+    } finally {
+        graph?.afterChange?.();
+    }
+    if (!applied.includes("plan_json")) {
+        throw new Error("The connected Plan does not expose an editable plan_json widget.");
+    }
+    const policies = restoreConnectedPolicyInputs(
+        planNode, policyInputs, inputs);
+    refreshRestoredPlanEditors(planNode);
+    graph.setDirtyCanvas?.(true, true);
+    return {applied, unavailable, policies};
+}
+
+function mount(node) {
+    if (node._h3RunManagerMounted || typeof node.addDOMWidget !== "function") return;
+    node._h3RunManagerMounted = true;
+    injectStyles();
+    removeLegacyStatusOutput(node);
+
+    const root = element("div", "h3rm-root");
+    for (const eventName of [
+        "pointerdown", "pointerup", "mousedown", "mouseup", "click", "dblclick",
+    ]) root.addEventListener(eventName, (event) => event.stopPropagation());
+    root.addEventListener("wheel", (event) => event.stopPropagation());
+
+    for (const name of ASSET_WIDGETS) collapseWidget(widgetByName(node, name));
+    const state = {
+        runs: [], selected: "", busy: false, bindings: [], watchedSources: new Set(),
+        watchedPlanWidget: null,
+        disposed: false, restoreEpoch: 0,
+    };
+    const title = element("div", "h3rm-title", "H3 Run Manager");
+    const identity = element("div", "h3rm-identity");
+    const activeIdentity = element("span", "h3rm-identity-active");
+    const selectedIdentity = element("span", "h3rm-identity-selected");
+    identity.append(activeIdentity, selectedIdentity);
+    const select = element("select", "h3rm-select");
+    select.title = "Saved projects discovered under the ComfyUI host's output/h3_chains folder.";
+    const details = element("div", "h3rm-details", "Loading saved runs…");
+    const assetSection = element("div", "h3rm-section");
+    const assetHeader = element("div", "h3rm-section-title");
+    const assetTitle = element("span", "", "Reference assets");
+    const assetList = element("div", "h3rm-assets");
+    const policies = element("div", "h3rm-policy");
+    const actions = element("div", "h3rm-actions");
+    const status = element("span", "h3rm-status");
+
+    function policyCheckbox(widgetName, label) {
+        const wrap = element("label");
+        const control = element("input");
+        control.type = "checkbox";
+        const widget = widgetByName(node, widgetName);
+        control.checked = Boolean(widget?.value);
+        control.addEventListener("change", () => {
+            if (widget) {
+                widget.value = control.checked;
+                widget.callback?.(control.checked);
+            }
+            node.graph?.setDirtyCanvas?.(true, true);
+        });
+        wrap.append(control, document.createTextNode(label));
+        return wrap;
+    }
+
+    policies.append(
+        policyCheckbox("archive_images", "Archive images"),
+        policyCheckbox("archive_audio", "Archive audio"),
+        policyCheckbox("archive_video", "Archive video"),
+    );
+    assetHeader.append(assetTitle, policies);
+
+    function activeRunName() {
+        const planNode = upstreamPlanNode(node);
+        return String(widgetByName(planNode, "run_name")?.value ?? "").trim();
+    }
+
+    const activeRunChanged = () => {
+        state.restoreEpoch += 1;
+        const defer = window.queueMicrotask ?? ((callback) => window.setTimeout(callback, 0));
+        defer(() => { if (!state.disposed) renderSelection(); });
+    };
+
+    function updatePlanWatch() {
+        const planWidget = widgetByName(upstreamPlanNode(node), "run_name") ?? null;
+        if (state.watchedPlanWidget === planWidget) return;
+        state.watchedPlanWidget?._h3RunManagerWatchers?.delete(activeRunChanged);
+        state.watchedPlanWidget = planWidget;
+        if (!planWidget) return;
+        planWidget._h3RunManagerWatchers ??= new Set();
+        if (!planWidget._h3RunManagerWatchWrapped) {
+            planWidget._h3RunManagerWatchWrapped = true;
+            const changed = planWidget.callback;
+            planWidget.callback = function () {
+                const result = changed?.apply(this, arguments);
+                for (const listener of this._h3RunManagerWatchers ?? []) listener();
+                return result;
+            };
+        }
+        planWidget._h3RunManagerWatchers.add(activeRunChanged);
+    }
+
+    function renderActiveRun() {
+        updatePlanWatch();
+        const runName = activeRunName();
+        assetTitle.textContent = runName
+            ? `Reference assets → ${runName}`
+            : "Reference assets → no active run_name";
+        assetTitle.title = runName
+            ? `Save/update assets writes to the connected Plan run “${runName}”.`
+            : "Set run_name on the connected Plan before saving assets.";
+    }
+
+    function writeBindingsWidget() {
+        const widget = widgetByName(node, "asset_bindings_json");
+        if (!widget) return;
+        const value = JSON.stringify(state.bindings);
+        if (widget.value === value) return;
+        widget.value = value;
+        widget.callback?.(value);
+        node.graph?.setDirtyCanvas?.(true, true);
+    }
+
+    const sourceChanged = () => {
+        const defer = window.queueMicrotask ?? ((callback) => window.setTimeout(callback, 0));
+        defer(() => { if (!state.disposed) syncAssetBindings(); });
+    };
+
+    function updateSourceWatches() {
+        const current = new Set();
+        for (const input of node.inputs ?? []) {
+            if (assetInputNumber(input) == null || input.link == null) continue;
+            const link = node.graph?.links?.[input.link];
+            const source = link ? node.graph?.getNodeById?.(link.origin_id) : null;
+            if (!source) continue;
+            current.add(source);
+            source._h3AssetWatchers ??= new Set();
+            if (!source._h3AssetWatchWrapped) {
+                source._h3AssetWatchWrapped = true;
+                const changed = source.onWidgetChanged;
+                source.onWidgetChanged = function () {
+                    const result = changed?.apply(this, arguments);
+                    for (const listener of this._h3AssetWatchers ?? []) listener();
+                    return result;
+                };
+            }
+            source._h3AssetWatchers.add(sourceChanged);
+        }
+        for (const binding of state.bindings) {
+            const source = node.graph?.getNodeById?.(binding.node_id)
+                ?? node.graph?.getNodeById?.(Number(binding.node_id));
+            if (!source || current.has(source)) continue;
+            current.add(source);
+            source._h3AssetWatchers ??= new Set();
+            if (!source._h3AssetWatchWrapped) {
+                source._h3AssetWatchWrapped = true;
+                const changed = source.onWidgetChanged;
+                source.onWidgetChanged = function () {
+                    const result = changed?.apply(this, arguments);
+                    for (const listener of this._h3AssetWatchers ?? []) listener();
+                    return result;
+                };
+            }
+            source._h3AssetWatchers.add(sourceChanged);
+        }
+        for (const source of state.watchedSources) {
+            if (!current.has(source)) source._h3AssetWatchers?.delete(sourceChanged);
+        }
+        state.watchedSources = current;
+    }
+
+    function renderAssetBindings() {
+        assetList.replaceChildren();
+        if (!state.bindings.length) {
+            assetList.append(element(
+                "div", "h3rm-empty",
+                "Connect an image, video, or audio loader to the asset socket.",
+            ));
+            return;
+        }
+        for (const binding of state.bindings) {
+            const row = element("div", "h3rm-asset");
+            const main = element("div", "h3rm-asset-main", binding.label);
+            const path = element(
+                "span", "h3rm-asset-path",
+                binding.original_value || "No loader filename detected",
+            );
+            main.title = `${binding.node_type} #${binding.node_id}`;
+            path.title = binding.original_value || main.title;
+            main.append(path);
+            const role = element("select");
+            for (const [value, label] of ASSET_ROLES) {
+                const option = element("option", "", label);
+                option.value = value;
+                role.append(option);
+            }
+            role.value = binding.role;
+            role.addEventListener("change", () => {
+                node.properties ??= {};
+                node.properties.h3_asset_roles ??= {};
+                node.properties.h3_asset_roles[binding.binding_id] = role.value;
+                syncAssetBindings();
+            });
+            row.append(main, role);
+            assetList.append(row);
+        }
+    }
+
+    function syncAssetBindings() {
+        if (state.disposed) return;
+        state.bindings = collectAssetBindings(node);
+        updateSourceWatches();
+        writeBindingsWidget();
+        renderAssetBindings();
+    }
+
+    function selectedRun() {
+        return state.runs.find((item) => item.run_name === state.selected) ?? null;
+    }
+
+    function setBusy(value) {
+        if (state.disposed) return;
+        state.busy = Boolean(value);
+        select.disabled = state.busy;
+        refresh.disabled = state.busy;
+        load.disabled = state.busy || !selectedRun()?.restorable;
+        open.disabled = state.busy || !selectedRun();
+        saveAssets.disabled = state.busy || !state.bindings.length;
+    }
+
+    function renderSelection() {
+        if (state.disposed) return;
+        renderActiveRun();
+        const run = selectedRun();
+        const runIdentity = runManagerIdentity(activeRunName(), run);
+        activeIdentity.textContent = runIdentity.activeLabel;
+        activeIdentity.title = "Generation and asset saving use this run_name from the connected Plan.";
+        selectedIdentity.textContent = runIdentity.selectedLabel;
+        selectedIdentity.title = runIdentity.same
+            ? "The selected saved archive matches the connected Plan."
+            : "Selection alone does not change the Plan. Load the selected archive to apply it.";
+        selectedIdentity.classList.toggle("h3rm-same", runIdentity.same);
+        load.textContent = runIdentity.loadLabel;
+        saveAssets.textContent = "Save assets to active Plan";
+        saveAssets.title = runIdentity.saveLabel;
+        for (const option of select.options ?? []) {
+            const optionRun = state.runs.find(
+                (item) => item.run_name === option.value);
+            if (optionRun) option.textContent = runArchiveOptionLabel(
+                optionRun, runIdentity.active);
+        }
+        if (!run) {
+            details.textContent = state.runs.length
+                ? "Select a saved H3 run." : "No saved H3 runs were found.";
+            load.disabled = true;
+            open.disabled = true;
+            return;
+        }
+        const scenes = run.scene_count == null ? "unknown scenes" : `${run.scene_count} scenes`;
+        const source = Object.entries(run.sources ?? {}).filter(([, ready]) => ready)
+            .map(([name]) => name.replace("_", " ")).join(", ") || "no archive";
+        details.textContent =
+            `${scenes} · ${run.checkpoint_count} checkpoints · ${run.asset_count ?? 0} assets · ${formatBytes(run.archive_bytes)}\n` +
+            `Modified ${localTime(run.modified_at)} · ${source}`;
+        load.disabled = state.busy || !run.restorable;
+        open.disabled = state.busy;
+    }
+
+    async function refreshRuns(preferredRunName = "") {
+        setBusy(true);
+        status.className = "h3rm-status";
+        status.textContent = "Scanning host output…";
+        try {
+            const payload = await jsonRequest("/minimax_h3_context_loop/runs");
+            if (state.disposed) return;
+            const previous = state.selected;
+            state.runs = Array.isArray(payload.runs) ? payload.runs : [];
+            const active = activeRunName();
+            const candidates = [preferredRunName, previous, active];
+            state.selected = candidates.find((candidate) =>
+                candidate && state.runs.some((item) => item.run_name === candidate))
+                ?? state.runs.find((item) => item.restorable)?.run_name
+                ?? state.runs[0]?.run_name ?? "";
+            select.replaceChildren();
+            for (const run of state.runs) {
+                const option = element(
+                    "option", "", runArchiveOptionLabel(run, active));
+                option.value = run.run_name;
+                select.append(option);
+            }
+            select.value = state.selected;
+            status.textContent = `${state.runs.length} saved archive${state.runs.length === 1 ? "" : "s"}`;
+        } catch (error) {
+            state.runs = [];
+            state.selected = "";
+            select.replaceChildren();
+            status.className = "h3rm-status h3rm-error";
+            status.textContent = error?.message || String(error);
+        } finally {
+            setBusy(false);
+            renderSelection();
+        }
+    }
+
+    function captureRestoreOperation(planNode, run) {
+        return {
+            graph:node.graph, activeGraph:app.graph, planNode, run:run.run_name,
+            epoch:state.restoreEpoch,
+            planValues:JSON.stringify((planNode.widgets ?? []).map(
+                (widget) => [widget.name, widget.value],
+            )),
+        };
+    }
+
+    function requireCurrentRestore(operation) {
+        const graph = operation.graph;
+        if (state.disposed || state.restoreEpoch !== operation.epoch
+                || !graph || node.graph !== graph || app.graph !== operation.activeGraph
+                || graph.getNodeById?.(node.id) !== node
+                || graph.getNodeById?.(operation.planNode.id) !== operation.planNode
+                || upstreamPlanNode(node) !== operation.planNode
+                || selectedRun()?.run_name !== operation.run
+                || JSON.stringify((operation.planNode.widgets ?? []).map(
+                    (widget) => [widget.name, widget.value],
+                )) !== operation.planValues) {
+            throw new Error(
+                "Archive load cancelled: the workflow, connected Plan, or Run " +
+                "changed while loading. Select the intended archive and load it again.",
+            );
+        }
+    }
+
+    async function loadRun() {
+        const run = selectedRun();
+        const planNode = upstreamPlanNode(node);
+        if (!run || !planNode || state.busy || state.disposed) {
+            if (!planNode) {
+                status.className = "h3rm-status h3rm-error";
+                status.textContent = "Connect the active Plan first.";
+            }
+            return;
+        }
+        const current = String(widgetByName(planNode, "run_name")?.value ?? "").trim();
+        const assetNotice = run.asset_count
+            ? ` It will also attempt to restore ${run.asset_count} loader asset${run.asset_count === 1 ? "" : "s"}.`
+            : "";
+        const message = `Load saved run “${run.run_name}” into the connected Plan?\n\n` +
+            `This replaces all active scene prompts, archived Plan settings, and connected 0.5 policies${current ? ` from “${current}”` : ""}.${assetNotice}`;
+        if (!window.confirm(message)) return;
+        const operation = captureRestoreOperation(planNode, run);
+        setBusy(true);
+        status.className = "h3rm-status";
+        status.textContent = "Loading archive…";
+        try {
+            const query = new URLSearchParams({run_name: run.run_name});
+            const payload = await jsonRequest(`/minimax_h3_context_loop/run?${query}`);
+            // Never apply a delayed archive to a different tab, replacement
+            // node with the same ID, or Plan edited since the load began.
+            requireCurrentRestore(operation);
+            const result = applyPlanInputs(
+                planNode, payload.plan_inputs, payload.policy_inputs);
+            const assetResults = [];
+            const graph = operation.graph;
+            graph?.beforeChange?.();
+            try {
+                for (const binding of payload.assets?.bindings ?? []) {
+                    assetResults.push(applyAssetBinding(graph, binding));
+                }
+            } finally {
+                graph?.afterChange?.();
+            }
+            const assetFailures = assetResults.filter((item) => !item.applied);
+            const assetApplied = assetResults.length - assetFailures.length;
+            const warning = [
+                ...(payload.warnings ?? []),
+                ...(result.unavailable.length
+                    ? [`Unavailable current widgets: ${result.unavailable.join(", ")}`] : []),
+                ...(result.policies.unavailable.length
+                    ? [`Unavailable 0.5 policies: ${result.policies.unavailable.join(", ")}`] : []),
+                ...assetFailures.map((item) =>
+                    `${item.binding?.label ?? "Asset"}: ${item.reason.replaceAll("_", " ")}`),
+            ];
+            status.className = warning.length
+                ? "h3rm-status h3rm-error" : "h3rm-status";
+            status.textContent = warning.length
+                ? `Active Plan is now “${run.run_name}”: loaded ${payload.scene_count ?? "saved"} scenes and ${assetApplied} assets · ${warning.join(" · ")}`
+                : `Active Plan is now “${run.run_name}”: loaded ${payload.scene_count ?? "saved"} scenes and ${assetApplied} assets`;
+            syncAssetBindings();
+            renderSelection();
+            graph?.setDirtyCanvas?.(true, true);
+        } catch (error) {
+            status.className = "h3rm-status h3rm-error";
+            status.textContent = error?.message || String(error);
+        } finally {
+            setBusy(false);
+        }
+    }
+
+    async function openRunFolder() {
+        const run = selectedRun();
+        if (!run || state.busy) return;
+        setBusy(true);
+        status.className = "h3rm-status";
+        status.textContent = "Opening run folder…";
+        try {
+            const response = await api.fetchApi(
+                "/minimax_h3_context_loop/open-run-folder",
+                {
+                    method: "POST",
+                    headers: {"Content-Type": "application/json"},
+                    body: JSON.stringify({run_name: run.run_name}),
+                },
+            );
+            const payload = await response.json();
+            if (!response.ok) throw new Error(payload.error || `HTTP ${response.status}`);
+            if (payload.opened) status.textContent = "Opened on ComfyUI host";
+            else {
+                try {
+                    await navigator.clipboard.writeText(payload.path);
+                    status.textContent = "Host path copied";
+                } catch (_error) {
+                    status.textContent = payload.path;
+                }
+                status.title = `${payload.path}${payload.error ? `\n${payload.error}` : ""}`;
+            }
+        } catch (error) {
+            status.className = "h3rm-status h3rm-error";
+            status.textContent = error?.message || String(error);
+        } finally {
+            setBusy(false);
+        }
+    }
+
+    async function saveRunAssets() {
+        const planNode = upstreamPlanNode(node);
+        const runName = String(widgetByName(planNode, "run_name")?.value ?? "").trim();
+        if (!planNode || !runName || !state.bindings.length || state.busy) {
+            status.className = "h3rm-status h3rm-error";
+            status.textContent = !planNode
+                ? "Connect the active Plan first."
+                : !runName
+                    ? "Set run_name on the connected Plan first."
+                    : "Connect at least one loader asset.";
+            return;
+        }
+        syncAssetBindings();
+        setBusy(true);
+        status.className = "h3rm-status";
+        status.textContent = "Saving asset manifest…";
+        try {
+            const response = await api.fetchApi(
+                "/minimax_h3_context_loop/run-assets",
+                {
+                    method: "POST",
+                    headers: {"Content-Type": "application/json"},
+                    body: JSON.stringify({
+                        run_name: runName,
+                        bindings: state.bindings,
+                        archive_images: Boolean(widgetByName(node, "archive_images")?.value),
+                        archive_audio: Boolean(widgetByName(node, "archive_audio")?.value),
+                        archive_video: Boolean(widgetByName(node, "archive_video")?.value),
+                    }),
+                },
+            );
+            const payload = await response.json();
+            if (!response.ok) throw new Error(payload.error || `HTTP ${response.status}`);
+            const warning = payload.warnings?.length
+                ? ` · ${payload.warnings.join(" · ")}` : "";
+            const savedRunName = String(payload.run_name || runName);
+            await refreshRuns(savedRunName);
+            status.className = warning ? "h3rm-status h3rm-error" : "h3rm-status";
+            status.textContent = `Saved ${payload.asset_count} bindings to “${savedRunName}”, ${payload.archived_asset_count ?? 0} archived${warning}`;
+        } catch (error) {
+            status.className = "h3rm-status h3rm-error";
+            status.textContent = error?.message || String(error);
+        } finally {
+            setBusy(false);
+        }
+    }
+
+    select.addEventListener("change", () => {
+        state.restoreEpoch += 1;
+        state.selected = select.value;
+        status.className = "h3rm-status";
+        status.textContent = "";
+        renderSelection();
+    });
+    const load = button("Load selected archive into Plan", "Replace the connected Plan after confirmation", () => {
+        void loadRun();
+    });
+    load.classList.add("h3rm-load");
+    const refresh = button("Refresh", "Rescan output/h3_chains on the ComfyUI host", () => {
+        void refreshRuns();
+    });
+    const open = button("Open selected folder", "Open the selected archive folder on the ComfyUI host", () => {
+        void openRunFolder();
+    });
+    const saveAssets = button(
+        "Save assets to active Plan",
+        "Write loader paths and enabled fallback copies into the active run folder",
+        () => { void saveRunAssets(); },
+    );
+    actions.append(load, refresh, open, saveAssets, status);
+    assetSection.append(assetHeader, assetList);
+    root.append(title, identity, select, details, assetSection, actions);
+
+    const widget = node.addDOMWidget("h3_run_manager", "h3-run-manager", root, {
+        serialize: false,
+        hideOnZoom: false,
+        getMinHeight: () => 340,
+    });
+    widget.serialize = false;
+    node.setSize?.([
+        Math.max(Number(node.size?.[0]) || 0, 520),
+        Math.max(Number(node.size?.[1]) || 0, 500),
+    ]);
+    const connectionsChanged = node.onConnectionsChange;
+    node.onConnectionsChange = function () {
+        state.restoreEpoch += 1;
+        const result = connectionsChanged?.apply(this, arguments);
+        window.setTimeout(() => {
+            if (state.disposed) return;
+            stabilizeAssetInputs(node);
+            syncAssetBindings();
+            renderSelection();
+        }, 0);
+        return result;
+    };
+    const serialized = node.onSerialize;
+    node.onSerialize = function () {
+        syncAssetBindings();
+        return serialized?.apply(this, arguments);
+    };
+    const removed = node.onRemoved;
+    node.onRemoved = function () {
+        state.disposed = true;
+        state.restoreEpoch += 1;
+        for (const source of state.watchedSources) {
+            source._h3AssetWatchers?.delete(sourceChanged);
+        }
+        state.watchedSources.clear();
+        state.watchedPlanWidget?._h3RunManagerWatchers?.delete(activeRunChanged);
+        state.watchedPlanWidget = null;
+        return removed?.apply(this, arguments);
+    };
+    node._h3RunManagerRefresh = () => {
+        if (state.disposed) return;
+        removeLegacyStatusOutput(node);
+        for (const name of ASSET_WIDGETS) collapseWidget(widgetByName(node, name));
+        stabilizeAssetInputs(node);
+        syncAssetBindings();
+        renderSelection();
+    };
+    window.setTimeout(() => {
+        node._h3RunManagerRefresh?.();
+    }, 100);
+    void refreshRuns(activeRunName());
+}
+
+app.registerExtension({
+    name: "minimax_h3_context_loop.run_manager",
+    async beforeRegisterNodeDef(nodeTypeClass, nodeData) {
+        if (nodeData.name !== NODE_NAME) return;
+        const created = nodeTypeClass.prototype.onNodeCreated;
+        nodeTypeClass.prototype.onNodeCreated = function () {
+            const result = created?.apply(this, arguments);
+            window.setTimeout(() => mount(this), 0);
+            return result;
+        };
+        const configured = nodeTypeClass.prototype.onConfigure;
+        nodeTypeClass.prototype.onConfigure = function () {
+            const result = configured?.apply(this, arguments);
+            window.setTimeout(() => this._h3RunManagerRefresh?.(), 0);
+            return result;
+        };
+    const graphConfigured = nodeTypeClass.prototype.onGraphConfigured;
+        nodeTypeClass.prototype.onGraphConfigured = function () {
+            const result = graphConfigured?.apply(this, arguments);
+            window.setTimeout(() => this._h3RunManagerRefresh?.(), 0);
+            return result;
+        };
+    },
+    async nodeCreated(node) {
+        if (nodeType(node) === NODE_NAME) mount(node);
+    },
+});
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_scene_prompt_editor.js b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_scene_prompt_editor.js
new file mode 100644
index 0000000000000000000000000000000000000000..15047f1e72114e82046f60f7b8abcb68dfd3ac70
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_chain_scene_prompt_editor.js
@@ -0,0 +1,3159 @@
+import {app} from "/scripts/app.js";
+import {api} from "/scripts/api.js";
+import {
+    MAX_SHOTS,
+    makeShot,
+    parsePlanJson,
+    planToJson,
+    promptTextToLines,
+    promptValueToText,
+    sharedPrompt,
+} from "./h3_chain_plan_core.mjs?v=0.6.5";
+import {
+    PROMPT_ASSIST_DEFAULT_INSTRUCTIONS,
+    PROMPT_ASSIST_MODES,
+    buildPromptAssistantContext,
+    draftConflict,
+    makePromptAssistRequest,
+    promptSceneKey,
+    promptSourceRevision,
+} from "./h3_prompt_assistant_core.mjs?v=0.6.5";
+import {PromptAssistantClient} from "./h3_prompt_assistant_client.mjs?v=0.6.2";
+import {
+    promptRevisionHelp,
+    promptRevisionLabel,
+    promptRevisionNavigation,
+    promptRevisionTree,
+} from "./h3_prompt_history_core.mjs?v=0.6.2";
+import {
+    availableReferenceRecords,
+    convertTaggedPictureReference,
+    referenceReplacementToken,
+    replacePromptReferenceOccurrence,
+    taggedPictureReferenceMode,
+    taggedPictureReferenceToken,
+} from "./h3_reference_preview_core.mjs?v=0.6.2";
+import {
+    PromptUndoHistory,
+    promptUndoDirection,
+    tokenizeRichPrompt,
+} from "./h3_rich_prompt_editor_core.mjs?v=0.6.5";
+import {createPromptCompletionController} from "./h3_prompt_completion_core.mjs?v=0.6.5";
+import {bindPromptMarkerInteractions} from "./h3_prompt_marker_ui.mjs?v=0.6.5";
+import {isWorkflowSaveShortcut, promptEditorRichText} from "./h3_prompt_editor_settings_core.mjs?v=0.6.5";
+import {promptEditorPreferences} from "./h3_prompt_editor_settings.js";
+import {createH3PromptSchemaController} from "./h3_prompt_schema_ui.mjs?v=0.6.5";
+import * as promptCompanionSync from "./h3_prompt_companion_sync.mjs?v=0.6.2";
+import {
+    PROJECT_ASSET_CATALOG_CHANGED_EVENT,
+} from "./h3_project_asset_sync_core.mjs?v=0.6.2";
+
+const {
+    publishCompanionScene,
+    rebaseScenePrompt,
+} = promptCompanionSync;
+const activeSceneIndexAfterRefresh =
+    typeof promptCompanionSync.activeSceneIndexAfterRefresh === "function"
+        ? promptCompanionSync.activeSceneIndexAfterRefresh
+        : (_previousPlan, nextPlan, sceneIndex) => Math.min(
+            Math.max(0, Math.trunc(Number(sceneIndex) || 0)),
+            Math.max(0, (nextPlan?.shots?.length ?? 1) - 1),
+        );
+const planHasNonPromptChanges =
+    typeof promptCompanionSync.planHasNonPromptChanges === "function"
+        ? promptCompanionSync.planHasNonPromptChanges
+        : () => true;
+function publishCompanionPrompt(...args) {
+    return promptCompanionSync.publishCompanionPrompt?.(...args) ?? 0;
+}
+
+// The compact reference and dialogue authoring interactions are inspired by
+// nkxx188/ComfyUI-MiniMaxH3-Easy (MIT); see THIRD_PARTY_NOTICES.md.
+
+const NODE_NAME = "MiniMaxH3ChainScenePromptEditor";
+const PLAN_NAME = "MiniMaxH3ChainPlan";
+const PLAN_NAMES = new Set([PLAN_NAME, "MiniMaxH3ChainPlanModern"]);
+const ACTIVE_SCENE_PROPERTY = "h3_scene_prompt_editor_active_scene";
+const FONT_SIZE_PROPERTY = "h3_scene_prompt_editor_font_size";
+const PRESENTATION_PROPERTY = "h3_scene_prompt_editor_rich_text";
+const ASSIST_PROVIDER_PROPERTY = "h3_scene_prompt_editor_assist_provider";
+const ASSIST_MODE_PROPERTY = "h3_scene_prompt_editor_assist_mode";
+// Keep the complete prompt-assistant implementation available for a future
+// revisit, but ship the original focused editor experience for now. Re-enabling
+// it is intentionally a one-line change.
+const PROMPT_ASSISTANT_ENABLED = false;
+const DEFAULT_FONT_SIZE = 18;
+const MIN_FONT_SIZE = 12;
+const MAX_FONT_SIZE = 36;
+const PROMPT_SYNC_DELAY_MS = 140;
+const PROMPT_ANALYSIS_DELAY_MS = 90;
+
+const ICONS = Object.freeze({
+    picture: '<svg viewBox="0 0 24 24" aria-hidden="true"><rect x="3" y="4" width="18" height="16" rx="2"/><circle cx="8.5" cy="9" r="1.5"/><path d="m5 17 4.5-4.5 3.2 3.2 2.3-2.3 4 3.6"/></svg>',
+    video: '<svg viewBox="0 0 24 24" aria-hidden="true"><rect x="3" y="5" width="13" height="14" rx="2"/><path d="m16 10 5-3v10l-5-3z"/></svg>',
+    audio: '<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M4 13v-2M8 17V7M12 20V4M16 16V8M20 13v-2"/></svg>',
+    subject: '<svg viewBox="0 0 24 24" aria-hidden="true"><circle cx="12" cy="8" r="4"/><path d="M5 21c.8-4.2 3.1-6.3 7-6.3s6.2 2.1 7 6.3"/></svg>',
+    dialogue: '<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M5 5h14v11H9l-4 3z"/><path d="M8 9h8M8 12h6"/></svg>',
+    reference: '<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M10 13a5 5 0 0 0 7.1.1l2-2a5 5 0 0 0-7.1-7.1l-1.1 1.1"/><path d="M14 11a5 5 0 0 0-7.1-.1l-2 2A5 5 0 0 0 12 20l1.1-1.1"/></svg>',
+    section: '<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M5 5h14M5 12h14M5 19h14"/></svg>',
+    flow: '<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M4 7h11M12 4l3 3-3 3M20 17H9M12 14l-3 3 3 3"/></svg>',
+    speaker: '<svg viewBox="0 0 24 24" aria-hidden="true"><path d="M4 10v4h4l5 4V6L8 10z"/><path d="M16 9c1.5 1.5 1.5 4.5 0 6"/></svg>',
+});
+
+function injectStyles() {
+    if (document.getElementById("h3-scene-prompt-editor-style")) return;
+    const style = document.createElement("style");
+    style.id = "h3-scene-prompt-editor-style";
+    style.textContent = `
+        .h3sp-root {
+            --h3sp-bg: color-mix(in srgb, var(--comfy-menu-bg, #202124) 92%, #101827);
+            --h3sp-panel: color-mix(in srgb, var(--comfy-input-bg, #111827) 84%, #263552);
+            --h3sp-border: color-mix(in srgb, var(--border-color, #555) 68%, #7891bf);
+            --h3sp-text: var(--input-text, #eef1f7);
+            --h3sp-muted: color-mix(in srgb, var(--h3sp-text) 58%, transparent);
+            /* Blend semantic foregrounds with the active ComfyUI text color.
+               This keeps the pastel identity in dark themes and makes the
+               same controls dark enough to read in light themes. */
+            --h3sp-accent: color-mix(in srgb, var(--h3sp-text) 38%, #4f83ff);
+            --h3sp-token-picture: color-mix(in srgb, var(--h3sp-text) 42%, #139be8);
+            --h3sp-token-video: color-mix(in srgb, var(--h3sp-text) 42%, #9355d6);
+            --h3sp-token-audio: color-mix(in srgb, var(--h3sp-text) 42%, #d47700);
+            --h3sp-token-subject: color-mix(in srgb, var(--h3sp-text) 42%, #26934a);
+            --h3sp-token-dialogue: color-mix(in srgb, var(--h3sp-text) 42%, #cf3976);
+            --h3sp-token-section: color-mix(in srgb, var(--h3sp-text) 38%, #5f87ff);
+            --h3sp-token-flow: color-mix(in srgb, var(--h3sp-text) 42%, #00a99d);
+            --h3sp-token-speaker: color-mix(in srgb, var(--h3sp-text) 42%, #d268b7);
+            --h3sp-token-danger: color-mix(in srgb, var(--h3sp-text) 42%, #d44747);
+            --h3sp-font-size: 18px;
+            box-sizing:border-box; width:100%; height:100%; min-height:420px;
+            display:flex; flex-direction:column; gap:8px; overflow:hidden; padding:10px;
+            border:1px solid var(--h3sp-border); border-radius:8px; background:var(--h3sp-bg);
+            color:var(--h3sp-text); font:12px/1.35 system-ui,sans-serif;
+        }
+        .h3sp-root *, .h3sp-root *::before, .h3sp-root *::after { box-sizing:border-box; }
+        .h3sp-head, .h3sp-nav, .h3sp-tools, .h3sp-font, .h3sp-footer {
+            display:flex; align-items:center; gap:6px;
+        }
+        .h3sp-head { justify-content:space-between; }
+        .h3sp-title { color:var(--h3sp-accent); font-size:15px; font-weight:750; }
+        .h3sp-context { color:var(--h3sp-muted); white-space:nowrap; overflow:hidden;
+            text-overflow:ellipsis; text-align:right; }
+        .h3sp-nav select { flex:1; min-width:0; }
+        .h3sp-root button, .h3sp-root select {
+            color:var(--h3sp-text); font:inherit; border:1px solid var(--h3sp-border);
+            border-radius:5px; background:var(--comfy-input-bg,#171a21);
+        }
+        .h3sp-root button { padding:6px 9px; cursor:pointer; white-space:nowrap; }
+        .h3sp-root button:hover { border-color:var(--h3sp-accent); }
+        .h3sp-root button:disabled { cursor:not-allowed; opacity:.4; }
+        .h3sp-root select { min-height:30px; padding:5px 7px; }
+        .h3sp-font { margin-left:auto; }
+        .h3sp-font-value { min-width:38px; color:var(--h3sp-muted); text-align:center; }
+        .h3sp-textarea {
+            width:100%; min-height:240px; flex:1 1 auto; resize:none; padding:12px 14px;
+            border:1px solid var(--h3sp-border); border-radius:7px;
+            outline:none; background:var(--comfy-input-bg,#11141a); color:var(--h3sp-text);
+            font:var(--h3sp-font-size)/1.55 ui-monospace,SFMono-Regular,Consolas,monospace;
+            tab-size:4; white-space:pre-wrap;
+        }
+        .h3sp-textarea:focus { border-color:var(--h3sp-accent);
+            box-shadow:0 0 0 1px color-mix(in srgb,var(--h3sp-accent) 45%,transparent); }
+        .h3sp-hidden { display:none !important; }
+        .h3sp-editor-shell { position:relative; width:100%; min-height:240px;
+            flex:1 1 auto; overflow:hidden; border:1px solid var(--h3sp-border);
+            border-radius:7px; background:var(--comfy-input-bg,#11141a); }
+        .h3sp-editor-shell:focus-within { border-color:var(--h3sp-accent);
+            box-shadow:0 0 0 1px color-mix(in srgb,var(--h3sp-accent) 45%,transparent); }
+        .h3sp-rich-editor { width:100%; height:100%; min-height:240px; overflow:auto;
+            padding:12px 14px; outline:none; white-space:pre-wrap; overflow-wrap:anywhere;
+            caret-color:var(--h3sp-text);
+            font:var(--h3sp-font-size)/1.55 ui-monospace,SFMono-Regular,Consolas,monospace; }
+        .h3sp-rich-editor:empty::before { content:attr(data-placeholder);
+            color:var(--h3sp-muted); pointer-events:none; }
+        .h3sp-token { display:inline-flex; align-items:center; gap:3px; max-width:320px;
+            margin:0 1px; padding:1px 4px 1px 2px; border:1px solid currentColor;
+            border-radius:5px; vertical-align:1px; line-height:1.25; cursor:pointer;
+            user-select:all; background:color-mix(in srgb,currentColor 14%,transparent); }
+        .h3sp-token-picture { color:var(--h3sp-token-picture); }
+        .h3sp-token-video { color:var(--h3sp-token-video); }
+        .h3sp-token-audio { color:var(--h3sp-token-audio); }
+        .h3sp-token-subject { color:var(--h3sp-token-subject); }
+        .h3sp-token-dialogue { color:var(--h3sp-token-dialogue); }
+        .h3sp-token-section { display:inline; margin:0; padding:0; border:0;
+            border-radius:0; color:var(--h3sp-token-section); background:none;
+            font-weight:650; cursor:text; user-select:text; }
+        .h3sp-token-flow { color:var(--h3sp-token-flow); }
+        .h3sp-token-speaker { color:var(--h3sp-token-speaker); }
+        .h3sp-token-unknown, .h3sp-token-inactive { color:var(--h3sp-token-danger);
+            border-style:dashed; }
+        .h3sp-token-icon { width:16px; height:16px; display:inline-flex;
+            flex:0 0 16px; color:currentColor; }
+        .h3sp-token-icon svg { width:100%; height:100%; fill:none; stroke:currentColor;
+            stroke-width:1.7; stroke-linecap:round; stroke-linejoin:round; }
+        .h3sp-token-thumb { width:18px; height:18px; flex:0 0 18px;
+            object-fit:cover; border-radius:3px; background:rgba(255,255,255,.09); }
+        .h3sp-token-label { overflow:hidden; text-overflow:ellipsis; white-space:nowrap; }
+        .h3sp-presentation-active { border-color:var(--h3sp-accent) !important;
+            color:var(--h3sp-accent) !important; }
+        .h3sp-popover { position:fixed; z-index:100000; width:min(360px,calc(100vw - 24px));
+            padding:9px; border:1px solid #60718c; border-radius:9px; background:#171a20;
+            color:#eef2f8; box-shadow:0 14px 38px rgba(0,0,0,.48);
+            font:12px/1.4 system-ui,sans-serif; }
+        .h3sp-popover[hidden] { display:none; }
+        .h3sp-popover-title { margin-bottom:6px; font-weight:750; }
+        .h3sp-popover-media { display:block; width:100%; max-height:240px;
+            object-fit:contain; border-radius:6px; background:#08090c; }
+        .h3sp-popover audio.h3sp-popover-media { height:42px; background:transparent; }
+        .h3sp-popover-detail { margin-top:6px; color:rgba(238,242,248,.62);
+            white-space:pre-wrap; overflow-wrap:anywhere; }
+        .h3sp-popover-editor { display:grid; gap:8px; }
+        .h3sp-popover-field { display:grid; grid-template-columns:82px minmax(0,1fr);
+            align-items:center; gap:7px; }
+        .h3sp-popover-field > span { color:rgba(238,242,248,.68); }
+        .h3sp-popover-field select,.h3sp-popover-field input { width:100%; min-width:0;
+            padding:5px 7px; border:1px solid #60718c; border-radius:5px;
+            background:#0e1117; color:#eef2f8; }
+        .h3sp-popover-actions { display:flex; justify-content:flex-end; gap:6px; }
+        .h3sp-popover-actions button { padding:4px 9px; }
+        .h3sp-root.h3sp-assistant-enabled { overflow:auto; }
+        .h3sp-root.h3sp-assistant-enabled .h3sp-textarea {
+            min-height:220px; resize:vertical;
+        }
+        .h3sp-tools { position:relative; flex-wrap:wrap; }
+        .h3sp-hint { color:var(--h3sp-muted); margin-left:auto; }
+        .h3sp-refs { display:none; flex:0 0 auto; max-height:340px; overflow:auto;
+            padding:7px; gap:5px; flex-wrap:wrap; border:1px solid var(--h3sp-border);
+            border-radius:6px; background:var(--h3sp-panel); }
+        .h3sp-refs.h3sp-open { display:flex; }
+        .h3sp-refs button { padding:4px 7px; }
+        .h3sp-ref-help { flex:1 0 100%; color:var(--h3sp-muted); }
+        .h3sp-ref-chip.h3sp-inactive { opacity:.48; }
+        .h3sp-ref-chip.h3sp-active { border-color:#658b77; }
+        .h3sp-ref-entry { display:flex; align-items:stretch; gap:2px; }
+        .h3sp-ref-mode { display:flex; align-items:stretch; gap:1px; }
+        .h3sp-ref-mode button { min-width:28px; padding:2px 5px; font-size:10px; }
+        .h3sp-ref-mode button.h3sp-selected { border-color:var(--h3sp-accent);
+            color:var(--h3sp-accent); }
+        .h3sp-ref-preview { display:none; flex:1 0 100%; min-height:58px;
+            padding:8px; border:1px solid color-mix(in srgb,var(--h3sp-border) 74%,transparent);
+            border-radius:6px; background:var(--comfy-input-bg,#11141a); }
+        .h3sp-ref-preview.h3sp-visible { display:grid; grid-template-columns:minmax(120px,220px) 1fr;
+            align-items:start; gap:9px; }
+        .h3sp-ref-preview-media { width:100%; max-height:190px; display:block;
+            border-radius:5px; object-fit:contain; background:#08090c; }
+        audio.h3sp-ref-preview-media { min-width:190px; height:38px; background:transparent; }
+        .h3sp-ref-preview-copy { min-width:0; color:var(--h3sp-muted);
+            white-space:pre-wrap; overflow-wrap:anywhere; }
+        .h3sp-ref-preview-title { color:var(--h3sp-text); font-weight:700; }
+        .h3sp-footer { display:grid; grid-template-columns:minmax(0,1fr) auto minmax(0,1fr);
+            align-items:center; gap:8px; color:var(--h3sp-muted); }
+        .h3sp-footer-status { min-width:0; overflow:hidden; text-align:right;
+            text-overflow:ellipsis; white-space:nowrap; }
+        .h3sp-history { min-width:0; display:flex; align-items:center;
+            justify-content:center; gap:6px; color:var(--h3sp-muted); }
+        .h3sp-history-nav { display:flex; align-items:center; gap:2px;
+            border:1px solid color-mix(in srgb,var(--h3sp-border) 72%,transparent);
+            border-radius:999px; padding:1px 3px; background:var(--comfy-input-bg,#11141a); }
+        .h3sp-history-nav button { min-width:25px; padding:2px 5px; border:0;
+            border-radius:999px; background:transparent; }
+        .h3sp-history-count { min-width:42px; text-align:center; color:var(--h3sp-text);
+            font-variant-numeric:tabular-nums; }
+        .h3sp-history-meta { min-width:0; max-width:280px; overflow:hidden;
+            text-overflow:ellipsis; white-space:nowrap; font-size:11px; }
+        .h3sp-history-error { color:#ffb3b3; }
+        .h3sp-history-tree { position:relative; flex:0 0 auto; }
+        .h3sp-history-tree > summary { list-style:none; cursor:pointer; padding:3px 7px;
+            border:1px solid color-mix(in srgb,var(--h3sp-border) 72%,transparent);
+            border-radius:999px; background:var(--comfy-input-bg,#11141a);
+            color:var(--h3sp-text); user-select:none; }
+        .h3sp-history-tree > summary::-webkit-details-marker { display:none; }
+        .h3sp-history-tree[open] > summary { border-color:var(--h3sp-accent); }
+        .h3sp-history-tree-panel { position:absolute; z-index:20; bottom:calc(100% + 7px);
+            left:50%; transform:translateX(-50%); width:min(440px,calc(100vw - 30px));
+            max-height:310px; overflow:auto; padding:7px; border:1px solid var(--h3sp-border);
+            border-radius:8px; background:var(--h3sp-bg); box-shadow:0 14px 36px rgba(0,0,0,.48); }
+        .h3sp-history-tree-row { display:flex; align-items:center; gap:4px; min-width:0;
+            margin:2px 0; border-radius:5px; }
+        .h3sp-history-tree-row.h3sp-history-active { background:rgba(132,170,255,.12); }
+        .h3sp-history-tree-row.h3sp-history-archived { opacity:.58; }
+        .h3sp-history-tree-select { flex:1 1 auto; min-width:0; justify-content:flex-start !important;
+            min-height:26px !important; padding:3px 6px !important; border-color:transparent !important;
+            background:transparent !important; text-align:left; }
+        .h3sp-history-branch { flex:0 0 auto; color:var(--h3sp-muted); }
+        .h3sp-history-tree-label { min-width:0; overflow:hidden; text-overflow:ellipsis;
+            white-space:nowrap; color:var(--h3sp-text); }
+        .h3sp-history-tree-badge { flex:0 0 auto; color:var(--h3sp-muted); font-size:10px; }
+        .h3sp-history-tree-action { min-width:25px !important; min-height:25px !important;
+            padding:2px 5px !important; }
+        .h3sp-history-tree-tools { display:flex; justify-content:space-between; align-items:center;
+            gap:8px; margin-top:6px; padding-top:6px; border-top:1px solid var(--h3sp-border);
+            color:var(--h3sp-muted); font-size:10px; }
+        .h3sp-history-tree-tools button { min-height:24px; padding:2px 6px; }
+        .h3sp-error { padding:12px; border:1px solid #a76565; border-radius:6px;
+            color:#ffb3b3; background:#351f24; white-space:pre-wrap; }
+        .h3sp-assist { flex:0 0 auto; display:flex; flex-direction:column; gap:7px;
+            padding:9px; border:1px solid var(--h3sp-border); border-radius:7px;
+            background:var(--h3sp-panel); }
+        .h3sp-assist-head, .h3sp-assist-controls, .h3sp-assist-actions,
+        .h3sp-assist-contexts { display:flex; align-items:center; gap:6px; flex-wrap:wrap; }
+        .h3sp-assist-head { justify-content:space-between; }
+        .h3sp-assist-title { color:var(--h3sp-accent); font-size:13px; font-weight:750; }
+        .h3sp-assist-status { color:var(--h3sp-muted); font-size:11px; }
+        .h3sp-assist-controls select { flex:1 1 120px; min-width:100px; }
+        .h3sp-assist-contexts label { display:flex; align-items:center; gap:4px;
+            color:var(--h3sp-muted); cursor:pointer; }
+        .h3sp-assist-contexts input { accent-color:var(--h3sp-accent); }
+        .h3sp-assist-chat { display:flex; flex-direction:column; gap:5px; max-height:180px;
+            overflow:auto; padding:6px; border:1px solid color-mix(in srgb,var(--h3sp-border) 70%,transparent);
+            border-radius:6px; background:color-mix(in srgb,var(--comfy-input-bg,#11141a) 82%,transparent); }
+        .h3sp-assist-message { padding:6px 8px; border-radius:6px; white-space:pre-wrap;
+            overflow-wrap:anywhere; }
+        .h3sp-assist-message-user { margin-left:12%; background:#23375b; }
+        .h3sp-assist-message-agent { margin-right:7%; background:#263c34; }
+        .h3sp-assist-message-system { color:var(--h3sp-muted); font-size:11px;
+            border:1px dashed var(--h3sp-border); }
+        .h3sp-assist-empty { color:var(--h3sp-muted); padding:5px; }
+        .h3sp-assist-compose { display:flex; align-items:stretch; gap:6px; }
+        .h3sp-assist-compose textarea, .h3sp-assist-draft textarea {
+            width:100%; resize:vertical; min-height:58px; padding:7px 8px;
+            border:1px solid var(--h3sp-border); border-radius:6px;
+            outline:none; background:var(--comfy-input-bg,#11141a); color:var(--h3sp-text);
+            font:12px/1.4 system-ui,sans-serif; }
+        .h3sp-assist-compose textarea:focus, .h3sp-assist-draft textarea:focus {
+            border-color:var(--h3sp-accent); }
+        .h3sp-assist-compose button { align-self:stretch; }
+        .h3sp-assist-draft { display:flex; flex-direction:column; gap:6px; padding:8px;
+            border:1px solid #5d8a72; border-radius:6px; background:#182b25; }
+        .h3sp-assist-draft-head { display:flex; justify-content:space-between;
+            align-items:center; gap:6px; }
+        .h3sp-assist-draft-title { font-weight:700; color:#9ad7b7; }
+        .h3sp-assist-stale { color:#ffc08a; font-size:11px; }
+        .h3sp-assist-original { color:var(--h3sp-muted); }
+        .h3sp-assist-original pre { max-height:120px; overflow:auto; white-space:pre-wrap;
+            padding:6px; border-radius:5px; background:var(--comfy-input-bg,#11141a); }
+        .h3sp-assist-error { color:#ffb3b3; white-space:pre-wrap; }
+    `;
+    document.head.appendChild(style);
+}
+
+function element(tag, className = "", text) {
+    const item = document.createElement(tag);
+    if (className) item.className = className;
+    if (text !== undefined) item.textContent = text;
+    return item;
+}
+
+function button(label, title, action) {
+    const item = element("button", "", label);
+    item.type = "button";
+    item.title = title;
+    // Preserve a contenteditable selection while clicking toolbar/reference
+    // controls. Keyboard focus via Tab remains available.
+    item.addEventListener("pointerdown", (event) => event.preventDefault());
+    item.addEventListener("click", action);
+    return item;
+}
+
+function icon(kind) {
+    const item = element("span", "h3sp-token-icon");
+    item.innerHTML = ICONS[kind] ?? ICONS.reference;
+    return item;
+}
+
+function nodeType(node) {
+    return node?.comfyClass ?? node?.type ?? null;
+}
+
+function allNodes(graph, output = []) {
+    for (const node of graph?._nodes ?? []) {
+        output.push(node);
+        if (node.subgraph) allNodes(node.subgraph, output);
+    }
+    return output;
+}
+
+function upstreamPlanNode(start) {
+    const queue = [start];
+    const seen = new Set();
+    while (queue.length) {
+        const node = queue.shift();
+        if (!node || seen.has(node)) continue;
+        seen.add(node);
+        if (node !== start && PLAN_NAMES.has(nodeType(node))) return node;
+        for (const input of node.inputs ?? []) {
+            if (input.link == null) continue;
+            const link = node.graph?.links?.[input.link];
+            const parent = link ? node.graph?.getNodeById?.(link.origin_id) : null;
+            if (parent) queue.push(parent);
+        }
+    }
+    return null;
+}
+
+function inputSource(node, name) {
+    const input = node?.inputs?.find((item) => item.name === name);
+    const link = input?.link == null ? null : node.graph?.links?.[input.link];
+    return link ? node.graph?.getNodeById?.(link.origin_id) ?? null : null;
+}
+
+function mediaExtension(kind) {
+    if (kind === "image") return /\.(?:avif|bmp|gif|jpe?g|png|webp)$/i;
+    if (kind === "video") return /\.(?:m4v|mkv|mov|mp4|webm)$/i;
+    return /\.(?:aac|flac|m4a|mp3|ogg|opus|wav)$/i;
+}
+
+function widgetAsset(value, kind) {
+    if (value && typeof value === "object" && value.filename) {
+        return {
+            filename: String(value.filename),
+            subfolder: String(value.subfolder ?? ""),
+            type: String(value.type ?? "input"),
+        };
+    }
+    let text = typeof value === "string" ? value.trim() : "";
+    if (!text) return null;
+    if (/^(?:blob:|data:|https?:|\/api\/view\?|\/view\?)/i.test(text)) {
+        return {url: text};
+    }
+    let type = "input";
+    const annotated = text.match(/\s+\[(input|output|temp)\]\s*$/i);
+    if (annotated) {
+        type = annotated[1].toLowerCase();
+        text = text.slice(0, annotated.index).trim();
+    }
+    text = text.replaceAll("\\", "/").replace(/^\/+/, "");
+    if (!mediaExtension(kind).test(text)) return null;
+    const slash = text.lastIndexOf("/");
+    return {
+        filename: slash >= 0 ? text.slice(slash + 1) : text,
+        subfolder: slash >= 0 ? text.slice(0, slash) : "",
+        type,
+    };
+}
+
+function assetUrl(asset) {
+    if (!asset) return null;
+    if (asset.url) return asset.url;
+    const query = new URLSearchParams({
+        filename: asset.filename,
+        subfolder: asset.subfolder ?? "",
+        type: asset.type ?? "input",
+    });
+    return api.apiURL(`/view?${query.toString()}`);
+}
+
+function previewFromNode(node, kind) {
+    if (kind === "image") {
+        const rendered = node?.imgs?.[0];
+        const src = typeof rendered === "string" ? rendered : rendered?.src;
+        if (src) return src;
+    }
+    for (const widget of node?.widgets ?? []) {
+        const asset = widgetAsset(widget.value, kind);
+        if (asset) return assetUrl(asset);
+    }
+    return null;
+}
+
+function findMediaPreview(start, kind) {
+    const queue = [start];
+    const seen = new Set();
+    while (queue.length) {
+        const node = queue.shift();
+        if (!node || seen.has(node)) continue;
+        seen.add(node);
+        const url = previewFromNode(node, kind);
+        if (url) return {url, source: node};
+        for (const input of node.inputs ?? []) {
+            const parent = inputSource(node, input.name);
+            if (parent) queue.push(parent);
+        }
+    }
+    return {url: null, source: start};
+}
+
+function referenceMediaPreview(record, kind) {
+    if (record?.previewUrl) {
+        return {
+            url: api.apiURL(record.previewUrl),
+            source: record.source ?? record.node ?? null,
+        };
+    }
+    return findMediaPreview(record?.source, kind);
+}
+
+function insertText(textarea, text, selectionOffset = text.length) {
+    const start = textarea.selectionStart ?? textarea.value.length;
+    const end = textarea.selectionEnd ?? start;
+    textarea.setRangeText(text, start, end, "end");
+    const caret = start + selectionOffset;
+    textarea.setSelectionRange(caret, caret);
+    textarea.dispatchEvent(new Event("input", {bubbles: true}));
+    textarea.focus();
+}
+
+function insertDialogue(textarea) {
+    const start = textarea.selectionStart ?? textarea.value.length;
+    const end = textarea.selectionEnd ?? start;
+    const selected = textarea.value.slice(start, end);
+    const markup = `<d>${selected}</d>`;
+    insertText(textarea, markup, selected ? markup.length : 3);
+}
+
+function editorPlainText(editor, {trimFinalNewline = true} = {}) {
+    function read(current, root) {
+        if (current.nodeType === Node.TEXT_NODE) return current.textContent ?? "";
+        if (current.nodeType === Node.DOCUMENT_FRAGMENT_NODE) {
+            let text = "";
+            for (const child of current.childNodes) text += read(child, root);
+            return text;
+        }
+        if (current.nodeType !== Node.ELEMENT_NODE) return "";
+        if (current.classList?.contains("h3sp-token")) {
+            return current.dataset.token ?? current.textContent ?? "";
+        }
+        if (current.tagName === "BR") return "\n";
+        let text = "";
+        for (const child of current.childNodes) text += read(child, root);
+        if (["DIV", "P"].includes(current.tagName)
+                && current !== root && !text.endsWith("\n")) text += "\n";
+        return text;
+    }
+    const text = read(editor, editor);
+    return trimFinalNewline ? text.replace(/\n$/, "") : text;
+}
+
+function selectedEditorPlainText(editor) {
+    const selection = globalThis.getSelection?.();
+    if (!selection?.rangeCount || selection.isCollapsed) return null;
+    const inside = (current) => current === editor || editor.contains(current);
+    if (!inside(selection.anchorNode) || !inside(selection.focusNode)) return null;
+    const fragment = selection.getRangeAt(0).cloneContents();
+    return editorPlainText(fragment);
+}
+
+function copyEditorSelection(editor, event, cut = false) {
+    const text = selectedEditorPlainText(editor);
+    if (text == null || !event.clipboardData) return false;
+    // A decorated tag contains icons/thumbnails as well as its visible label.
+    // Copy its canonical data-token value so another prompt editor receives
+    // exactly the original prompt markup rather than browser-generated HTML.
+    event.clipboardData.setData("text/plain", text);
+    event.preventDefault();
+    if (cut) {
+        const selection = globalThis.getSelection?.();
+        const range = selection.getRangeAt(0);
+        range.deleteContents();
+        range.collapse(true);
+        selection.removeAllRanges();
+        selection.addRange(range);
+        editor.dispatchEvent(new Event("input", {bubbles: true}));
+    }
+    return true;
+}
+
+function editorPointTextOffset(editor, node, offset) {
+    if (!node || (node !== editor && !editor.contains(node))) return null;
+    const range = document.createRange();
+    range.selectNodeContents(editor);
+    try {
+        range.setEnd(node, offset);
+    } catch (_error) {
+        return null;
+    }
+    return editorPlainText(range.cloneContents()).length;
+}
+
+function editorSelectionOffsets(editor) {
+    const selection = globalThis.getSelection?.();
+    if (!selection?.rangeCount) return null;
+    const selected = selection.getRangeAt(0);
+    const start = editorPointTextOffset(
+        editor, selected.startContainer, selected.startOffset,
+    );
+    const end = editorPointTextOffset(
+        editor, selected.endContainer, selected.endOffset,
+    );
+    return start == null || end == null ? null : {start, end};
+}
+
+function selectionTextOffset(editor) {
+    const selection = globalThis.getSelection?.();
+    const offset = selection?.rangeCount
+        ? editorPointTextOffset(editor, selection.focusNode, selection.focusOffset)
+        : null;
+    return offset == null ? editorPlainText(editor).length : offset;
+}
+
+function restoreCaret(editor, requested) {
+    const target = Math.max(0, Number(requested) || 0);
+    const range = document.createRange();
+    const selection = globalThis.getSelection?.();
+    let consumed = 0;
+    let placed = false;
+    function visit(current) {
+        if (placed) return;
+        if (current.nodeType === Node.TEXT_NODE) {
+            const length = current.textContent?.length ?? 0;
+            if (target <= consumed + length) {
+                range.setStart(current, Math.max(0, target - consumed));
+                placed = true;
+                return;
+            }
+            consumed += length;
+            return;
+        }
+        if (current.nodeType !== Node.ELEMENT_NODE) return;
+        if (current.classList?.contains("h3sp-token")) {
+            const length = String(current.dataset.token ?? "").length;
+            if (target <= consumed + length) {
+                if (target <= consumed) range.setStartBefore(current);
+                else range.setStartAfter(current);
+                placed = true;
+                return;
+            }
+            consumed += length;
+            return;
+        }
+        for (const child of current.childNodes) visit(child);
+    }
+    visit(editor);
+    if (!placed) {
+        range.selectNodeContents(editor);
+        range.collapse(false);
+    } else {
+        range.collapse(true);
+    }
+    selection?.removeAllRanges();
+    selection?.addRange(range);
+}
+
+function restoreTextSelection(editor, requestedStart, requestedEnd) {
+    const start = Math.max(0, Number(requestedStart) || 0);
+    const end = Math.max(start, Number(requestedEnd) || start);
+    let consumed = 0;
+    let startPoint = null;
+    let endPoint = null;
+    function visit(current) {
+        if (startPoint && endPoint) return;
+        if (current.nodeType === Node.TEXT_NODE) {
+            const length = current.textContent?.length ?? 0;
+            if (!startPoint && start >= consumed && start <= consumed + length) {
+                startPoint = [current, start - consumed];
+            }
+            if (!endPoint && end >= consumed && end <= consumed + length) {
+                endPoint = [current, end - consumed];
+            }
+            consumed += length;
+            return;
+        }
+        if (current.nodeType !== Node.ELEMENT_NODE) return;
+        if (current.classList?.contains("h3sp-token")) {
+            consumed += String(current.dataset.token ?? "").length;
+            return;
+        }
+        for (const child of current.childNodes) visit(child);
+    }
+    visit(editor);
+    if (!startPoint || !endPoint) {
+        restoreCaret(editor, end);
+        return;
+    }
+    const range = document.createRange();
+    range.setStart(...startPoint);
+    range.setEnd(...endPoint);
+    const selection = globalThis.getSelection?.();
+    selection?.removeAllRanges();
+    selection?.addRange(range);
+}
+
+function insertPlainText(editor, text) {
+    editor.focus();
+    const selection = globalThis.getSelection?.();
+    const inside = Boolean(selection?.rangeCount && editor.contains(selection.anchorNode));
+    const range = inside ? selection.getRangeAt(0) : document.createRange();
+    if (!inside) {
+        range.selectNodeContents(editor);
+        range.collapse(false);
+    }
+    range.deleteContents();
+    const textNode = document.createTextNode(String(text ?? ""));
+    range.insertNode(textNode);
+    range.setStartAfter(textNode);
+    range.collapse(true);
+    selection?.removeAllRanges();
+    selection?.addRange(range);
+    editor.dispatchEvent(new Event("input", {bubbles: true}));
+}
+
+function clamp(value, minimum, maximum, fallback) {
+    const numeric = Number(value);
+    return Number.isFinite(numeric)
+        ? Math.max(minimum, Math.min(maximum, Math.round(numeric))) : fallback;
+}
+
+function promptAssistantIdentityKey(node) {
+    // Node ids are only unique inside one workflow. ComfyUI can keep several
+    // workflows open in the same browser/sessionStorage, so include the active
+    // workflow identity or two editors with (for example) node id 7 would share
+    // one agent route and pending-request record.
+    const workflow = app.extensionManager?.workflow?.activeWorkflow;
+    const workflowIdentity = workflow?.path
+        ?? workflow?.activeState?.id
+        ?? workflow?.filename
+        ?? "legacy-workflow";
+    const nodeIdentity = node.id == null
+        ? `new-${globalThis.crypto?.randomUUID?.() ?? Math.random().toString(36).slice(2)}`
+        : String(node.id);
+    return `workflow-${workflowIdentity}-node-${nodeIdentity}`;
+}
+
+function mount(node) {
+    if (node._h3ScenePromptEditorMounted || typeof node.addDOMWidget !== "function") return;
+    node._h3ScenePromptEditorMounted = true;
+    injectStyles();
+
+    node.properties ??= {};
+    const root = element("div", "h3sp-root");
+    root.classList.toggle("h3sp-assistant-enabled", PROMPT_ASSISTANT_ENABLED);
+    root.title = "Edit the active scene prompt stored in the connected H3 Chain Plan.";
+    for (const eventName of [
+        "pointerdown", "pointerup", "mousedown", "mouseup", "click", "dblclick",
+    ]) {
+        root.addEventListener(eventName, (event) => event.stopPropagation());
+    }
+    // Keep ComfyUI/LiteGraph's canvas shortcuts from claiming Ctrl/Cmd+V (and
+    // the other native editing shortcuts) while focus is inside this DOM
+    // widget. stopPropagation deliberately preserves the browser's default
+    // textarea/contenteditable action; preventDefault here would break paste.
+    for (const eventName of ["keydown", "keyup", "keypress", "copy", "cut", "paste"]) {
+        root.addEventListener(eventName, (event) => {
+            // Saving the workflow must remain available while typing; all
+            // editing/undo shortcuts keep their existing scene-local routing.
+            if (isWorkflowSaveShortcut(event)) {
+                if (event.type === "keydown") flushPlanEffects();
+                return;
+            }
+            event.stopPropagation();
+        });
+    }
+    root.addEventListener("wheel", (event) => event.stopPropagation());
+
+    const state = {
+        plan: null,
+        planNode: null,
+        planWidget: null,
+        lastValue: "",
+        lastRunName: "",
+        active: Math.max(0, Number(node.properties[ACTIVE_SCENE_PROPERTY]) || 0),
+        fontSize: clamp(
+            node.properties[FONT_SIZE_PROPERTY], MIN_FONT_SIZE, MAX_FONT_SIZE,
+            DEFAULT_FONT_SIZE,
+        ),
+        decorated: promptEditorRichText(node.properties, PRESENTATION_PROPERTY, promptEditorPreferences()),
+        records: [],
+        referenceMode: null,
+        referenceSyntax: new Map(),
+        completion: null,
+        schema: null,
+        promptTextarea: null,
+        richEditor: null,
+        promptSelection: null,
+        referenceTray: null,
+        popover: null,
+        popoverTimer: null,
+        popoverPinned: false,
+        assistant: {
+            client: null,
+            host: null,
+            status: "idle",
+            statusDetail: "Connects through comfyui-mcp on the first request",
+            provider: ["codex", "hermes"].includes(
+                node.properties[ASSIST_PROVIDER_PROPERTY],
+            ) ? node.properties[ASSIST_PROVIDER_PROPERTY] : "codex",
+            mode: PROMPT_ASSIST_MODES.some(
+                (item) => item.id === node.properties[ASSIST_MODE_PROPERTY],
+            ) ? node.properties[ASSIST_MODE_PROPERTY] : "rewrite",
+            includeShared: true,
+            includeAdjacent: true,
+            composer: "",
+            messagesByProvider: {codex: [], hermes: []},
+            drafts: new Map(),
+            requestContexts: new Map(),
+            activeRequest: null,
+            preparingRequest: null,
+            pendingStorageKey: "",
+            reconnectTimer: null,
+            lastApplied: null,
+            providers: null,
+            error: "",
+        },
+        history: {
+            sceneKey: "",
+            data: null,
+            revisionId: null,
+            host: null,
+            textarea: null,
+            status: null,
+            loadToken: 0,
+            loadPromise: null,
+            saveTimer: null,
+            pendingDraft: null,
+            savePromise: null,
+            error: "",
+            treeOpen: false,
+            showArchived: false,
+        },
+        undoByScene: new Map(),
+        promptUndo: null,
+        richInputType: "",
+        pollTimer: null,
+        planSyncTimer: null,
+        planSyncPending: null,
+        analysisTimer: null,
+        applyPromptHistoryShortcut: null,
+        ownsPromptHistoryTarget: null,
+        disposed: false,
+    };
+    node._h3ScenePromptEditorState = state;
+
+    // Intercept prompt undo before ComfyUI's workflow history can restore an
+    // older node snapshot (which commonly resets the editor to scene 1).
+    root.addEventListener("keydown", (event) => {
+        const direction = promptUndoDirection(event);
+        if (!direction || !state.ownsPromptHistoryTarget?.(event.target)) return;
+        event.preventDefault();
+        event.stopImmediatePropagation();
+        state.applyPromptHistoryShortcut?.(direction, event.target);
+    }, true);
+
+    const assistant = state.assistant;
+    if (PROMPT_ASSISTANT_ENABLED) {
+        assistant.client = new PromptAssistantClient({
+            identityKey: promptAssistantIdentityKey(node),
+            onFrame: (frame) => handleAssistantFrame(frame),
+            onStatus: (status, detail) => {
+                assistant.status = status;
+                if (status === "connected") {
+                    clearAssistantReconnect();
+                    assistant.statusDetail = "Connected · isolated prompt session";
+                } else if (status === "connecting") {
+                    assistant.statusDetail = "Connecting to comfyui-mcp…";
+                } else if (assistant.activeRequest) {
+                    assistant.statusDetail = "Disconnected · reconnecting to recover the active draft…";
+                    scheduleAssistantReconnect();
+                } else {
+                    assistant.statusDetail = "Disconnected · send to reconnect";
+                }
+                if (detail?.providers) assistant.providers = detail.providers;
+                refreshAssistant();
+            },
+        });
+        assistant.pendingStorageKey = `h3.prompt-assistant.pending.${assistant.client.identity}`;
+    }
+
+    function dirty() {
+        node.graph?.setDirtyCanvas?.(true, true);
+        app.graph?.setDirtyCanvas?.(true, true);
+    }
+
+    function persistView() {
+        node.properties[ACTIVE_SCENE_PROPERTY] = state.active;
+        node.properties[FONT_SIZE_PROPERTY] = state.fontSize;
+        node.properties[PRESENTATION_PROPERTY] = state.decorated;
+        dirty();
+    }
+
+    function rebaseActivePromptOntoLivePlan() {
+        if (!state.plan || !state.planWidget) return false;
+        let live;
+        try { live = parsePlanJson(String(state.planWidget.value ?? "")); }
+        catch (_error) { return false; }
+        const index = rebaseScenePrompt(state.plan, live, state.active);
+        if (index < 0) return false;
+        state.active = index;
+        node.properties[ACTIVE_SCENE_PROPERTY] = index;
+        return true;
+    }
+
+    function flushPlanEffects() {
+        if (state.planSyncTimer != null) {
+            window.clearTimeout(state.planSyncTimer);
+            state.planSyncTimer = null;
+        }
+        const pending = state.planSyncPending;
+        state.planSyncPending = null;
+        if (!pending || !state.planWidget || !state.planNode) return;
+        const liveValue = String(state.planWidget.value ?? "");
+        if (liveValue !== pending.value) {
+            if (!rebaseActivePromptOntoLivePlan()) {
+                if (pending.status) {
+                    pending.status.textContent =
+                        "Plan structure changed; waiting to resynchronize";
+                }
+                return;
+            }
+            pending.value = planToJson(state.plan);
+            pending.sceneIndex = state.active;
+            pending.prompt = promptValueToText(
+                state.plan.shots[state.active]?.prompt,
+            );
+            state.lastValue = pending.value;
+            state.planWidget.value = pending.value;
+        }
+        if (typeof state.planWidget.callback === "function") {
+            state.planWidget.callback(pending.value);
+        } else {
+            state.planNode._h3ChainEditorRefresh?.();
+        }
+        state.planNode.graph?.setDirtyCanvas?.(true, true);
+        publishCompanionPrompt(
+            node, state.planNode, pending.sceneIndex, pending.prompt,
+        );
+        if (pending.status) pending.status.textContent = pending.message;
+        dirty();
+    }
+
+    function schedulePlanEffects(pending) {
+        if (state.disposed) return;
+        state.planSyncPending = pending;
+        if (state.planSyncTimer != null) {
+            window.clearTimeout(state.planSyncTimer);
+        }
+        state.planSyncTimer = window.setTimeout(
+            flushPlanEffects, PROMPT_SYNC_DELAY_MS,
+        );
+        if (pending.status) pending.status.textContent = "Editing…";
+    }
+
+    function schedulePromptAnalysis() {
+        if (state.disposed) return;
+        if (state.analysisTimer != null) {
+            window.clearTimeout(state.analysisTimer);
+        }
+        state.analysisTimer = window.setTimeout(() => {
+            state.analysisTimer = null;
+            refreshAssistant();
+            state.schema?.refresh();
+        }, PROMPT_ANALYSIS_DELAY_MS);
+    }
+
+    function flushPromptAnalysis() {
+        if (state.analysisTimer == null) return;
+        window.clearTimeout(state.analysisTimer);
+        state.analysisTimer = null;
+        refreshAssistant();
+        state.schema?.refresh();
+    }
+
+    function commitPlan(
+        status, message = "Saved to connected Plan",
+        {deferEffects = false} = {},
+    ) {
+        const value = planToJson(state.plan);
+        state.lastValue = value;
+        state.planWidget.value = value;
+        const pending = {
+            value,
+            sceneIndex:state.active,
+            prompt:promptValueToText(state.plan.shots[state.active]?.prompt),
+            status,
+            message,
+        };
+        if (deferEffects) schedulePlanEffects(pending);
+        else {
+            state.planSyncPending = pending;
+            flushPlanEffects();
+        }
+    }
+
+    function writePlan(status, options = {}) {
+        if (!state.plan || !state.planWidget || !state.planNode) return;
+        // This node owns only one scene prompt. Rebase when another UI changed
+        // the live Plan so concurrent Studio edits are preserved, while
+        // consecutive keystrokes avoid reparsing the full JSON.
+        const liveValue = String(state.planWidget.value ?? "");
+        if (liveValue !== state.lastValue && !rebaseActivePromptOntoLivePlan()) {
+            if (status) status.textContent = "Plan structure changed; waiting to resynchronize";
+            return;
+        }
+        commitPlan(status, "Saved to connected Plan", options);
+    }
+
+    function planRunName() {
+        return String(state.planNode?.widgets?.find(
+            (item) => item.name === "run_name",
+        )?.value ?? "").trim();
+    }
+
+    function historySceneKey(runName, shotId) {
+        return `${runName}\u0000${shotId}`;
+    }
+
+    function promptUndoForScene(shotId, text, {external = false} = {}) {
+        const key = historySceneKey(planRunName(), shotId);
+        let history = state.undoByScene.get(key);
+        if (!history) {
+            history = new PromptUndoHistory(text);
+            state.undoByScene.set(key, history);
+        } else if (external) {
+            // Plan Studio republishes the active prompt after non-prompt edits.
+            // Preserve undo when that synchronized text did not actually change.
+            history.align(text);
+        } else {
+            history.align(text);
+        }
+        return history;
+    }
+
+    async function historyRequest(query = {}, body = null) {
+        const suffix = new URLSearchParams(query).toString();
+        const response = await api.fetchApi(
+            `/minimax_h3_context_loop/prompt-history${suffix ? `?${suffix}` : ""}`,
+            body == null ? undefined : {
+                method: "POST",
+                headers: {"Content-Type": "application/json"},
+                body: JSON.stringify(body),
+            },
+        );
+        let payload = {};
+        try {
+            payload = await response.json();
+        } catch (_error) {
+            // A proxy can replace a backend error with a non-JSON response.
+        }
+        if (!response.ok) {
+            throw new Error(payload.error || `Prompt history request failed (HTTP ${response.status}).`);
+        }
+        return payload;
+    }
+
+    function renderHistory() {
+        const history = state.history;
+        const host = history.host;
+        if (!host) return;
+        host.replaceChildren();
+        if (history.error) {
+            host.append(element("span", "h3sp-history-meta h3sp-history-error", history.error));
+            return;
+        }
+        if (!history.data) {
+            host.append(element("span", "h3sp-history-meta", "Loading prompt versions…"));
+            return;
+        }
+        const navigation = promptRevisionNavigation(history.data, history.revisionId);
+        const controls = element("span", "h3sp-history-nav");
+        const previous = button("‹", "Activate previous prompt version in the Plan", () => {
+            if (navigation.previous) void selectHistoryRevision(navigation.previous.id);
+        });
+        const count = element(
+            "span", "h3sp-history-count",
+            `Active ${navigation.position} / ${navigation.total}`,
+        );
+        const next = button("›", "Activate next prompt version in the Plan", () => {
+            if (navigation.next) void selectHistoryRevision(navigation.next.id);
+        });
+        previous.disabled = !navigation.previous;
+        next.disabled = !navigation.next;
+        controls.append(previous, count, next);
+        const treeDetails = renderHistoryTree();
+        const metadata = element(
+            "span", "h3sp-history-meta", promptRevisionLabel(navigation),
+        );
+        metadata.title = promptRevisionHelp(navigation);
+        host.append(controls, treeDetails, metadata);
+    }
+
+    function renderHistoryTree() {
+        const history = state.history;
+        const details = element("details", "h3sp-history-tree");
+        details.open = history.treeOpen;
+        const tree = promptRevisionTree(history.data, {
+            includeArchived: history.showArchived,
+        });
+        const summary = element("summary", "", `History (${tree.rows.length})`);
+        summary.title = "Show prompt ancestry, labels, and revision actions";
+        const panel = element("div", "h3sp-history-tree-panel");
+        for (const row of tree.rows) {
+            const rowHost = element(
+                "div",
+                `h3sp-history-tree-row${row.isActive ? " h3sp-history-active" : ""}${row.isArchived ? " h3sp-history-archived" : ""}`,
+            );
+            rowHost.style.paddingLeft = `${row.depth * 15}px`;
+            const select = button("", `Activate ${row.displayLabel} in the Plan`, () => {
+                if (!row.isActive) void selectHistoryRevision(row.revision.id);
+            });
+            select.className = "h3sp-history-tree-select";
+            select.disabled = row.isActive;
+            select.append(
+                element("span", "h3sp-history-branch", row.depth ? "↳" : "●"),
+                element("span", "h3sp-history-tree-label", row.displayLabel),
+                element(
+                    "span", "h3sp-history-tree-badge",
+                    row.isArchived ? "Archived"
+                        : row.isActive ? "Active"
+                            : row.isExecuted ? "Executed" : "Draft",
+                ),
+            );
+            const rename = button("Label", `Label ${row.displayLabel}`, () => {
+                const label = window.prompt(
+                    "Short label for this prompt revision (leave blank to clear):",
+                    String(row.revision.label ?? ""),
+                );
+                if (label != null) void mutateHistoryRevision(
+                    "label", row.revision.id, {label});
+            });
+            rename.className = "h3sp-history-tree-action";
+            rowHost.append(select, rename);
+            if (row.canRestore) {
+                const restore = button("Restore", `Restore ${row.displayLabel} to visible history`, () => {
+                    void mutateHistoryRevision("archive", row.revision.id, {archived:false});
+                });
+                restore.className = "h3sp-history-tree-action";
+                rowHost.append(restore);
+            } else if (row.canArchive) {
+                const archive = button("Archive", `Archive ${row.displayLabel}`, () => {
+                    void mutateHistoryRevision("archive", row.revision.id, {archived:true});
+                });
+                archive.className = "h3sp-history-tree-action";
+                rowHost.append(archive);
+            }
+            if (row.canDelete) {
+                const remove = button("Delete", `Delete unexecuted leaf ${row.displayLabel}`, () => {
+                    if (window.confirm(`Delete ${row.displayLabel}? This cannot be undone.`)) {
+                        void mutateHistoryRevision("delete", row.revision.id);
+                    }
+                });
+                remove.className = "h3sp-history-tree-action";
+                rowHost.append(remove);
+            }
+            panel.append(rowHost);
+        }
+        if (!tree.rows.length) {
+            panel.append(element("div", "h3sp-history-tree-tools", "No visible revisions"));
+        }
+        const tools = element("div", "h3sp-history-tree-tools");
+        tools.append(element(
+            "span", "",
+            "↳ shows parent → child progression",
+        ));
+        if (tree.archivedCount) {
+            tools.append(button(
+                history.showArchived ? "Hide archived" : `Show archived (${tree.archivedCount})`,
+                "Toggle archived prompt revisions",
+                () => {
+                    history.showArchived = !history.showArchived;
+                    history.treeOpen = true;
+                    renderHistory();
+                },
+            ));
+        }
+        panel.append(tools);
+        details.append(summary, panel);
+        details.addEventListener("toggle", () => {
+            history.treeOpen = details.open;
+        });
+        return details;
+    }
+
+    async function mutateHistoryRevision(action, revisionId, fields = {}) {
+        await flushHistoryDraft();
+        const history = state.history;
+        const shot = state.plan?.shots?.[state.active];
+        if (!shot) return;
+        const shotId = String(shot.id || `clip_${String(state.active + 1).padStart(4, "0")}`);
+        const runName = planRunName();
+        const key = historySceneKey(runName, shotId);
+        try {
+            const payload = await historyRequest({}, {
+                action,
+                run_name: runName,
+                scene_id: shotId,
+                revision: revisionId,
+                ...fields,
+            });
+            if (history.sceneKey !== key) return;
+            history.data = payload.history;
+            history.revisionId = payload.history?.active_revision ?? history.revisionId;
+            history.error = "";
+            renderHistory();
+        } catch (error) {
+            if (history.sceneKey !== key) return;
+            history.error = error?.message || String(error);
+            renderHistory();
+        }
+    }
+
+    async function loadHistory(shotId, prompt, synchronize = true) {
+        const runName = planRunName();
+        const history = state.history;
+        const key = historySceneKey(runName, shotId);
+        const token = ++history.loadToken;
+        history.sceneKey = key;
+        history.data = null;
+        history.revisionId = null;
+        history.error = "";
+        renderHistory();
+        if (!runName) {
+            history.error = "Set a Plan run_name to enable prompt history.";
+            renderHistory();
+            return;
+        }
+        const request = synchronize
+            ? historyRequest({}, {
+                action: "save",
+                run_name: runName,
+                scene_id: shotId,
+                prompt,
+                parent_revision: null,
+            })
+            : historyRequest({run_name: runName, scene_id: shotId});
+        history.loadPromise = request;
+        try {
+            const payload = await request;
+            if (token !== history.loadToken || history.sceneKey !== key) return;
+            history.data = payload.history ?? payload;
+            history.revisionId = payload.revision?.id
+                ?? history.data.active_revision ?? history.revisionId;
+            history.error = "";
+        } catch (error) {
+            if (token !== history.loadToken || history.sceneKey !== key) return;
+            history.error = error?.message || String(error);
+        } finally {
+            if (history.loadPromise === request) history.loadPromise = null;
+            if (token === history.loadToken && history.sceneKey === key) renderHistory();
+        }
+    }
+
+    function scheduleHistoryDraft(shotId, prompt) {
+        if (state.disposed) return;
+        const history = state.history;
+        const runName = planRunName();
+        if (!runName) return;
+        history.pendingDraft = {
+            key: historySceneKey(runName, shotId),
+            runName,
+            shotId,
+            prompt,
+        };
+        history.error = "";
+        if (history.saveTimer != null) window.clearTimeout(history.saveTimer);
+        history.saveTimer = window.setTimeout(() => {
+            history.saveTimer = null;
+            void flushHistoryDraft();
+        }, 650);
+    }
+
+    async function flushHistoryDraft() {
+        const history = state.history;
+        if (history.saveTimer != null) {
+            window.clearTimeout(history.saveTimer);
+            history.saveTimer = null;
+        }
+        if (history.savePromise) {
+            await history.savePromise;
+            return history.pendingDraft ? flushHistoryDraft() : undefined;
+        }
+        const draft = history.pendingDraft;
+        if (!draft) return;
+        history.pendingDraft = null;
+        if (history.loadPromise && history.sceneKey === draft.key) {
+            await history.loadPromise;
+        }
+        const parent = history.sceneKey === draft.key ? history.revisionId : null;
+        const request = historyRequest({}, {
+            action: "save",
+            run_name: draft.runName,
+            scene_id: draft.shotId,
+            prompt: draft.prompt,
+            parent_revision: parent,
+        });
+        history.savePromise = request;
+        try {
+            const payload = await request;
+            if (history.sceneKey === draft.key) {
+                history.data = payload.history;
+                history.revisionId = payload.revision?.id ?? payload.history?.active_revision;
+                history.error = "";
+                renderHistory();
+            }
+        } catch (error) {
+            if (history.sceneKey === draft.key) {
+                history.error = error?.message || String(error);
+                renderHistory();
+            }
+        } finally {
+            if (history.savePromise === request) history.savePromise = null;
+        }
+        if (history.pendingDraft) await flushHistoryDraft();
+    }
+
+    async function selectHistoryRevision(revisionId) {
+        await flushHistoryDraft();
+        const history = state.history;
+        const shot = state.plan?.shots?.[state.active];
+        if (!shot || !history.textarea) return;
+        const shotId = String(shot.id || `clip_${String(state.active + 1).padStart(4, "0")}`);
+        const runName = planRunName();
+        const key = historySceneKey(runName, shotId);
+        try {
+            const payload = await historyRequest({}, {
+                action: "activate",
+                run_name: runName,
+                scene_id: shotId,
+                revision: revisionId,
+            });
+            if (history.sceneKey !== key) return;
+            history.data = payload.history;
+            history.revisionId = payload.revision.id;
+            history.error = "";
+            history.textarea.value = String(payload.revision.prompt ?? "");
+            state.promptUndo?.record(history.textarea.value, {
+                inputType: "insertReplacementText",
+            });
+            renderRichEditorText(history.textarea.value);
+            shot.prompt = promptTextToLines(history.textarea.value);
+            writePlan(history.status);
+            if (history.status) history.status.textContent = "Loaded prompt version";
+            renderHistory();
+            history.textarea.focus();
+        } catch (error) {
+            if (history.sceneKey !== key) return;
+            history.error = error?.message || String(error);
+            renderHistory();
+        }
+    }
+
+    function messagesForProvider(provider = assistant.provider) {
+        const key = provider === "hermes" ? "hermes" : "codex";
+        assistant.messagesByProvider[key] ??= [];
+        return assistant.messagesByProvider[key];
+    }
+
+    function assistantMessage(role, text, provider = assistant.provider) {
+        const value = String(text ?? "").trim();
+        if (!value) return;
+        const messages = messagesForProvider(provider);
+        messages.push({role, text: value});
+        assistant.messagesByProvider[provider === "hermes" ? "hermes" : "codex"] = messages.slice(-24);
+    }
+
+    function clearAssistantReconnect() {
+        if (assistant.reconnectTimer != null) {
+            window.clearTimeout(assistant.reconnectTimer);
+            assistant.reconnectTimer = null;
+        }
+    }
+
+    function scheduleAssistantReconnect(delay = 500) {
+        if (!assistant.activeRequest || assistant.reconnectTimer != null) return;
+        assistant.reconnectTimer = window.setTimeout(async () => {
+            assistant.reconnectTimer = null;
+            if (!assistant.activeRequest) return;
+            try {
+                await assistant.client.connect();
+            } catch (_error) {
+                if (assistant.activeRequest) scheduleAssistantReconnect(1_000);
+            }
+        }, delay);
+    }
+
+    function persistPendingRequest(requestId, meta) {
+        try {
+            globalThis.sessionStorage?.setItem(assistant.pendingStorageKey, JSON.stringify({
+                requestId,
+                ...meta,
+            }));
+        } catch (_error) {
+            // Recovery across reload is best-effort; live correlation still works.
+        }
+    }
+
+    function clearPendingRequest(requestId = null) {
+        if (requestId && assistant.activeRequest && assistant.activeRequest !== requestId) return;
+        try { globalThis.sessionStorage?.removeItem(assistant.pendingStorageKey); } catch (_error) { /* unavailable */ }
+    }
+
+    function restorePendingRequest() {
+        let stored = null;
+        try {
+            stored = JSON.parse(globalThis.sessionStorage?.getItem(assistant.pendingStorageKey) || "null");
+        } catch (_error) {
+            clearPendingRequest();
+        }
+        if (!stored || typeof stored !== "object" || typeof stored.requestId !== "string") return;
+        const meta = {
+            sceneKey: String(stored.sceneKey || ""),
+            sceneId: String(stored.sceneId || ""),
+            sceneIndex: Number(stored.sceneIndex),
+            sourcePrompt: String(stored.sourcePrompt ?? ""),
+            sourceRevision: String(stored.sourceRevision || ""),
+            provider: stored.provider === "hermes" ? "hermes" : "codex",
+        };
+        if (!meta.sceneKey || !meta.sceneId || !Number.isInteger(meta.sceneIndex) || !meta.sourceRevision) {
+            clearPendingRequest();
+            return;
+        }
+        assistant.provider = meta.provider;
+        assistant.activeRequest = stored.requestId;
+        assistant.requestContexts.set(stored.requestId, meta);
+        assistant.status = "connecting";
+        assistant.statusDetail = "Reconnecting to recover the active draft…";
+        refreshAssistant();
+        scheduleAssistantReconnect(0);
+    }
+
+    function reconcileAssistantProvider() {
+        // A restored in-flight request remains owned by its original provider.
+        // Switching the visible lane during recovery would hide its reply in a
+        // different provider transcript.
+        if (assistant.activeRequest) return;
+        const selected = assistant.providers?.find((item) => item.id === assistant.provider);
+        if (selected?.available !== false) return;
+        const fallback = assistant.providers?.find((item) => item.available !== false);
+        if (!fallback || !["codex", "hermes"].includes(fallback.id)) return;
+        const unavailable = assistant.provider === "hermes" ? "Hermes" : "Codex";
+        assistant.provider = fallback.id;
+        node.properties[ASSIST_PROVIDER_PROPERTY] = assistant.provider;
+        assistantMessage("system", `${unavailable} is unavailable; using ${fallback.label || fallback.id}.`, assistant.provider);
+        dirty();
+    }
+
+    function assistantProviderAvailable(provider = assistant.provider) {
+        return assistant.providers?.find((item) => item.id === provider)?.available !== false;
+    }
+
+    function refreshAssistant() {
+        const host = assistant.host;
+        const promptTextarea = root.querySelector(".h3sp-textarea");
+        if (!host || !promptTextarea || !state.plan?.shots?.length) return;
+        renderAssistant(host, promptTextarea);
+    }
+
+    function handleAssistantFrame(frame) {
+        if (!frame || typeof frame !== "object") return;
+        if (frame.type === "prompt_assist_ready") {
+            assistant.providers = Array.isArray(frame.providers) ? frame.providers : null;
+            reconcileAssistantProvider();
+            assistant.error = "";
+        } else if (frame.type === "prompt_assist_started") {
+            if (frame.request_id === assistant.activeRequest) assistant.status = "working";
+        } else if (frame.type === "prompt_assist_progress") {
+            if (frame.request_id === assistant.activeRequest) assistant.statusDetail = "Agent is drafting…";
+        } else if (frame.type === "prompt_assist_result") {
+            // Accept only a request this editor incarnation has in its live or
+            // sessionStorage-restored correlation map. A disconnected "New
+            // chat" can reconnect to a buffered result before its reset frame
+            // reaches the server; reconstructing metadata from that result
+            // would resurrect a draft the user explicitly discarded.
+            const meta = assistant.requestContexts.get(frame.request_id);
+            if (!meta) return;
+            assistant.requestContexts.delete(frame.request_id);
+            if (assistant.activeRequest === frame.request_id) assistant.activeRequest = null;
+            clearPendingRequest(frame.request_id);
+            clearAssistantReconnect();
+            assistant.status = "connected";
+            assistant.statusDetail = "Connected · isolated prompt session";
+            assistant.error = "";
+            assistantMessage("agent", frame.message || "Draft ready.", meta.provider);
+            if (typeof frame.rewritten_prompt === "string" && frame.rewritten_prompt.trim()) {
+                assistant.drafts.set(meta.sceneKey, {
+                    sceneId: meta.sceneId,
+                    sceneIndex: meta.sceneIndex,
+                    sourcePrompt: meta.sourcePrompt,
+                    sourceRevision: meta.sourceRevision,
+                    proposed: frame.rewritten_prompt,
+                    provider: frame.provider || meta.provider,
+                });
+            } else if (typeof frame.rewritten_prompt === "string") {
+                assistant.error = "The agent returned an empty draft, so it was not staged.";
+            }
+        } else if (frame.type === "prompt_assist_error") {
+            const meta = assistant.requestContexts.get(frame.request_id);
+            if (frame.request_id && !meta && assistant.activeRequest !== frame.request_id) return;
+            if (meta) assistant.requestContexts.delete(frame.request_id);
+            if (!frame.request_id || assistant.activeRequest === frame.request_id) {
+                assistant.activeRequest = null;
+            }
+            clearPendingRequest(frame.request_id);
+            clearAssistantReconnect();
+            assistant.status = assistant.client?.socket?.readyState === WebSocket.OPEN
+                ? "connected" : "disconnected";
+            assistant.error = String(frame.error || "Prompt assistant failed.");
+            assistantMessage("system", `Agent error: ${assistant.error}`, meta?.provider);
+        } else if (frame.type === "prompt_assist_cancelled") {
+            const meta = assistant.requestContexts.get(frame.request_id);
+            if (!meta && assistant.activeRequest !== frame.request_id) return;
+            assistant.requestContexts.delete(frame.request_id);
+            if (assistant.activeRequest === frame.request_id) assistant.activeRequest = null;
+            clearPendingRequest(frame.request_id);
+            clearAssistantReconnect();
+            assistant.status = "connected";
+            assistant.statusDetail = "Stopped · ready for another request";
+            assistantMessage("system", "Request stopped. The scene prompt was not changed.", meta?.provider);
+        } else if (
+            frame.type === "prompt_assist_cancel_ack"
+            && frame.cancelled === false
+            && frame.request_id === assistant.activeRequest
+        ) {
+            // The orchestrator may have restarted while the browser retained a
+            // pending request. A negative correlated ack proves there is no
+            // server-side turn left to wait for.
+            const meta = assistant.requestContexts.get(frame.request_id);
+            assistant.requestContexts.delete(frame.request_id);
+            assistant.activeRequest = null;
+            clearPendingRequest(frame.request_id);
+            clearAssistantReconnect();
+            assistant.status = assistant.client?.socket?.readyState === WebSocket.OPEN
+                ? "connected" : "disconnected";
+            assistant.statusDetail = "No active server request · ready for another request";
+            assistant.error = "The prior request is no longer active, likely because the bridge restarted.";
+            assistantMessage("system", assistant.error, meta?.provider);
+        }
+        refreshAssistant();
+    }
+
+    async function sendAssistant(promptTextarea) {
+        if (assistant.activeRequest || assistant.preparingRequest || !state.plan?.shots?.length) return;
+        // Snapshot the selected scene before the asynchronous bridge handshake.
+        // Navigation remains usable while connecting; reading state.active and
+        // an old textarea after await could otherwise pair scene B's id with
+        // scene A's prompt.
+        const requestSceneIndex = state.active;
+        const requestShot = state.plan.shots[requestSceneIndex];
+        const sourcePrompt = promptTextarea.value;
+        const selectedText = sourcePrompt.slice(
+            promptTextarea.selectionStart ?? 0,
+            promptTextarea.selectionEnd ?? 0,
+        );
+        const context = buildPromptAssistantContext(
+            state.plan,
+            requestSceneIndex,
+            sourcePrompt,
+            {
+                includeShared: assistant.includeShared,
+                includeAdjacent: assistant.includeAdjacent,
+                selectedText,
+            },
+        );
+        const preparation = {};
+        assistant.preparingRequest = preparation;
+        assistant.status = "connecting";
+        assistant.statusDetail = "Connecting to comfyui-mcp…";
+        assistant.error = "";
+        refreshAssistant();
+        try {
+            // Wait for prompt_assist_ready before freezing the provider into the
+            // request. The ready frame may switch a persisted unavailable Hermes
+            // selection to Codex.
+            await assistant.client.connect();
+        } catch (error) {
+            // New chat may have invalidated this connect attempt while it was
+            // awaiting the handshake. In that case it owns no UI state.
+            if (assistant.preparingRequest !== preparation) return;
+            assistant.preparingRequest = null;
+            assistant.status = "disconnected";
+            assistant.error = error.message || String(error);
+            assistantMessage("system", `Could not connect: ${assistant.error}`);
+            refreshAssistant();
+            return;
+        }
+        if (assistant.preparingRequest !== preparation) return;
+        assistant.preparingRequest = null;
+        if (!assistantProviderAvailable()) {
+            assistant.error = `${assistant.provider === "hermes" ? "Hermes" : "Codex"} is unavailable.`;
+            refreshAssistant();
+            return;
+        }
+        const sceneId = String(requestShot.id || `clip_${String(requestSceneIndex + 1).padStart(4, "0")}`);
+        const sceneKey = promptSceneKey(sceneId, requestSceneIndex);
+        const requestId = `pa-${globalThis.crypto?.randomUUID?.()
+            ?? `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`}`;
+        const request = makePromptAssistRequest({
+            requestId,
+            conversationId: assistant.client.conversationId,
+            provider: assistant.provider,
+            mode: assistant.mode,
+            instruction: assistant.composer,
+            context,
+        });
+        assistant.requestContexts.set(requestId, {
+            sceneKey,
+            sceneId,
+            sceneIndex: requestSceneIndex,
+            sourcePrompt,
+            sourceRevision: request.source_revision,
+            provider: assistant.provider,
+        });
+        const requestMeta = assistant.requestContexts.get(requestId);
+        assistant.activeRequest = requestId;
+        persistPendingRequest(requestId, requestMeta);
+        assistant.status = "working";
+        assistant.statusDetail = `Asking ${assistant.provider === "hermes" ? "Hermes" : "Codex"}…`;
+        assistant.error = "";
+        assistantMessage("user", request.instruction);
+        assistant.composer = "";
+        refreshAssistant();
+        try {
+            await assistant.client.send(request);
+        } catch (error) {
+            if (assistant.activeRequest !== requestId) return;
+            assistant.activeRequest = null;
+            assistant.requestContexts.delete(requestId);
+            clearPendingRequest(requestId);
+            clearAssistantReconnect();
+            assistant.status = "disconnected";
+            assistant.error = error.message || String(error);
+            assistantMessage("system", `Could not send: ${assistant.error}`);
+            refreshAssistant();
+        }
+    }
+
+    function stopAssistant() {
+        if (!assistant.activeRequest) return;
+        if (!assistant.client.cancel(assistant.activeRequest)) {
+            assistant.error = "The bridge is disconnected; the local request may finish without being delivered.";
+            refreshAssistant();
+        } else {
+            assistant.statusDetail = "Stopping agent…";
+            refreshAssistant();
+        }
+    }
+
+    function resetAssistantChat() {
+        if (assistant.activeRequest) assistant.client.cancel(assistant.activeRequest);
+        assistant.client.reset();
+        assistant.activeRequest = null;
+        assistant.preparingRequest = null;
+        clearPendingRequest();
+        clearAssistantReconnect();
+        assistant.requestContexts.clear();
+        assistant.messagesByProvider = {codex: [], hermes: []};
+        assistant.error = "";
+        assistant.statusDetail = "New isolated conversation";
+        refreshAssistant();
+    }
+
+    function copyAssistantDraft(draft) {
+        const operation = navigator.clipboard?.writeText?.(draft.proposed);
+        if (!operation) {
+            assistant.error = "Clipboard access is unavailable. Select the proposed text and copy it manually.";
+            refreshAssistant();
+            return;
+        }
+        operation.then(() => {
+            assistantMessage("system", "Proposed prompt copied.");
+            refreshAssistant();
+        }).catch(() => {
+            assistant.error = "Clipboard access was refused. Select the proposed text and copy it manually.";
+            refreshAssistant();
+        });
+    }
+
+    function applyAssistantDraft(draft, promptTextarea, conflict) {
+        if (conflict.stale && !window.confirm(
+            `${conflict.reason}\n\nApply this draft anyway and replace the current scene prompt?`,
+        )) return;
+        const before = promptTextarea.value;
+        const after = draft.proposed;
+        if (!String(after).trim()) {
+            assistant.error = "An empty assistant draft cannot replace the scene prompt.";
+            refreshAssistant();
+            return;
+        }
+        assistant.lastApplied = {
+            sceneKey: promptSceneKey(draft.sceneId, draft.sceneIndex),
+            before,
+            after,
+        };
+        promptTextarea.value = after;
+        promptTextarea.dispatchEvent(new Event("input", {bubbles: true}));
+        assistant.drafts.delete(promptSceneKey(draft.sceneId, draft.sceneIndex));
+        assistantMessage("system", "Draft applied to the active scene and saved in the connected Plan.");
+        refreshAssistant();
+    }
+
+    function undoAssistantApply(promptTextarea, sceneKey) {
+        const undo = assistant.lastApplied;
+        if (!undo || undo.sceneKey !== sceneKey || promptTextarea.value !== undo.after) return;
+        promptTextarea.value = undo.before;
+        promptTextarea.dispatchEvent(new Event("input", {bubbles: true}));
+        assistant.lastApplied = null;
+        assistantMessage("system", "The last assistant apply was undone.");
+        refreshAssistant();
+    }
+
+    function renderAssistant(host, promptTextarea) {
+        host.replaceChildren();
+        const shot = state.plan.shots[state.active];
+        const sceneId = String(shot.id || `clip_${String(state.active + 1).padStart(4, "0")}`);
+        const sceneKey = promptSceneKey(sceneId, state.active);
+
+        const head = element("div", "h3sp-assist-head");
+        const heading = element("span", "h3sp-assist-title", "Prompt Assistant");
+        const busy = Boolean(assistant.activeRequest || assistant.preparingRequest);
+        const statusText = busy
+            ? assistant.statusDetail || "Agent is working…"
+            : assistant.statusDetail;
+        head.append(heading, element("span", "h3sp-assist-status", statusText));
+
+        const controls = element("div", "h3sp-assist-controls");
+        const provider = element("select");
+        provider.title = "Choose which isolated local agent handles this prompt turn.";
+        for (const [id, label] of [["codex", "Codex"], ["hermes", "Hermes"]]) {
+            const option = element("option", "", label);
+            option.value = id;
+            const available = assistant.providers?.find((item) => item.id === id)?.available;
+            if (available === false) {
+                option.textContent = `${label} (not found)`;
+                option.disabled = true;
+            }
+            provider.append(option);
+        }
+        provider.value = assistant.provider;
+        provider.disabled = busy;
+        provider.addEventListener("change", () => {
+            assistant.provider = provider.value;
+            node.properties[ASSIST_PROVIDER_PROPERTY] = assistant.provider;
+            persistView();
+            refreshAssistant();
+        });
+        const mode = element("select");
+        mode.title = "Choose the kind of help to request.";
+        for (const item of PROMPT_ASSIST_MODES) {
+            const option = element("option", "", item.label);
+            option.value = item.id;
+            mode.append(option);
+        }
+        mode.value = assistant.mode;
+        mode.disabled = busy;
+        mode.addEventListener("change", () => {
+            assistant.mode = mode.value;
+            node.properties[ASSIST_MODE_PROPERTY] = assistant.mode;
+            persistView();
+            refreshAssistant();
+        });
+        controls.append(provider, mode, button("New chat", "Clear agent conversation; staged drafts remain.", resetAssistantChat));
+
+        const chat = element("div", "h3sp-assist-chat");
+        const messages = messagesForProvider();
+        if (!messages.length) {
+            chat.append(element(
+                "div", "h3sp-assist-empty",
+                "Ask for a rewrite, continuity pass, critique, or a specific change. Nothing is applied until you press Apply.",
+            ));
+        } else {
+            for (const message of messages) {
+                chat.append(element(
+                    "div",
+                    `h3sp-assist-message h3sp-assist-message-${message.role}`,
+                    message.text,
+                ));
+            }
+            setTimeout(() => { chat.scrollTop = chat.scrollHeight; }, 0);
+        }
+
+        const draft = assistant.drafts.get(sceneKey);
+        let draftPanel = null;
+        if (draft) {
+            const conflict = draftConflict(draft, sceneId, promptTextarea.value);
+            draftPanel = element("div", "h3sp-assist-draft");
+            const draftHead = element("div", "h3sp-assist-draft-head");
+            draftHead.append(
+                element("span", "h3sp-assist-draft-title", `Staged ${draft.provider || "agent"} proposal`),
+                conflict.stale ? element("span", "h3sp-assist-stale", conflict.reason) : element("span"),
+            );
+            const proposed = element("textarea");
+            proposed.value = draft.proposed;
+            proposed.title = "You can edit the staged proposal before applying it.";
+            proposed.addEventListener("input", () => { draft.proposed = proposed.value; });
+            const original = element("details", "h3sp-assist-original");
+            original.append(
+                element("summary", "", "Compare with original"),
+                element("pre", "", draft.sourcePrompt),
+            );
+            const actions = element("div", "h3sp-assist-actions");
+            actions.append(
+                button(
+                    conflict.stale ? "Apply anyway…" : "Apply to scene",
+                    "Replace the real active scene prompt in the connected Plan.",
+                    () => applyAssistantDraft(draft, promptTextarea, conflict),
+                ),
+                button("Copy", "Copy the proposed prompt without changing the Plan.", () => copyAssistantDraft(draft)),
+                button("Discard", "Remove this staged proposal without changing the Plan.", () => {
+                    assistant.drafts.delete(sceneKey);
+                    refreshAssistant();
+                }),
+            );
+            draftPanel.append(draftHead, proposed, original, actions);
+        }
+
+        const contexts = element("div", "h3sp-assist-contexts");
+        const contextToggle = (label, checked, change, title) => {
+            const wrapper = element("label");
+            wrapper.title = title;
+            const input = element("input");
+            input.type = "checkbox";
+            input.checked = checked;
+            input.disabled = busy;
+            input.addEventListener("change", () => change(input.checked));
+            wrapper.append(input, document.createTextNode(label));
+            return wrapper;
+        };
+        contexts.append(
+            contextToggle("Shared prompt", assistant.includeShared, (value) => {
+                assistant.includeShared = value;
+            }, "Include the Plan's shared/global prompt as read-only context."),
+            contextToggle("Previous + next", assistant.includeAdjacent, (value) => {
+                assistant.includeAdjacent = value;
+            }, "Include adjacent scene prompts for continuity advice."),
+            element("span", "h3sp-assist-status", "Selected text is included automatically"),
+        );
+
+        const compose = element("div", "h3sp-assist-compose");
+        const composer = element("textarea");
+        composer.value = assistant.composer;
+        composer.placeholder = PROMPT_ASSIST_DEFAULT_INSTRUCTIONS[assistant.mode];
+        composer.disabled = busy;
+        composer.addEventListener("input", () => { assistant.composer = composer.value; });
+        composer.addEventListener("keydown", (event) => {
+            if ((event.ctrlKey || event.metaKey) && event.key === "Enter") {
+                event.preventDefault();
+                void sendAssistant(promptTextarea);
+            }
+        });
+        const send = button("Ask agent", "Send (Ctrl/Cmd+Enter). The response is staged, never auto-applied.", () => {
+            void sendAssistant(promptTextarea);
+        });
+        send.disabled = busy || !assistantProviderAvailable();
+        compose.append(composer, send);
+        if (assistant.activeRequest) {
+            compose.append(button("Stop", "Interrupt this prompt-assist request.", stopAssistant));
+        }
+
+        const error = assistant.error
+            ? element("div", "h3sp-assist-error", assistant.error) : null;
+        const undo = assistant.lastApplied;
+        const undoButton = undo?.sceneKey === sceneKey && promptTextarea.value === undo.after
+            ? button("Undo last apply", "Restore the prompt that existed before the last assistant Apply.", () => {
+                undoAssistantApply(promptTextarea, sceneKey);
+            }) : null;
+
+        host.append(head, controls, chat);
+        if (draftPanel) host.append(draftPanel);
+        host.append(contexts, compose);
+        if (undoButton) host.append(undoButton);
+        if (error) host.append(error);
+    }
+
+    function showFailure(message) {
+        state.completion?.destroy();
+        state.completion = null;
+        assistant.host = null;
+        state.promptTextarea = null;
+        state.richEditor = null;
+        state.history.host = null;
+        state.history.textarea = null;
+        state.history.status = null;
+        root.replaceChildren();
+        root.append(
+            element("div", "h3sp-title", "MiniMax H3 Scene Prompt Editor"),
+            element("div", "h3sp-error", message),
+            element("div", "h3sp-context", "Connect the Plan output to this node's plan input."),
+        );
+        hidePopover(true);
+    }
+
+    function navigate(offset, absolute = null, {synchronize = true, focus = true} = {}) {
+        if (!state.plan?.shots?.length) return;
+        flushPlanEffects();
+        flushPromptAnalysis();
+        const pending = state.sceneNavigation;
+        const from = pending && pending.planNode === state.planNode
+                && pending.runName === planRunName() ? pending.index : state.active;
+        const requested = absolute == null ? from + offset : Number(absolute);
+        if (!Number.isFinite(requested)) return;
+        const index = Math.max(0, Math.min(state.plan.shots.length - 1, Math.trunc(requested)));
+        const selection = {
+            planNode:state.planNode, runName:planRunName(),
+            sceneId:String(state.plan.shots[index]?.id ?? ""), index,
+        };
+        state.sceneNavigation = selection;
+        void (async () => {
+            await flushHistoryDraft();
+            // History IO can complete out of order. Only the latest selection
+            // may move this editor or broadcast a scene to its companions.
+            if (state.disposed || state.sceneNavigation !== selection
+                    || state.planNode !== selection.planNode
+                    || planRunName() !== selection.runName) return;
+            state.sceneNavigation = null;
+            const target = selection.sceneId
+                    && String(state.plan.shots[selection.index]?.id ?? "") !== selection.sceneId
+                ? state.plan.shots.findIndex(shot => String(shot?.id ?? "") === selection.sceneId)
+                : selection.index;
+            if (!state.plan.shots[target]) return;
+            state.active = target;
+            persistView();
+            render();
+            if (synchronize) publishCompanionScene(node, state.planNode, state.active);
+            if (focus) (state.decorated ? state.richEditor : state.promptTextarea)?.focus();
+        })();
+    }
+
+    async function appendScene() {
+        if (!state.plan || state.plan.shots.length >= MAX_SHOTS) return;
+        state.sceneNavigation = null;
+        flushPlanEffects();
+        flushPromptAnalysis();
+        await flushHistoryDraft();
+        // This is the one structural operation exposed by the focused editor.
+        // Start from the live Plan so Studio/timing edits cannot be overwritten,
+        // then append instead of inserting into the middle of an active chain.
+        if (!rebaseActivePromptOntoLivePlan()) return;
+        state.plan.shots.push(makeShot(state.plan.shots));
+        state.active = state.plan.shots.length - 1;
+        persistView();
+        commitPlan(null);
+        render();
+        publishCompanionScene(node, state.planNode, state.active);
+        (state.decorated ? state.richEditor : state.promptTextarea)?.focus();
+    }
+
+    function ensureTokenPopover() {
+        if (state.popover) return state.popover;
+        const popover = element("div", "h3sp-popover");
+        popover.hidden = true;
+        popover.addEventListener("mouseenter", () => {
+            if (state.popoverTimer != null) window.clearTimeout(state.popoverTimer);
+        });
+        popover.addEventListener("mouseleave", scheduleHidePopover);
+        for (const eventName of [
+            "pointerdown", "pointerup", "mousedown", "mouseup", "click", "dblclick",
+            "keydown", "keyup", "keypress", "wheel",
+        ]) {
+            popover.addEventListener(eventName, (event) => event.stopPropagation());
+        }
+        document.body.append(popover);
+        state.popover = popover;
+        return popover;
+    }
+
+    function hidePopover(force = false) {
+        if (state.popoverPinned && !force) return;
+        if (state.popoverTimer != null) {
+            window.clearTimeout(state.popoverTimer);
+            state.popoverTimer = null;
+        }
+        state.popoverPinned = false;
+        for (const media of state.popover?.querySelectorAll?.("audio,video") ?? []) {
+            media.pause?.();
+        }
+        if (state.popover) state.popover.hidden = true;
+    }
+
+    function scheduleHidePopover() {
+        if (state.popoverPinned) return;
+        if (state.popoverTimer != null) window.clearTimeout(state.popoverTimer);
+        state.popoverTimer = window.setTimeout(hidePopover, 140);
+    }
+
+    function positionTokenPopover(popover, anchor) {
+        popover.hidden = false;
+        const rect = anchor.getBoundingClientRect();
+        const width = Math.min(360, globalThis.innerWidth - 24);
+        popover.style.left = `${Math.max(
+            12, Math.min(globalThis.innerWidth - width - 12, rect.left),
+        )}px`;
+        popover.style.top = `${Math.max(12, Math.min(
+            globalThis.innerHeight - popover.offsetHeight - 12, rect.bottom + 7,
+        ))}px`;
+    }
+
+    function showTokenPopover(record, anchor) {
+        if (state.popoverPinned) return;
+        hidePopover(true);
+        const popover = ensureTokenPopover();
+        popover.replaceChildren(element("div", "h3sp-popover-title", record.token));
+        const mediaKind = record.kind === "picture" ? "image" : record.kind;
+        const media = referenceMediaPreview(record, mediaKind);
+        if (media.url) {
+            const mediaElement = element(
+                mediaKind === "image" ? "img" : mediaKind === "video" ? "video" : "audio",
+                "h3sp-popover-media",
+            );
+            mediaElement.src = media.url;
+            if (mediaKind !== "image") {
+                mediaElement.controls = true;
+                mediaElement.preload = "metadata";
+            } else {
+                mediaElement.alt = `Preview for ${record.token}`;
+            }
+            popover.append(mediaElement);
+        } else {
+            popover.append(element(
+                "div", "h3sp-popover-detail", "No browser-playable file preview was found upstream.",
+            ));
+        }
+        const sourceTitle = media.source?.title || nodeType(media.source) || "unresolved source";
+        popover.append(element(
+            "div", "h3sp-popover-detail",
+            `${record.kind.toUpperCase()} · scenes ${record.selector}\n` +
+            `${record.active ? "Active" : "Inactive"} in scene ${state.active + 1}\n` +
+            `Source: ${sourceTitle}`,
+        ));
+        positionTokenPopover(popover, anchor);
+    }
+
+    function recordSupportsNative(record) {
+        return record?.nativeToken !== null
+            && Boolean(String(record?.nativeToken ?? record?.token ?? ""));
+    }
+
+    function recordSupportsSemantic(record) {
+        return record?.kind === "picture" && Boolean(record?.tag)
+            && Boolean(record?.supportsSemantic || record?.semanticOnly);
+    }
+
+    function inlineReferenceCandidates(part) {
+        return state.records.filter((record) => {
+            if (state.referenceMode !== "tagged" && !record.active) return false;
+            return part.kind === "unknown" || record.kind === part.kind;
+        });
+    }
+
+    function showReferenceEditor(part, start, end, anchor) {
+        const candidates = inlineReferenceCandidates(part);
+        if (!candidates.length) return;
+        hidePopover(true);
+        state.popoverPinned = true;
+        const popover = ensureTokenPopover();
+        const editor = element("div", "h3sp-popover-editor");
+        editor.append(element("div", "h3sp-popover-title", "Replace reference"));
+
+        const referenceField = element("label", "h3sp-popover-field");
+        referenceField.append(element("span", "", "Reference"));
+        const referenceSelect = element("select");
+        for (let index = 0; index < candidates.length; index += 1) {
+            const record = candidates[index];
+            const option = element("option", "", record.token);
+            option.value = String(index);
+            if (record.label && record.label !== record.token) {
+                option.textContent = `${record.token} → ${record.label}`;
+            }
+            referenceSelect.append(option);
+        }
+        const currentIndex = Math.max(0, candidates.findIndex(
+            (record) => record === part.record
+                || (record.tag && record.tag === part.record?.tag)
+                || record.token === part.record?.token,
+        ));
+        referenceSelect.value = String(currentIndex);
+        referenceField.append(referenceSelect);
+
+        const modeField = element("label", "h3sp-popover-field");
+        modeField.append(element("span", "", "Syntax"));
+        const modeSelect = element("select");
+        modeField.append(modeSelect);
+
+        const timestampField = element("label", "h3sp-popover-field");
+        timestampField.append(element("span", "", "Time (sec)"));
+        const timestampInput = element("input");
+        timestampInput.type = "number";
+        timestampInput.min = "0";
+        timestampInput.step = "0.01";
+        timestampInput.placeholder = "blank = untimed";
+        timestampInput.value = part.timestamp == null
+            ? "" : String(part.timestamp);
+        timestampField.append(timestampInput);
+
+        const updateModes = (preferred = modeSelect.value) => {
+            const record = candidates[Number(referenceSelect.value)];
+            const native = recordSupportsNative(record);
+            const semantic = recordSupportsSemantic(record);
+            modeSelect.replaceChildren();
+            if (native) {
+                const option = element("option", "", "@ native");
+                option.value = "native";
+                modeSelect.append(option);
+            }
+            if (semantic) {
+                const option = element("option", "", "# semantic (time optional)");
+                option.value = "semantic";
+                modeSelect.append(option);
+            }
+            modeSelect.value = [...modeSelect.options].some(
+                (option) => option.value === preferred,
+            ) ? preferred : semantic && !native ? "semantic" : "native";
+            timestampField.hidden = modeSelect.value !== "semantic";
+            modeField.hidden = modeSelect.options.length < 2;
+        };
+        referenceSelect.addEventListener("change", () => updateModes());
+        modeSelect.addEventListener("change", () => {
+            timestampField.hidden = modeSelect.value !== "semantic";
+        });
+        updateModes(part.semantic ? "semantic" : "native");
+        editor.append(referenceField, modeField, timestampField);
+
+        const actions = element("div", "h3sp-popover-actions");
+        const cancel = element("button", "", "Cancel");
+        cancel.type = "button";
+        cancel.addEventListener("click", () => hidePopover(true));
+        const apply = element("button", "", "Apply");
+        apply.type = "button";
+        apply.addEventListener("click", () => {
+            const record = candidates[Number(referenceSelect.value)];
+            const mode = modeSelect.value;
+            const timestampText = timestampInput.value.trim();
+            const timestamp = timestampText === ""
+                ? null : Number(timestampText);
+            const current = activePromptText();
+            if (current.slice(start, end) !== part.text) {
+                hidePopover(true);
+                renderRichEditorText(current);
+                return;
+            }
+            const next = replacePromptReferenceOccurrence(
+                current, start, end, record, mode, timestamp,
+            );
+            const replacement = referenceReplacementToken(
+                record, mode, timestamp,
+            );
+            hidePopover(true);
+            if (!state.richEditor || !replacement || next === current) return;
+            renderRichEditorText(next, start + replacement.length);
+            state.richEditor.dispatchEvent(new InputEvent("input", {
+                bubbles:true, inputType:"insertReplacementText",
+            }));
+            const referenceData = availableReferenceRecords(
+                node, state.active + 1, {
+                    includeInactive:true,
+                    prompt:[sharedPrompt(state.plan).text.trim(), next.trim()]
+                        .filter(Boolean).join("\n\n"),
+                },
+            );
+            state.records = referenceData.records;
+            state.referenceMode = referenceData.mode;
+            renderRichEditorText(next, start + replacement.length);
+            if (state.referenceTray) renderReferenceTray(state.referenceTray);
+            state.richEditor.focus();
+        });
+        actions.append(cancel, apply);
+        editor.append(actions);
+        editor.addEventListener("keydown", (event) => {
+            if (event.key === "Escape") {
+                event.preventDefault();
+                cancel.click();
+            } else if (event.key === "Enter") {
+                event.preventDefault();
+                apply.click();
+            }
+        });
+        popover.replaceChildren(editor);
+        positionTokenPopover(popover, anchor);
+        referenceSelect.focus();
+    }
+
+    function makeRichToken(part, start, end) {
+        if (part.type === "text") return document.createTextNode(part.text);
+        const kind = part.type === "reference" ? part.kind : part.type;
+        const token = element("span", `h3sp-token h3sp-token-${kind}`);
+        token.contentEditable = "false";
+        token.dataset.token = part.text;
+        if (["subject", "speaker", "dialogue", "flow"].includes(part.type)) {
+            token.dataset.h3PromptMarker = "";
+            token.tabIndex = 0;
+            token.setAttribute("role", "button");
+            token.addEventListener("keydown", (event) => {
+                if (event.key !== "Enter" && event.key !== " ") return;
+                event.preventDefault();
+                event.stopPropagation();
+                token.click();
+            });
+        }
+        if (part.unresolved) token.classList.add("h3sp-token-unknown");
+        if (part.record && !part.record.active) token.classList.add("h3sp-token-inactive");
+        if (part.type === "section") {
+            token.append(element("span", "h3sp-token-label", part.text));
+            token.title = `H3 section · ${part.section}`;
+            return token;
+        }
+        const mediaKind = kind === "picture" ? "image" : kind;
+        const media = part.record
+            ? referenceMediaPreview(part.record, mediaKind) : null;
+        if (kind === "picture" && media?.url) {
+            const thumbnail = element("img", "h3sp-token-thumb");
+            thumbnail.src = media.url;
+            thumbnail.alt = "";
+            token.append(thumbnail);
+        } else {
+            token.append(icon(kind));
+        }
+        token.append(element("span", "h3sp-token-label", part.text));
+        if (part.record) {
+            token.title = part.type === "reference"
+                ? `${part.text} · click to replace or edit; hover for preview`
+                : `${part.text} · hover for ${kind} preview`;
+            token.addEventListener("mouseenter", () => showTokenPopover(part.record, token));
+            token.addEventListener("mouseleave", scheduleHidePopover);
+            token.addEventListener("focus", () => showTokenPopover(part.record, token));
+        } else {
+            token.title = part.type === "reference"
+                ? "Unresolved reference in this scene · click to replace"
+                : token.dataset.h3PromptMarker !== undefined
+                  ? "Click to replace or remove this prompt token" : part.text;
+        }
+        if (part.type === "reference") {
+            token.tabIndex = 0;
+            token.addEventListener("click", (event) => {
+                event.preventDefault();
+                event.stopPropagation();
+                showReferenceEditor(part, start, end, token);
+            });
+            token.addEventListener("keydown", (event) => {
+                if (event.key !== "Enter" && event.key !== " ") return;
+                event.preventDefault();
+                showReferenceEditor(part, start, end, token);
+            });
+        }
+        return token;
+    }
+
+    function renderRichEditorText(text, caret = null, editableSelection = null) {
+        if (!state.richEditor) return;
+        const scrollTop = state.richEditor.scrollTop;
+        const scrollLeft = state.richEditor.scrollLeft;
+        const parts = tokenizeRichPrompt(String(text ?? ""), state.records);
+        const fragment = document.createDocumentFragment();
+        let sourceOffset = 0;
+        for (let index = 0; index < parts.length; index += 1) {
+            const part = parts[index];
+            const partStart = sourceOffset;
+            const partEnd = partStart + part.text.length;
+            sourceOffset = partEnd;
+            const unfinished = part.type === "reference" && part.unresolved
+                && part.text.startsWith("@") && index === parts.length - 1
+                && document.activeElement === state.richEditor;
+            const editingSemanticTime = part.type === "reference" && part.semantic
+                && editableSelection?.selectionStart >= partStart
+                && editableSelection?.selectionEnd <= partEnd;
+            fragment.append(unfinished || editingSemanticTime
+                ? document.createTextNode(part.text)
+                : makeRichToken(part, partStart, partEnd));
+        }
+        state.richEditor.replaceChildren(fragment);
+        if (editableSelection?.selectionStart != null
+                && editableSelection?.selectionEnd != null) {
+            restoreTextSelection(
+                state.richEditor,
+                editableSelection.selectionStart,
+                editableSelection.selectionEnd,
+            );
+        } else if (caret != null) restoreCaret(state.richEditor, caret);
+        // replaceChildren resets a contenteditable's viewport. Prompt edits,
+        // undo/redo, and reference refreshes must not throw the reader back to
+        // the first line of a long scene.
+        state.richEditor.scrollTop = scrollTop;
+        state.richEditor.scrollLeft = scrollLeft;
+    }
+
+    function rememberPromptSelection() {
+        if (state.decorated && state.richEditor) {
+            const selected = editorSelectionOffsets(state.richEditor);
+            if (selected) state.promptSelection = {kind:"rich", ...selected};
+        } else if (state.promptTextarea) {
+            const start = state.promptTextarea.selectionStart;
+            const end = state.promptTextarea.selectionEnd;
+            if (start != null && end != null) {
+                state.promptSelection = {kind:"plain", start, end};
+            }
+        }
+    }
+
+    function insertPromptText(text, selectSemanticTimestamp = false) {
+        const inserted = String(text ?? "");
+        selectSemanticTimestamp = Boolean(
+            selectSemanticTimestamp && inserted.includes("[")
+            && inserted.includes("s]"));
+        if (state.decorated && state.richEditor) {
+            const current = editorPlainText(state.richEditor);
+            const live = document.activeElement === state.richEditor
+                ? editorSelectionOffsets(state.richEditor) : null;
+            const saved = state.promptSelection?.kind === "rich"
+                ? state.promptSelection : null;
+            const selected = live ?? saved ?? {
+                start:current.length, end:current.length,
+            };
+            const insertionStart = Math.max(
+                0, Math.min(current.length, Number(selected.start) || 0),
+            );
+            const insertionEnd = Math.max(
+                insertionStart,
+                Math.min(current.length, Number(selected.end) || insertionStart),
+            );
+            const next = current.slice(0, insertionStart)
+                + inserted + current.slice(insertionEnd);
+            refreshReferenceState(next);
+            if (selectSemanticTimestamp) {
+                const first = inserted.indexOf("[") + 1;
+                const last = inserted.lastIndexOf("s]");
+                renderRichEditorText(next, null, {
+                    selectionStart:insertionStart + first,
+                    selectionEnd:insertionStart + last,
+                });
+                state.promptSelection = {
+                    kind:"rich",
+                    start:insertionStart + first,
+                    end:insertionStart + last,
+                };
+            } else {
+                const caret = insertionStart + inserted.length;
+                renderRichEditorText(next, caret);
+                state.promptSelection = {kind:"rich", start:caret, end:caret};
+            }
+            state.richEditor.dispatchEvent(new InputEvent("input", {
+                bubbles:true, inputType:"insertText",
+            }));
+            state.richEditor.focus();
+        } else if (state.promptTextarea) {
+            const saved = state.promptSelection?.kind === "plain"
+                ? state.promptSelection : null;
+            const insertionStart = saved?.start
+                ?? state.promptTextarea.selectionStart
+                ?? state.promptTextarea.value.length;
+            const insertionEnd = saved?.end
+                ?? state.promptTextarea.selectionEnd
+                ?? insertionStart;
+            state.promptTextarea.setSelectionRange(insertionStart, insertionEnd);
+            insertText(state.promptTextarea, inserted);
+            if (selectSemanticTimestamp) {
+                const first = inserted.indexOf("[") + 1;
+                const last = inserted.lastIndexOf("s]");
+                state.promptTextarea.setSelectionRange(
+                    insertionStart + first, insertionStart + last,
+                );
+                state.promptSelection = {
+                    kind:"plain",
+                    start:insertionStart + first,
+                    end:insertionStart + last,
+                };
+            } else {
+                const caret = insertionStart + inserted.length;
+                state.promptSelection = {kind:"plain", start:caret, end:caret};
+            }
+        }
+    }
+
+    function referenceSyntaxKey(record) {
+        const shot = state.plan?.shots?.[state.active];
+        return `${String(shot?.id ?? state.active)}:${record.tag}`;
+    }
+
+    function activePromptText() {
+        return state.decorated && state.richEditor
+            ? editorPlainText(state.richEditor)
+            : state.promptTextarea?.value ?? "";
+    }
+
+    function refreshReferenceState(prompt = activePromptText()) {
+        if (!state.plan?.shots?.length) {
+            state.records = [];
+            state.referenceMode = null;
+            return {wrapper:null, mode:null, records:[]};
+        }
+        const referenceData = availableReferenceRecords(
+            node, state.active + 1, {
+                includeInactive:true,
+                prompt:[
+                    sharedPrompt(state.plan).text.trim(),
+                    String(prompt ?? "").trim(),
+                ].filter(Boolean).join("\n\n"),
+            },
+        );
+        state.records = referenceData.records;
+        state.referenceMode = referenceData.mode;
+        return referenceData;
+    }
+
+    function selectedReferenceSyntax(record) {
+        if (state.referenceMode !== "tagged") return "native";
+        if (record.semanticOnly) return "semantic";
+        if (!record.supportsSemantic) return "native";
+        const promptMode = taggedPictureReferenceMode(
+            activePromptText(), record.tag,
+        );
+        if (promptMode === "native" || promptMode === "semantic") {
+            return promptMode;
+        }
+        return state.referenceSyntax.get(referenceSyntaxKey(record)) ?? "native";
+    }
+
+    function convertReferenceSyntax(record, mode, refs) {
+        state.referenceSyntax.set(referenceSyntaxKey(record), mode);
+        const current = activePromptText();
+        const next = convertTaggedPictureReference(current, record.tag, mode);
+        if (next !== current) {
+            if (state.decorated && state.richEditor) {
+                renderRichEditorText(next, next.length);
+                state.richEditor.dispatchEvent(new InputEvent("input", {
+                    bubbles:true, inputType:"insertReplacementText",
+                }));
+            } else if (state.promptTextarea) {
+                state.promptTextarea.value = next;
+                state.promptTextarea.dispatchEvent(new InputEvent("input", {
+                    bubbles:true, inputType:"insertReplacementText",
+                }));
+            }
+        }
+        renderReferenceTray(refs);
+    }
+
+    function insertPromptDialogue() {
+        if (state.decorated && state.richEditor) {
+            const selection = globalThis.getSelection?.();
+            const selected = selection?.rangeCount ? selection.toString() : "";
+            insertPromptText(`<d>${selected}</d>`);
+        } else if (state.promptTextarea) {
+            insertDialogue(state.promptTextarea);
+        }
+    }
+
+    function showReferencePreview(record, preview) {
+        preview.replaceChildren();
+        preview.classList.add("h3sp-visible");
+        const mediaKind = record.kind === "picture" ? "image" : record.kind;
+        const media = referenceMediaPreview(record, mediaKind);
+        if (media.url) {
+            const mediaElement = element(mediaKind === "image" ? "img"
+                : mediaKind === "video" ? "video" : "audio",
+            "h3sp-ref-preview-media");
+            mediaElement.src = media.url;
+            if (mediaKind !== "image") {
+                mediaElement.controls = true;
+                mediaElement.preload = "metadata";
+            } else {
+                mediaElement.alt = `Preview for ${record.token}`;
+                mediaElement.loading = "lazy";
+            }
+            preview.append(mediaElement);
+        } else {
+            preview.append(element(
+                "div", "h3sp-ref-preview-copy",
+                "No browser-playable source was found. Dynamic tensors can " +
+                "still run in the generation graph, but need an upstream loaded file for an editor preview.",
+            ));
+        }
+
+        const sourceTitle = media.source?.title || nodeType(media.source) || "unresolved source";
+        const mapping = record.label
+            ? `${record.label} in scene ${state.active + 1}`
+            : record.semanticActive
+                ? `semantic anchor active in scene ${state.active + 1}`
+                : `inactive in scene ${state.active + 1}`;
+        const syntax = selectedReferenceSyntax(record);
+        const displayToken = syntax === "semantic"
+            ? taggedPictureReferenceToken(record.tag, "semantic")
+            : record.token;
+        const previewTitle = record.mode === "native"
+            ? displayToken : `${displayToken} → ${mapping}`;
+        const copy = element("div", "h3sp-ref-preview-copy");
+        copy.append(
+            element("div", "h3sp-ref-preview-title", previewTitle),
+            document.createTextNode(
+                `\n${record.kind.toUpperCase()} · ${record.selector === "prompt tag" ? "activated by prompt tag" : `scenes ${record.selector}`}` +
+                `\nSource: ${sourceTitle}`,
+            ),
+        );
+        preview.append(copy);
+    }
+
+    function renderReferenceTray(refs) {
+        refs.replaceChildren();
+        const referenceData = refreshReferenceState(activePromptText());
+        const {mode, wrapper} = referenceData;
+        const records = mode === "tagged"
+            ? referenceData.records
+            : referenceData.records.filter((record) => record.active);
+        const preview = element("div", "h3sp-ref-preview");
+        if (!records.length) {
+            refs.append(element(
+                "div", "h3sp-ref-help",
+                wrapper
+                    ? `No connected references are active in scene ${state.active + 1}.`
+                    : "No connected Tagged/Scheduled Ref2VA, core Ref2VA, or core I2V/FL2V references were found. The menu does not invent unavailable labels.",
+            ));
+            return;
+        }
+
+        const help = mode === "tagged"
+            ? "Prompt-driven references. Picture previews switch and convert between " +
+              "native @tag and Qwen-only #tag; add [time] for explicit placement. " +
+              "Video and audio stay native-only. " +
+              "Audio never autoplays."
+            : mode === "scheduled"
+            ? `Scheduled references for scene ${state.active + 1}. Hover to preview; ` +
+              "click to insert the optional stable @alias. It compiles to a native label; " +
+              "the scheduler inserts no prompt text. Audio never autoplays."
+            : mode === "native_keyframes"
+              ? `Core I2V/FL2V keyframes for scene ${state.active + 1}. ` +
+                "A first-scene gate is shown inactive on continuations. " +
+                "Hover to preview; click to insert the native Picture label."
+              : "Core Ref2VA references. Hover to preview; click to insert the " +
+                "native label. Audio never autoplays.";
+        refs.append(element("div", "h3sp-ref-help", help));
+        const icons = {picture: "▧", video: "▶", audio: "♫"};
+        for (const record of records) {
+            const aliasMode = mode === "scheduled" || mode === "tagged";
+            const mapping = aliasMode && record.label
+                ? ` → ${record.label}` : "";
+            const syntax = selectedReferenceSyntax(record);
+            const displayToken = syntax === "semantic"
+                ? taggedPictureReferenceToken(record.tag, "semantic")
+                : record.token;
+            const entry = element("div", "h3sp-ref-entry");
+            const chip = button(
+                `${icons[record.kind] ?? "@"} ${displayToken}${mapping}`,
+                aliasMode
+                    ? `Insert ${displayToken}; it activates this reference in this scene.`
+                    : `Insert ${record.token} for the connected core conditioning input.`,
+                () => {
+                    insertPromptText(displayToken, syntax === "semantic");
+                    refs.classList.remove("h3sp-open");
+                },
+            );
+            chip.classList.add("h3sp-ref-chip");
+            chip.classList.toggle("h3sp-active", record.active);
+            chip.addEventListener("mouseenter", () => showReferencePreview(record, preview));
+            chip.addEventListener("focus", () => showReferencePreview(record, preview));
+            entry.append(chip);
+            if (mode === "tagged" && record.supportsSemantic) {
+                const usedMode = taggedPictureReferenceMode(
+                    activePromptText(), record.tag,
+                );
+                const modes = element("div", "h3sp-ref-mode");
+                const native = button("@", "Use native @tag and convert semantic anchors in this scene", () => {
+                    convertReferenceSyntax(record, "native", refs);
+                });
+                const semantic = button("#", "Use untimed Qwen-only #tag; add [time] for placement", () => {
+                    convertReferenceSyntax(record, "semantic", refs);
+                });
+                native.classList.toggle(
+                    "h3sp-selected", syntax === "native" || usedMode === "mixed",
+                );
+                semantic.classList.toggle(
+                    "h3sp-selected", syntax === "semantic" || usedMode === "mixed",
+                );
+                modes.append(native, semantic);
+                entry.append(modes);
+            }
+            refs.append(entry);
+        }
+        refs.append(preview);
+        showReferencePreview(records[0], preview);
+    }
+
+    function render() {
+        if (!state.plan?.shots?.length) {
+            showFailure("The connected Plan has no scenes.");
+            return;
+        }
+        hidePopover(true);
+        state.completion?.destroy();
+        state.completion = null;
+        state.schema = null;
+        state.active = Math.max(0, Math.min(state.active, state.plan.shots.length - 1));
+        root.style.setProperty("--h3sp-font-size", `${state.fontSize}px`);
+        assistant.host = null;
+        root.replaceChildren();
+
+        const shot = state.plan.shots[state.active];
+        const shotId = String(shot.id || `clip_${String(state.active + 1).padStart(4, "0")}`);
+        const head = element("div", "h3sp-head");
+        head.append(
+            element("span", "h3sp-title", "Scene Prompt Editor"),
+            element("span", "h3sp-context", sharedPrompt(state.plan).text.trim()
+                ? "Shared prompt active (unchanged)" : "No shared prompt"),
+        );
+
+        const nav = element("div", "h3sp-nav");
+        const previous = button("←", "Previous scene (Alt+Left)", () => navigate(-1));
+        const next = button("→", "Next scene (Alt+Right)", () => navigate(1));
+        const add = button("+", "Append a new scene and select it", () => void appendScene());
+        previous.disabled = state.active === 0;
+        next.disabled = state.active === state.plan.shots.length - 1;
+        add.disabled = state.plan.shots.length >= MAX_SHOTS;
+        const sceneSelect = element("select");
+        for (let index = 0; index < state.plan.shots.length; index += 1) {
+            const option = element("option", "", `Scene ${index + 1} — ${state.plan.shots[index].id || `clip_${String(index + 1).padStart(4, "0")}`}`);
+            option.value = String(index);
+            sceneSelect.append(option);
+        }
+        sceneSelect.value = String(state.active);
+        sceneSelect.title = "Jump directly to another scene prompt.";
+        sceneSelect.addEventListener("change", () => navigate(0, sceneSelect.value));
+
+        const font = element("div", "h3sp-font");
+        const fontValue = element("span", "h3sp-font-value", `${state.fontSize}px`);
+        const smaller = button("A−", "Decrease editor font size", () => {
+            state.fontSize = clamp(state.fontSize - 2, MIN_FONT_SIZE, MAX_FONT_SIZE, DEFAULT_FONT_SIZE);
+            persistView();
+            render();
+        });
+        const larger = button("A+", "Increase editor font size", () => {
+            state.fontSize = clamp(state.fontSize + 2, MIN_FONT_SIZE, MAX_FONT_SIZE, DEFAULT_FONT_SIZE);
+            persistView();
+            render();
+        });
+        smaller.disabled = state.fontSize <= MIN_FONT_SIZE;
+        larger.disabled = state.fontSize >= MAX_FONT_SIZE;
+        font.append(smaller, fontValue, larger);
+        nav.append(previous, sceneSelect, next, add, font);
+
+        const textarea = element("textarea", "h3sp-textarea");
+        textarea.value = promptValueToText(shot.prompt, `Scene ${state.active + 1} prompt`);
+        textarea.placeholder = "Write this scene's action, camera, performance, dialogue, and ending continuity…";
+        textarea.spellcheck = true;
+        textarea.title = "This is the actual active scene prompt in the connected H3 Chain Plan.";
+        textarea.classList.toggle("h3sp-hidden", state.decorated);
+        state.promptTextarea = textarea;
+        state.promptUndo = promptUndoForScene(shotId, textarea.value);
+
+        const referenceData = availableReferenceRecords(
+            node, state.active + 1, {includeInactive:true, prompt: [
+                sharedPrompt(state.plan).text.trim(), textarea.value.trim(),
+            ].filter(Boolean).join("\n\n")});
+        state.records = referenceData.records;
+        state.referenceMode = referenceData.mode;
+        const editorShell = element("div", "h3sp-editor-shell");
+        editorShell.classList.toggle("h3sp-hidden", !state.decorated);
+        const richEditor = element("div", "h3sp-rich-editor");
+        richEditor.contentEditable = "true";
+        richEditor.spellcheck = true;
+        richEditor.tabIndex = 0;
+        richEditor.setAttribute("role", "textbox");
+        richEditor.setAttribute("aria-multiline", "true");
+        richEditor.dataset.placeholder = textarea.placeholder;
+        richEditor.title = textarea.title;
+        state.richEditor = richEditor;
+        renderRichEditorText(textarea.value);
+        editorShell.append(richEditor);
+        state.promptSelection = {
+            kind:state.decorated ? "rich" : "plain",
+            start:textarea.value.length,
+            end:textarea.value.length,
+        };
+
+        const tools = element("div", "h3sp-tools");
+        const refs = element("div", "h3sp-refs");
+        state.referenceTray = refs;
+        const referenceButton = button(
+            "@ Reference",
+            "Browse connected Ref2VA media; typing @ opens inline autocomplete",
+            () => {
+                state.completion?.hide();
+                const opening = !refs.classList.contains("h3sp-open");
+                if (opening) renderReferenceTray(refs);
+                refs.classList.toggle("h3sp-open", opening);
+            },
+        );
+        referenceButton.addEventListener("pointerdown", rememberPromptSelection);
+        const dialogueButton = button("Dialogue", "Wrap selection in <d> dialogue tags", () => {
+            insertPromptDialogue();
+        });
+        const presentationButton = button(
+            state.decorated ? "Rich text" : "Plain text",
+            state.decorated
+                ? "Show the same prompt as plain text"
+                : "Color recognized H3 references, subjects, and dialogue tags",
+            () => {
+                if (state.decorated && state.richEditor) {
+                    textarea.value = editorPlainText(state.richEditor);
+                }
+                state.decorated = !state.decorated;
+                persistView();
+                render();
+                (state.decorated ? state.richEditor : state.promptTextarea)?.focus();
+            },
+        );
+        presentationButton.classList.toggle("h3sp-presentation-active", state.decorated);
+        tools.append(
+            referenceButton,
+            dialogueButton,
+            presentationButton,
+            element("span", "h3sp-hint",
+                "Alt+←/→ scenes · type @ # < [ ( · Ctrl/Cmd+Space for all"),
+        );
+        const footer = element("div", "h3sp-footer");
+        const identity = element(
+            "span", "", `Scene ${state.active + 1}/${state.plan.shots.length} · ${shotId}`,
+        );
+        const status = element("span", "h3sp-footer-status", "Synchronized with Plan");
+        const historyHost = element("div", "h3sp-history");
+        footer.append(identity, historyHost, status);
+        state.history.host = historyHost;
+        state.history.textarea = textarea;
+        state.history.status = status;
+
+        const applyPromptUndo = (direction, target) => {
+            const text = state.promptUndo?.[direction]?.();
+            if (text == null) return false;
+            const scrollTop = target.scrollTop;
+            const scrollLeft = target.scrollLeft;
+            const richCaret = target === richEditor
+                ? selectionTextOffset(richEditor) : null;
+            textarea.value = text;
+            shot.prompt = promptTextToLines(text);
+            writePlan(status);
+            scheduleHistoryDraft(shotId, text);
+            renderRichEditorText(
+                text,
+                richCaret == null ? null : Math.min(richCaret, text.length),
+            );
+            if (target === textarea) textarea.setSelectionRange(text.length, text.length);
+            target.focus({preventScroll:true});
+            target.scrollTop = scrollTop;
+            target.scrollLeft = scrollLeft;
+            refreshAssistant();
+            state.schema?.refresh();
+            return true;
+        };
+        state.ownsPromptHistoryTarget = (target) => (
+            target === textarea || target === richEditor || richEditor.contains(target)
+        );
+        state.applyPromptHistoryShortcut = (direction, target) => applyPromptUndo(
+            direction, target === textarea ? textarea : richEditor,
+        );
+        const handlePromptUndo = (event, target) => {
+            const direction = promptUndoDirection(event);
+            if (!direction) return false;
+            event.preventDefault();
+            applyPromptUndo(direction, target);
+            return true;
+        };
+
+        textarea.addEventListener("input", (event) => {
+            state.promptUndo?.record(textarea.value, {
+                inputType:event.inputType || state.richInputType,
+            });
+            shot.prompt = promptTextToLines(textarea.value);
+            writePlan(status, {deferEffects:true});
+            scheduleHistoryDraft(shotId, textarea.value);
+            if (document.activeElement !== richEditor) renderRichEditorText(textarea.value);
+            state.completion?.refresh();
+            schedulePromptAnalysis();
+        });
+        for (const eventName of ["focus", "pointerup", "keyup", "select"]) {
+            textarea.addEventListener(eventName, rememberPromptSelection);
+        }
+        textarea.addEventListener("keydown", (event) => {
+            if (state.completion?.handleKeydown(event)) {
+                return;
+            } else if (handlePromptUndo(event, textarea)) {
+                return;
+            } else if (event.altKey && event.key === "ArrowLeft") {
+                event.preventDefault();
+                navigate(-1);
+            } else if (event.altKey && event.key === "ArrowRight") {
+                event.preventDefault();
+                navigate(1);
+            }
+        });
+        textarea.addEventListener("blur", () => {
+            flushPlanEffects();
+            flushPromptAnalysis();
+        });
+
+        richEditor.addEventListener("input", (event) => {
+            state.richInputType = event.inputType || "";
+            try {
+                textarea.value = editorPlainText(richEditor);
+                textarea.dispatchEvent(new Event("input", {bubbles: true}));
+            } finally {
+                state.richInputType = "";
+            }
+        });
+        for (const eventName of ["focus", "pointerup", "keyup"]) {
+            richEditor.addEventListener(eventName, rememberPromptSelection);
+        }
+        richEditor.addEventListener("beforeinput", (event) => {
+            if (event.inputType === "insertParagraph" || event.inputType === "insertLineBreak") {
+                event.preventDefault();
+                insertPlainText(richEditor, "\n");
+            }
+        });
+        richEditor.addEventListener("paste", (event) => {
+            event.preventDefault();
+            insertPlainText(richEditor, event.clipboardData?.getData("text/plain") ?? "");
+            // Decorate pasted tokens now, retaining the existing text-level
+            // undo transaction and routing the save through the input handler.
+            renderRichEditorText(editorPlainText(richEditor, {trimFinalNewline:false}), selectionTextOffset(richEditor));
+            state.completion?.refresh();
+        });
+        richEditor.addEventListener("copy", (event) => copyEditorSelection(richEditor, event));
+        richEditor.addEventListener("cut", (event) => copyEditorSelection(richEditor, event, true));
+        richEditor.addEventListener("keydown", (event) => {
+            if (state.completion?.handleKeydown(event)) {
+                return;
+            } else if (handlePromptUndo(event, richEditor)) {
+                return;
+            } else if (event.altKey && event.key === "ArrowLeft") {
+                event.preventDefault();
+                navigate(-1);
+            } else if (event.altKey && event.key === "ArrowRight") {
+                event.preventDefault();
+                navigate(1);
+            } else if (event.key === "Escape") {
+                refs.classList.remove("h3sp-open");
+            }
+        });
+        richEditor.addEventListener("blur", () => {
+            flushPlanEffects();
+            flushPromptAnalysis();
+            renderRichEditorText(editorPlainText(richEditor));
+        });
+
+        const replacePromptText = (result, message = "H3 edit saved to Plan") => {
+            const text = String(result.text ?? "");
+            const refreshed = availableReferenceRecords(
+                node, state.active + 1, {
+                    includeInactive:true,
+                    prompt:[sharedPrompt(state.plan).text.trim(), text.trim()]
+                        .filter(Boolean).join("\n\n"),
+                },
+            );
+            state.records = refreshed.records;
+            state.referenceMode = refreshed.mode;
+            textarea.value = text;
+            if (state.decorated) {
+                state.richInputType = "insertReplacementText";
+                try {
+                    textarea.dispatchEvent(new Event("input", {bubbles:true}));
+                } finally {
+                    state.richInputType = "";
+                }
+                renderRichEditorText(text, result.caret, result);
+                richEditor.focus();
+            } else {
+                textarea.setSelectionRange(
+                    result.selectionStart ?? result.caret,
+                    result.selectionEnd ?? result.caret,
+                );
+                textarea.dispatchEvent(new InputEvent("input", {
+                    bubbles:true,
+                    inputType:"insertReplacementText",
+                }));
+                textarea.focus();
+            }
+            status.textContent = message;
+        };
+
+        state.schema = createH3PromptSchemaController({
+            node,
+            propertyPrefix:"h3_scene_prompt_editor",
+            getText:() => state.decorated
+                ? editorPlainText(richEditor) : textarea.value,
+            replaceText:replacePromptText,
+            focusAt:(caret) => {
+                const position = Math.max(0, Math.min(textarea.value.length, Number(caret) || 0));
+                if (state.decorated) {
+                    renderRichEditorText(textarea.value, position);
+                    richEditor.focus();
+                } else {
+                    textarea.focus();
+                    textarea.setSelectionRange(position, position);
+                }
+            },
+            getRecords:() => state.records,
+            defaultDuration:Number(shot.duration_seconds)
+                || Number(shot.length) / 24 || 6,
+            defaultMode:["tagged", "scheduled", "native"].includes(state.referenceMode)
+                ? "ref2va"
+                : state.referenceMode === "native_keyframes"
+                  ? state.records.filter((record) => record.active && record.kind === "picture").length >= 2
+                    ? "fl2va" : "i2va"
+                  : "auto",
+            scopeKey:shotId,
+            markDirty:dirty,
+        });
+        if (state.schema) {
+            tools.prepend(state.schema.modeSelect, state.schema.toggle);
+            identity.append(document.createTextNode(" · "), state.schema.counts);
+        }
+
+        const activeInput = state.decorated ? richEditor : textarea;
+        state.completion = createPromptCompletionController({
+            input:activeInput,
+            maxItems:40,
+            getText:() => state.decorated
+                ? editorPlainText(richEditor) : textarea.value,
+            getCaret:() => state.decorated
+                ? selectionTextOffset(richEditor) : textarea.selectionStart,
+            getRecords:() => state.records,
+            getReferenceMode:() => state.referenceMode,
+            getMode:() => state.schema?.getMode() ?? "auto",
+            getAutomaticSuggestions:() => promptEditorPreferences().automaticSuggestions,
+            getAppendCompletionSpace:() => promptEditorPreferences().appendCompletionSpace,
+            getMarkerReplacement:() => promptEditorPreferences().markerReplacement,
+            replaceText:(result) => replacePromptText(result, "Completion saved to Plan"),
+        });
+        bindPromptMarkerInteractions({
+            input:activeInput, completion:state.completion,
+            getText:() => activePromptText(),
+            getCaret:() => state.decorated ? selectionTextOffset(richEditor) : textarea.selectionStart,
+            readFragment:(fragment) => editorPlainText(fragment, {trimFinalNewline:false}),
+            restoreCaret:(position) => state.decorated ? restoreCaret(richEditor, position)
+                : textarea.setSelectionRange(position, position),
+            getEnabled:() => promptEditorPreferences().markerReplacement,
+            getRecords:() => state.records,
+            beforeOpen:() => hidePopover(true),
+        });
+
+        root.append(head, nav, tools);
+        if (state.schema) root.append(state.schema.panel);
+        root.append(refs, textarea, editorShell);
+        if (PROMPT_ASSISTANT_ENABLED) {
+            const assistantHost = element("div", "h3sp-assist");
+            assistant.host = assistantHost;
+            renderAssistant(assistantHost, textarea);
+            root.append(assistantHost);
+        }
+        root.append(footer);
+        void loadHistory(shotId, textarea.value);
+    }
+
+    function loadPlan(force = false) {
+        if (state.disposed) return;
+        const planNode = upstreamPlanNode(node);
+        const planWidget = planNode?.widgets?.find((item) => item.name === "plan_json");
+        if (!planNode || !planWidget) {
+            if (force || state.planNode) {
+                state.plan = null;
+                state.planNode = null;
+                state.planWidget = null;
+                state.lastValue = "";
+                state.lastRunName = "";
+                showFailure("No connected H3 Chain Plan was found.");
+            }
+            return;
+        }
+        const value = String(planWidget.value ?? "");
+        const runName = String(planNode.widgets?.find(
+            (item) => item.name === "run_name",
+        )?.value ?? "").trim();
+        if (!force && planNode === state.planNode && value === state.lastValue
+            && runName === state.lastRunName) return;
+        try {
+            const previousPlan = state.plan;
+            const previousActive = state.active;
+            const nextPlan = parsePlanJson(value);
+            state.active = activeSceneIndexAfterRefresh(
+                previousPlan, nextPlan, previousActive,
+            );
+            node.properties[ACTIVE_SCENE_PROPERTY] = state.active;
+            state.plan = nextPlan;
+            state.planNode = planNode;
+            state.planWidget = planWidget;
+            state.lastValue = value;
+            state.lastRunName = runName;
+            render();
+        } catch (error) {
+            showFailure(`Connected Plan JSON is invalid:\n${error.message}`);
+        }
+    }
+
+    const widget = node.addDOMWidget(
+        "h3_scene_prompt_editor", "h3-scene-prompt-editor", root,
+        {
+            serialize: false,
+            hideOnZoom: false,
+            getMinHeight: () => PROMPT_ASSISTANT_ENABLED ? 760 : 420,
+        },
+    );
+    widget.serialize = false;
+    const minimumWidth = PROMPT_ASSISTANT_ENABLED ? 760 : 700;
+    const minimumHeight = PROMPT_ASSISTANT_ENABLED ? 900 : 620;
+    const currentWidth = Number(node.size?.[0]);
+    const currentHeight = Number(node.size?.[1]);
+    // Undo only the exact assistant-era default dimensions. Preserve any node
+    // the user deliberately made larger.
+    const targetWidth = !PROMPT_ASSISTANT_ENABLED && currentWidth === 760
+        ? minimumWidth : Math.max(currentWidth || minimumWidth, minimumWidth);
+    const targetHeight = !PROMPT_ASSISTANT_ENABLED && currentHeight === 900
+        ? minimumHeight : Math.max(currentHeight || minimumHeight, minimumHeight);
+    node.setSize?.([
+        targetWidth,
+        targetHeight,
+    ]);
+
+    const connectionsChanged = node.onConnectionsChange;
+    node.onConnectionsChange = function () {
+        const result = connectionsChanged?.apply(this, arguments);
+        setTimeout(() => loadPlan(true), 0);
+        return result;
+    };
+    const onPromptExecuted = (event) => {
+        const values = event.detail?.output?.h3_chain_active_scene;
+        const scene = Array.isArray(values) ? values.at(-1) : null;
+        if (!scene || String(scene.run_name ?? "") !== planRunName()) return;
+        const shot = state.plan?.shots?.[state.active];
+        const shotId = String(shot?.id ?? "");
+        if (!shotId || String(scene.shot_id ?? "") !== shotId) return;
+        // Current Shot marks the revision on the backend before emitting this
+        // event. Reload only the lightweight index; prompt content stays lazy.
+        window.setTimeout(() => {
+            if (state.history.sceneKey === historySceneKey(planRunName(), shotId)) {
+                void loadHistory(shotId, promptValueToText(shot.prompt), false);
+            }
+        }, 50);
+    };
+    api.addEventListener("executed", onPromptExecuted);
+    const onProjectAssetCatalogChanged = (event) => {
+        const changedProject = String(event?.detail?.project ?? "").trim();
+        const currentProject = planRunName();
+        if (changedProject && currentProject && changedProject !== currentProject) return;
+        if (!state.plan?.shots?.length) return;
+        const prompt = activePromptText();
+        const selection = state.decorated && state.richEditor
+            && document.activeElement === state.richEditor
+            ? editorSelectionOffsets(state.richEditor) : null;
+        refreshReferenceState(prompt);
+        if (state.decorated && state.richEditor) {
+            renderRichEditorText(prompt, null, selection ? {
+                selectionStart:selection.start,
+                selectionEnd:selection.end,
+            } : null);
+        }
+        if (state.referenceTray?.classList.contains("h3sp-open")) {
+            renderReferenceTray(state.referenceTray);
+        }
+        state.completion?.refresh();
+        state.schema?.refresh();
+    };
+    globalThis.addEventListener?.(
+        PROJECT_ASSET_CATALOG_CHANGED_EVENT, onProjectAssetCatalogChanged,
+    );
+
+    const removed = node.onRemoved;
+    node.onRemoved = function () {
+        // Workflow removal runs inside ComfyUI's tab/session teardown. The
+        // Plan value is already updated synchronously by commitPlan(), so only
+        // cancel deferred work here; callbacks and analysis can race teardown.
+        state.disposed = true;
+        const cleanups = [
+            () => {
+                if (state.planSyncTimer != null) window.clearTimeout(state.planSyncTimer);
+                state.planSyncTimer = null;
+                state.planSyncPending = null;
+                if (state.analysisTimer != null) window.clearTimeout(state.analysisTimer);
+                state.analysisTimer = null;
+                if (state.history.saveTimer != null) window.clearTimeout(state.history.saveTimer);
+                state.history.saveTimer = null;
+                state.history.pendingDraft = null;
+                state.history.loadToken += 1;
+                state.history.host = null;
+            },
+            () => { if (state.pollTimer != null) window.clearInterval(state.pollTimer); },
+            () => { if (state.popoverTimer != null) window.clearTimeout(state.popoverTimer); },
+            () => hidePopover(true),
+            () => state.popover?.remove(),
+            () => state.completion?.destroy(),
+            () => api.removeEventListener("executed", onPromptExecuted),
+            () => globalThis.removeEventListener?.(
+                PROJECT_ASSET_CATALOG_CHANGED_EVENT, onProjectAssetCatalogChanged,
+            ),
+        ];
+        if (PROMPT_ASSISTANT_ENABLED) {
+            assistant.preparingRequest = null;
+            cleanups.push(
+                () => clearAssistantReconnect(),
+                () => clearPendingRequest(),
+                () => assistant.client?.close(),
+            );
+        }
+        for (const cleanup of cleanups) {
+            try { cleanup(); }
+            catch (error) { console.warn("H3 Scene Prompt Editor cleanup failed", error); }
+        }
+        state.completion = null;
+        delete node._h3PromptCompanionSetActiveScene;
+        delete node._h3PromptCompanionSetScenePrompt;
+        return removed?.apply(this, arguments);
+    };
+    node._h3PromptCompanionSetActiveScene = (planNode, index) => {
+        if (planNode !== state.planNode || !state.plan?.shots?.length) return false;
+        navigate(0, index, {synchronize:false, focus:false});
+        return true;
+    };
+    node._h3PromptCompanionSetScenePrompt = (planNode, index, text) => {
+        if (planNode !== state.planNode || !state.plan?.shots?.[index]) return false;
+        const liveValue = String(state.planWidget?.value ?? "");
+        let livePlanParsed = false;
+        try {
+            const livePlan = parsePlanJson(liveValue);
+            livePlanParsed = true;
+            if (planHasNonPromptChanges(state.plan, livePlan)) {
+                loadPlan(true);
+                return true;
+            }
+        } catch (_error) {
+            // Leave lastValue untouched so normal polling reports invalid JSON.
+        }
+        state.plan.shots[index].prompt = promptTextToLines(text);
+        const shotId = String(
+            state.plan.shots[index].id
+            || `clip_${String(index + 1).padStart(4, "0")}`,
+        );
+        const promptUndo = promptUndoForScene(shotId, text, {external:true});
+        if (index === state.active) state.promptUndo = promptUndo;
+        if (index === state.active) {
+            const textarea = root.querySelector(".h3sp-textarea");
+            if (textarea && textarea.value !== text) {
+                const focused = document.activeElement === textarea;
+                const start = textarea.selectionStart;
+                const end = textarea.selectionEnd;
+                const richFocused = document.activeElement === state.richEditor;
+                const richCaret = richFocused ? selectionTextOffset(state.richEditor) : null;
+                textarea.value = text;
+                if (focused) textarea.setSelectionRange(
+                    Math.min(start, text.length), Math.min(end, text.length));
+                renderRichEditorText(
+                    text,
+                    richCaret == null ? null : Math.min(richCaret, text.length),
+                );
+                scheduleHistoryDraft(
+                    String(state.plan.shots[index].id || `clip_${String(index + 1).padStart(4, "0")}`),
+                    text);
+                refreshAssistant();
+                state.schema?.refresh();
+            }
+        }
+        if (livePlanParsed) state.lastValue = liveValue;
+        return true;
+    };
+    node._h3ScenePromptEditorRefresh = () => loadPlan(true);
+    state.pollTimer = window.setInterval(() => loadPlan(false), 500);
+    loadPlan(true);
+    if (PROMPT_ASSISTANT_ENABLED) restorePendingRequest();
+}
+
+app.registerExtension({
+    name: "minimax_h3_context_loop.scene_prompt_editor",
+    async beforeRegisterNodeDef(nodeType, nodeData) {
+        if (nodeData.name !== NODE_NAME) return;
+        const created = nodeType.prototype.onNodeCreated;
+        nodeType.prototype.onNodeCreated = function () {
+            const result = created?.apply(this, arguments);
+            setTimeout(() => mount(this), 0);
+            return result;
+        };
+    },
+    async nodeCreated(node) {
+        if (nodeType(node) === NODE_NAME) mount(node);
+    },
+    async afterConfigureGraph() {
+        for (const node of allNodes(app.graph)) {
+            if (nodeType(node) === NODE_NAME) {
+                setTimeout(() => node._h3ScenePromptEditorRefresh?.(), 0);
+            }
+        }
+    },
+});
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_checkpoint_manager_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_checkpoint_manager_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..d7856fc8a47ff8e4f66c3eecde036741220a3ba6
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_checkpoint_manager_core.mjs
@@ -0,0 +1,391 @@
+export function formatCheckpointBytes(value) {
+    const bytes = Math.max(0, Number(value) || 0);
+    if (bytes < 1024) return `${bytes} B`;
+    if (bytes < 1024 ** 2) return `${(bytes / 1024).toFixed(bytes < 10240 ? 1 : 0)} KB`;
+    if (bytes < 1024 ** 3) return `${(bytes / 1024 ** 2).toFixed(1)} MB`;
+    return `${(bytes / 1024 ** 3).toFixed(2)} GB`;
+}
+
+export function checkpointRevisionKey(scene, revision) {
+    return `${Number(scene)}:${String(revision ?? "").toLowerCase()}`;
+}
+
+export const CHECKPOINT_STAGES = [
+    {id:"original", label:"Original"},
+    {id:"derope", label:"DeRoPE"},
+    {id:"latent_upscale", label:"Latent Upscale"},
+    {id:"pixel_upscale", label:"Pixel Upscale"},
+    {id:"other", label:"Other processing"},
+];
+
+export function checkpointStageVariants(payload, stage, original = null, range = null) {
+    const key = original ? checkpointRevisionKey(original.scene, original.revision) : null;
+    return (payload?.processing_variants ?? []).filter((item) => item.stage === stage
+        && (!range || (Number(item.scene) >= range.start && Number(item.scene) <= range.end))
+        && (!key || (item.originals ?? []).some((source) =>
+            checkpointRevisionKey(source.scene, source.revision) === key)));
+}
+
+export function checkpointVariantLatentStatus(record) {
+    if (!record?.latent_saved) return record?.context_steps > 0
+        ? "Continuation tail only — full latent not saved"
+        : "Not saved — preview/assembly only";
+    if (!record.ready) return "Saved latent unavailable — missing artifacts";
+    return `Full latent saved (${record.latent_layout || "unknown layout"}); not yet execution-validated`;
+}
+
+export function checkpointRevisionMap(payload) {
+    return new Map((payload?.revisions ?? []).map((item) => [
+        checkpointRevisionKey(item.scene, item.revision), item,
+    ]));
+}
+
+export function selectedCheckpointRevision(payload, scene = null, revision = "") {
+    const revisions = Array.isArray(payload?.revisions) ? payload.revisions : [];
+    const wantedScene = Number(scene);
+    const wantedRevision = String(revision ?? "").toLowerCase();
+    if (Number.isInteger(wantedScene) && wantedRevision) {
+        const exact = revisions.find((item) =>
+            Number(item.scene) === wantedScene &&
+            String(item.revision).toLowerCase() === wantedRevision);
+        if (exact) return exact;
+    }
+    const sceneRevisions = Number.isInteger(wantedScene)
+        ? revisions.filter((item) => Number(item.scene) === wantedScene) : [];
+    const deepest = (items) => [...items].sort((left, right) =>
+        Number(right.scene) - Number(left.scene) ||
+        String(right.created_at).localeCompare(String(left.created_at)))[0];
+    return sceneRevisions.find((item) => item.active)
+        ?? sceneRevisions.sort((left, right) =>
+            String(right.created_at).localeCompare(String(left.created_at)))[0]
+        ?? deepest(revisions.filter((item) => item.active))
+        ?? deepest(revisions)
+        ?? null;
+}
+
+export function checkpointBranchRows(payload) {
+    const revisions = checkpointRevisionMap(payload);
+    return (payload?.branches ?? []).map((branch) => {
+        const slot = branch.attribution_slot;
+        return {
+            ...branch,
+            revisions: (branch.path ?? []).map((item) =>
+            revisions.get(checkpointRevisionKey(item.scene, item.revision)))
+            .filter(Boolean),
+            attribution_slot: slot ? {
+                ...slot,
+                blocked_candidates:(slot.blocked_candidates ?? []).map((item) => ({
+                    ...revisions.get(checkpointRevisionKey(item.scene, item.revision)),
+                    ...item,
+                })),
+                candidates: (slot.candidates ?? []).map((item) =>
+                    revisions.get(checkpointRevisionKey(
+                        item.scene, item.revision,
+                    ))).filter(Boolean),
+            } : null,
+        };
+    });
+}
+
+export function checkpointChapterBranchRows(payload, range) {
+    const start = Number(range?.start);
+    const end = Number(range?.end);
+    if (!Number.isFinite(start) || !Number.isFinite(end) || end < start) {
+        return checkpointBranchRows(payload);
+    }
+    const grouped = new Map();
+    for (const branch of checkpointBranchRows(payload)) {
+        const revisions = branch.revisions.filter((revision) => {
+            const scene = Number(revision.scene);
+            return scene >= start && scene <= end;
+        });
+        if (!revisions.length) continue;
+        const key = revisions.map((revision) => checkpointRevisionKey(
+            revision.scene, revision.revision,
+        )).join("|");
+        const tip = revisions.at(-1);
+        const active = revisions.every((revision) => Boolean(revision.active));
+        const slot = branch.attribution_slot;
+        const attributionSlot = slot && Number(slot.scene) >= start
+            && Number(slot.scene) <= end
+            && Number(slot.parent_scene ?? tip.scene) === Number(tip.scene)
+            && String(slot.parent_revision ?? "").toLowerCase()
+                === String(tip.revision ?? "").toLowerCase()
+            ? slot : null;
+        const existing = grouped.get(key);
+        if (existing) {
+            existing.source_branch_ids.push(branch.id);
+            if (active) {
+                existing.active = true;
+                existing.label = "Active branch";
+            }
+            existing.attribution_slot ??= attributionSlot;
+            continue;
+        }
+        grouped.set(key, {
+            ...branch,
+            id:`chapter:${String(range?.id ?? `${start}-${end}`)}:${key}`,
+            label:active ? "Active branch"
+                : `Branch ${String(tip.revision ?? "").slice(0, 8)}`,
+            active,
+            path:revisions.map((revision) => ({
+                scene:Number(revision.scene),
+                revision:String(revision.revision ?? "").toLowerCase(),
+            })),
+            revisions,
+            attribution_slot:attributionSlot,
+            source_branch_ids:[branch.id],
+        });
+    }
+    return [...grouped.values()].sort((left, right) =>
+        Number(Boolean(right.active)) - Number(Boolean(left.active)) ||
+        Number(right.revisions.at(-1)?.scene ?? 0)
+            - Number(left.revisions.at(-1)?.scene ?? 0));
+}
+
+// Resolve a whole branch, never use a previewed ancestor as an output range.
+// Shared ancestors are ambiguous unless the caller supplies the clicked row.
+export function checkpointOutputBranchTip(payload, selected, range = null, preferred = null) {
+    if (!selected || selected.take_kind === "editorial_alternate") return null;
+    const key = checkpointRevisionKey(selected.scene, selected.revision);
+    const rows = checkpointChapterBranchRows(payload, range).filter(branch =>
+        branch.revisions.some(item => checkpointRevisionKey(item.scene, item.revision) === key));
+    const tips = new Map(rows.map(branch => {
+        const tip = branch.revisions.at(-1);
+        return [checkpointRevisionKey(tip.scene, tip.revision), tip];
+    }));
+    const preferredKey = preferred ? checkpointRevisionKey(preferred.scene, preferred.revision) : null;
+    return tips.get(preferredKey) ?? tips.get(key) ?? (tips.size === 1 ? [...tips.values()][0] : null);
+}
+
+export function checkpointRevisionLineage(payload, selected, range = null) {
+    const records = checkpointRevisionMap(payload);
+    const start = Math.max(1, Number(range?.start) || 1);
+    let cursor = selected ?? null;
+    const reversed = [];
+    const seen = new Set();
+    while (cursor) {
+        const scene = Number(cursor.scene);
+        if (!Number.isInteger(scene) || scene < start) return [];
+        const key = checkpointRevisionKey(cursor.scene, cursor.revision);
+        if (seen.has(key)) return [];
+        seen.add(key);
+        reversed.push({
+            scene,
+            revision: String(cursor.revision ?? "").toLowerCase(),
+        });
+        // A chapter start is an editorial branch root. Its immutable parent
+        // remains useful provenance, but it does not select the prior
+        // chapter's branch.
+        if (scene === start) break;
+        if (!cursor.parent) break;
+        cursor = records.get(checkpointRevisionKey(
+            cursor.parent.scene, cursor.parent.revision,
+        ));
+        if (!cursor) return [];
+    }
+    const lineage = reversed.reverse();
+    if (!lineage.length || lineage[0].scene !== start) return [];
+    if (lineage.some((item, index) => item.scene !== start + index)) return [];
+    return lineage;
+}
+
+export function checkpointProjectLineage(payload, selected, range = null) {
+    const start = Math.max(1, Number(range?.start) || 1);
+    const chapterLineage = checkpointRevisionLineage(payload, selected, {
+        ...range, start,
+    });
+    if (!chapterLineage.length) return [];
+    const revisions = Array.isArray(payload?.revisions) ? payload.revisions : [];
+    const prefix = [];
+    for (let scene = 1; scene < start; scene += 1) {
+        const active = revisions.find((item) =>
+            Number(item.scene) === scene && Boolean(item.active));
+        if (!active) return [];
+        prefix.push({
+            scene,
+            revision:String(active.revision ?? "").toLowerCase(),
+        });
+    }
+    return [...prefix, ...chapterLineage];
+}
+
+export function checkpointSelectionJson(payload, runName, selected, range = null, outputScope = "project") {
+    const normalizedRun = String(runName ?? "").trim();
+    const lineage = checkpointProjectLineage(payload, selected, range);
+    const start = Math.max(1, Number(range?.start) || 1);
+    const end = Math.max(start, Number(range?.end) || Number(selected?.scene) || start);
+    return normalizedRun && lineage.length
+        ? JSON.stringify({
+            run_name:normalizedRun,
+            lineage,
+            scope_start_scene:start,
+            scope_end_scene:end,
+            ...(outputScope === "chapter" ? {output_scope:"chapter"} : {}),
+        })
+        : "";
+}
+
+// Keep the pinned output in the execution widget itself: one serialized source
+// of truth survives save/load, duplication and node reconfiguration.
+export function checkpointLocalSelection(value) {
+    try {
+        const selection = typeof value === "string" ? JSON.parse(value) : value;
+        return selection?.output_mode === "workflow_local" ? selection : null;
+    } catch {
+        return null;
+    }
+}
+
+function checkpointSceneRanges(scenes) {
+    const values = [...new Set(scenes)].sort((left, right) => left - right);
+    const ranges = [];
+    for (let index = 0; index < values.length; index += 1) {
+        const start = values[index];
+        let end = start;
+        while (values[index + 1] === end + 1) end = values[++index];
+        ranges.push(start === end ? String(start) : `${start}–${end}`);
+    }
+    return ranges.join(", ");
+}
+
+// Describe the serialized output, never the preview cursor or the open tab.
+// This is a source manifest, not a promise to process every available scene.
+export function checkpointOutputSummary(value) {
+    const invalid = "Cannot send a source: the saved output selection is invalid. Select a branch again.";
+    let saved;
+    try { saved = typeof value === "string" ? JSON.parse(value || "null") : value; }
+    catch { return invalid; }
+    if (!saved) {
+        return "No source selected for connected nodes. Choose a saved branch heading; clip and tab clicks only preview.";
+    }
+    if (!saved.run_name || !Array.isArray(saved.lineage) || !saved.lineage.length
+        || saved.lineage.some((item, index) => Number(item?.scene) !== index + 1 || !item?.revision)
+        || ![undefined, "project", "chapter"].includes(saved.output_scope)
+        || ![undefined, null, "workflow_local"].includes(saved.output_mode)) return invalid;
+    const chapterOnly = saved.output_scope === "chapter";
+    const first = chapterOnly ? Number(saved.scope_start_scene ?? 1) : 1;
+    if (!Number.isInteger(first) || first < 1) return invalid;
+    const clips = saved.lineage.filter(item => Number(item.scene) >= first);
+    const tip = clips.at(-1);
+    if (!tip) return "No saved clips in this output scope. Select a branch again.";
+    const processing = saved.processing_source;
+    if (processing != null && processing.stage !== "derope") return invalid;
+    let source = "Original checkpoints";
+    if (processing?.stage === "derope") {
+        const lineage = processing.branch?.lineage;
+        if (!processing.profile_path || !Array.isArray(lineage) || !lineage.length
+            || lineage.some(item => !Number.isInteger(Number(item?.scene))
+                || Number(item.scene) < 1 || !item?.revision)) return invalid;
+        const scenes = new Set(lineage.map(item => Number(item.scene)));
+        const processed = clips.filter(item => scenes.has(Number(item.scene))).map(item => Number(item.scene));
+        const fallback = clips.filter(item => !scenes.has(Number(item.scene))).map(item => Number(item.scene));
+        source = `DeRoPE checkpoints for scenes ${checkpointSceneRanges(processed) || "none"}`;
+        source += fallback.length ? `; Original fallback for scenes ${checkpointSceneRanges(fallback)}` : "; no Original fallback needed";
+        source += ` · DeRoPE branch ${String(lineage.at(-1)?.revision ?? "?").slice(0, 8)} (${processing.profile_path})`;
+    }
+    const scope = chapterOnly ? "selected chapter only" : "selected branch + earlier chapters";
+    const mode = saved.output_mode === "workflow_local" ? "pinned to this workflow" : "follows branch selection";
+    return `Will send to connected nodes: ${source} · ${saved.run_name} · original branch through scene ${tip.scene} / ${String(tip.revision).slice(0, 8)}`
+        + ` · scenes ${first}–${tip.scene} (${clips.length} ${clips.length === 1 ? "clip" : "clips"}; ${scope}) · ${mode}.`
+        + " Clip and tab previews do not change this output. Set the processing range downstream.";
+}
+
+export function checkpointLocalSelectionJson(payload, runName, selected, range = null, outputScope = "project") {
+    const value = checkpointSelectionJson(payload, runName, selected, range, outputScope);
+    if (!value) throw new Error("Select a complete saved checkpoint lineage first.");
+    const selection = JSON.parse(value);
+    const records = checkpointRevisionMap(payload);
+    if (selection.lineage.some((item) => {
+        const record = records.get(checkpointRevisionKey(item.scene, item.revision));
+        // Earlier chapters supply immutable timing metadata only.
+        if (outputScope === "chapter" && item.scene < selection.scope_start_scene) return !record;
+        return !record?.ready || record.take_kind === "editorial_alternate";
+    })) {
+        throw new Error("Local output requires available generation checkpoints for every selected scene.");
+    }
+    return JSON.stringify({...selection, output_mode:"workflow_local"});
+}
+
+export function checkpointOutputSelectionJson(current, payload, runName, selected, range = null, outputScope = "project") {
+    // Browsing or a new project-wide active tip must never move a local pin.
+    return checkpointLocalSelection(current) ? current
+        : checkpointSelectionJson(payload, runName, selected, range, outputScope);
+}
+
+export function checkpointDeropeSelectionJson(payload, runName, tip, variant, range = null, outputScope = "project") {
+    const base = JSON.parse(checkpointLocalSelectionJson(payload, runName, tip, range, outputScope));
+    if (variant?.stage !== "derope" || !variant.processing_branch) {
+        throw new Error("Select a DeRoPE take with an unambiguous saved branch. For a shared take, choose the desired branch's later take.");
+    }
+    const selected = new Set(base.lineage.filter(item => outputScope !== "chapter" || item.scene >= base.scope_start_scene)
+        .map(item => checkpointRevisionKey(item.scene, item.revision)));
+    const first = outputScope === "chapter" ? base.scope_start_scene : 1;
+    let used = 0;
+    for (const ref of variant.processing_branch.lineage) {
+        if (ref.scene < first || ref.scene > tip.scene) continue;
+        const saved = (payload.processing_variants ?? []).find(item => item.key === ref.metadata_path && item.checkpoint_sha256 === ref.checkpoint_sha256);
+        if (!saved || saved.stage !== "derope" || !saved.ready || !saved.latent_saved) {
+            throw new Error(`DeRoPE scene ${ref.scene} needs an available full latent. Save with save_latent enabled and Recovered AV connected, or explicitly use Original.`);
+        }
+        if (saved.profile_path !== variant.profile_path || !(saved.originals ?? []).some(item => selected.has(checkpointRevisionKey(item.scene, item.revision)))) {
+            throw new Error(`DeRoPE scene ${ref.scene} belongs to a different original branch.`);
+        }
+        used += 1;
+    }
+    if (!used) throw new Error("This DeRoPE branch has no scenes in the selected output scope.");
+    return JSON.stringify({...base, processing_source:{stage:"derope", profile_path:variant.profile_path, branch:variant.processing_branch}});
+}
+
+export function checkpointActivationMode(payload, selected, range = null) {
+    if (!selected?.ready || selected?.take_kind === "editorial_alternate") {
+        return "disabled";
+    }
+    const start = Math.max(1, Number(range?.start) || 1);
+    const selectedScene = Number(selected.scene);
+    const lineage = checkpointRevisionLineage(payload, selected, range);
+    if (!Number.isInteger(selectedScene)
+            || lineage.length !== selectedScene - start + 1) {
+        return "disabled";
+    }
+    const revisions = Array.isArray(payload?.revisions)
+        ? payload.revisions : [];
+    const records = checkpointRevisionMap(payload);
+    if (lineage.some((item) => !records.get(
+        checkpointRevisionKey(item.scene, item.revision),
+    )?.active)) {
+        return "activate";
+    }
+    const maximumScene = Math.max(
+        selectedScene,
+        ...revisions.map((item) => Number(item.scene) || 0),
+    );
+    const end = Math.max(start, Number(range?.end) || maximumScene);
+    return revisions.some((item) =>
+        Boolean(item.active || item.pointer_active)
+        && item.take_kind !== "editorial_alternate"
+        && Number(item.scene) > selectedScene
+        && Number(item.scene) <= end)
+        ? "rollback" : "current";
+}
+
+export function checkpointDependencyText(item) {
+    const scene = Number(item?.scene) || 0;
+    const id = String(item?.scene_id ?? `clip_${String(scene).padStart(4, "0")}`);
+    const video = Math.max(0, Number(item?.context_length) || 0);
+    const audio = Math.max(0, Number(item?.audio_context_length) || 0);
+    const mode = String(item?.continuation_mode ?? "guide");
+    const relationship = video || audio
+        ? `uses Video ${video}f / Audio ${audio}f via ${mode}`
+        : `has a structural continuation edge (Video 0f / Audio 0f)`;
+    return `Scene ${scene} · ${id} ${relationship}`;
+}
+
+export function checkpointDeletionTitle(preview) {
+    if (!preview) return "Select a checkpoint revision to inspect deletion safety.";
+    if (preview.allowed) {
+        const action = preview.rollback ? "Safe active-tip rollback" : "Safe leaf deletion";
+        return `${action} · ${preview.owned_file_count} files · ${formatCheckpointBytes(preview.reclaimed_bytes)}`;
+    }
+    return (preview.blockers ?? []).join(" ") || "Deletion is blocked.";
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_kj_preview_bridge.js b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_kj_preview_bridge.js
new file mode 100644
index 0000000000000000000000000000000000000000..2af2d4adbbd01ca54f99a4a30ab801262635debc
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_kj_preview_bridge.js
@@ -0,0 +1,81 @@
+import { app } from "../../scripts/app.js";
+import { api } from "../../scripts/api.js";
+import {
+    H3_LOOP_END_TYPE,
+    KJ_PREVIEW_TYPE,
+    fallbackDisplayIds,
+    recursiveRootId,
+} from "./h3_kj_preview_bridge_core.mjs?v=0.6.2";
+
+const executionToDisplay = new Map();
+
+// Mirrors ComfyUI's qualified-id lookup for nodes inside subgraphs.
+function findNodeByDisplayId(qid) {
+    if (!app.graph || qid == null) return null;
+    const parts = String(qid).split(":");
+    let graph = app.graph;
+    for (let i = 0; i < parts.length - 1; i++) {
+        const parentId = Number(parts[i]);
+        if (!Number.isFinite(parentId)) return null;
+        const parent = graph?.getNodeById?.(parentId);
+        if (!parent?.subgraph) return null;
+        graph = parent.subgraph;
+    }
+    const leafId = Number(parts.at(-1));
+    return Number.isFinite(leafId) ? graph?.getNodeById?.(leafId) ?? null : null;
+}
+
+function nodeType(node) {
+    return node?.comfyClass ?? node?.type ?? null;
+}
+
+function belongsToH3Loop(executionId) {
+    const rootId = recursiveRootId(executionId);
+    return rootId != null && nodeType(findNodeByDisplayId(rootId)) === H3_LOOP_END_TYPE;
+}
+
+function rememberDisplayMapping(data) {
+    if (data?.node == null || data?.display_node == null) return;
+    const executionId = String(data.node);
+    const displayId = String(data.display_node);
+    if (executionId === displayId || !belongsToH3Loop(executionId)) return;
+    if (nodeType(findNodeByDisplayId(displayId)) === KJ_PREVIEW_TYPE) {
+        executionToDisplay.set(executionId, displayId);
+    }
+}
+
+function resolvePreviewNode(executionId) {
+    if (!belongsToH3Loop(executionId)) return null;
+
+    const candidates = [];
+    const mapped = executionToDisplay.get(executionId);
+    if (mapped != null) candidates.push(mapped);
+    candidates.push(...fallbackDisplayIds(executionId));
+
+    for (const displayId of candidates) {
+        const node = findNodeByDisplayId(displayId);
+        if (nodeType(node) === KJ_PREVIEW_TYPE) return node;
+    }
+    return null;
+}
+
+app.registerExtension({
+    name: "minimax_h3_context_loop.kj_preview_loop_bridge",
+    setup() {
+        api.addEventListener("execution_start", () => executionToDisplay.clear());
+        api.addEventListener("executing", (event) => rememberDisplayMapping(event.detail));
+        api.addEventListener("kj_preview_override", (event) => {
+            const data = event.detail;
+            if (data?.node_id == null) return;
+            const executionId = String(data.node_id);
+
+            // KJ handles ordinary canvas ids itself. We intervene only when its
+            // source is a generated H3 recursion id that has no canvas node.
+            if (findNodeByDisplayId(executionId)) return;
+            const node = resolvePreviewNode(executionId);
+            if (typeof node?._kjPreviewHandler === "function") {
+                node._kjPreviewHandler(data);
+            }
+        });
+    },
+});
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_kj_preview_bridge_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_kj_preview_bridge_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..959bdc06e6dfb6a333fca3c42ae5fe36be84828b
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_kj_preview_bridge_core.mjs
@@ -0,0 +1,23 @@
+export const H3_LOOP_END_TYPE = "MiniMaxH3ChainLoopEnd";
+export const KJ_PREVIEW_TYPE = "ModelPreviewOverrideKJ";
+
+export function recursiveRootId(executionId) {
+    const value = String(executionId ?? "");
+    const dot = value.indexOf(".");
+    return dot > 0 ? value.slice(0, dot) : null;
+}
+
+export function isRecursiveExecutionId(executionId) {
+    return recursiveRootId(executionId) !== null;
+}
+
+export function fallbackDisplayIds(executionId) {
+    const value = String(executionId ?? "");
+    if (!isRecursiveExecutionId(value)) return [];
+
+    // GraphBuilder prefixes every recursive clone with dot-separated execution
+    // components. Canvas/subgraph display ids use ':' and therefore remain
+    // intact as the final component.
+    const leaf = value.slice(value.lastIndexOf(".") + 1);
+    return leaf && leaf !== value ? [leaf] : [];
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_legacy_widget_width_fix.js b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_legacy_widget_width_fix.js
new file mode 100644
index 0000000000000000000000000000000000000000..3b9a6c934dee9e5812ae987b960947a897722bc7
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_legacy_widget_width_fix.js
@@ -0,0 +1,182 @@
+import {app} from "/scripts/app.js";
+import {
+    createLegacyWidgetWidthController,
+    graphNodes,
+} from "./h3_legacy_widget_width_fix_core.mjs?v=0.6.2";
+
+const SETTING_ID = "MiniMaxH3ContexLoop.legacyWidgetWidthFix";
+const LEGACY_FIX_NODE = "LegacyWidgetWidthFix";
+const REPAIR_BUTTON = "Repair widget widths now";
+const HOST_LIFECYCLE_PATCH = "__h3_lwwf_host_lifecycle";
+const LEGACY_LIFECYCLE_PATCH = "__h3_lwwf_legacy_lifecycle";
+const LEGACY_DISPLAY_PREFIX = "MiniMax H3 Contex Loop";
+const CURRENT_DISPLAY_PREFIX = "MiniMax H3 Context Loop";
+
+const H3_NODE_TYPES = new Set([
+    "MiniMaxH3LoopTrim",
+    "MiniMaxH3ContexLoopSeamProbe",
+    "MiniMaxH3ChainPlan",
+    "MiniMaxH3ChainPlanModern",
+    "MiniMaxH3ChainCheckpointManager",
+    "MiniMaxH3ChainScenePromptEditor",
+    "MiniMaxH3ChainRunManager",
+    "MiniMaxH3ReferenceVideoPrepare",
+    "MiniMaxH3ScheduledPictureReference",
+    "MiniMaxH3ScheduledVideoReference",
+    "MiniMaxH3ScheduledAudioReference",
+    "MiniMaxH3ScheduledReferenceToVideo",
+    "MiniMaxH3TaggedPictureReference",
+    "MiniMaxH3TaggedVideoReference",
+    "MiniMaxH3TaggedMotionReference",
+    "MiniMaxH3LazyMotionAVLoader",
+    "MiniMaxH3TaggedMotionReferencePath",
+    "MiniMaxH3LazyMotionScenePreview",
+    "MiniMaxH3TaggedAudioReference",
+    "MiniMaxH3TaggedReferenceToVideo",
+    "MiniMaxH3ChainExternalVideo",
+    "MiniMaxH3ChainLoopStart",
+    "MiniMaxH3ChainCurrent",
+    "MiniMaxH3ChainContext",
+    "MiniMaxH3ChainSegmentSave",
+    "MiniMaxH3ChainReview",
+    "MiniMaxH3ChainLoopEnd",
+    "MiniMaxH3ChainManifestLoad",
+    "MiniMaxH3ChainExportPNG",
+    "MiniMaxH3ChainLatentVideoAdapter",
+    "MiniMaxH3ChainAssemble",
+]);
+
+function nodeType(node) {
+    return node?.comfyClass ?? node?.constructor?.comfyClass ?? node?.type ?? null;
+}
+
+function isH3Host(node) {
+    return H3_NODE_TYPES.has(nodeType(node));
+}
+
+function correctLegacyNodeTitle(node) {
+    if (!isH3Host(node) || typeof node?.title !== "string"
+            || !node.title.includes(LEGACY_DISPLAY_PREFIX)) return false;
+    node.title = node.title.replaceAll(
+        LEGACY_DISPLAY_PREFIX, CURRENT_DISPLAY_PREFIX);
+    return true;
+}
+
+function correctLegacyGraphTitles(graph) {
+    for (const node of graphNodes(graph)) correctLegacyNodeTitle(node);
+}
+
+function schedule(callback) {
+    if (typeof globalThis.requestAnimationFrame === "function") {
+        globalThis.requestAnimationFrame(callback);
+    } else {
+        globalThis.setTimeout?.(callback, 0);
+    }
+}
+
+function askStandaloneFixToRepair() {
+    schedule(() => {
+        for (const node of graphNodes(app.graph)) {
+            if (nodeType(node) !== LEGACY_FIX_NODE) continue;
+            const button = node.widgets?.find((widget) =>
+                widget.name === REPAIR_BUTTON);
+            button?.callback?.();
+        }
+    });
+}
+
+const controller = createLegacyWidgetWidthController({
+    getGraph: () => app.graph,
+    requestFrame: schedule,
+    onRelinquish: askStandaloneFixToRepair,
+});
+
+function patchHostLifecycle(nodeTypeDefinition) {
+    const prototype = nodeTypeDefinition?.prototype;
+    if (!prototype || prototype[HOST_LIFECYCLE_PATCH]) return;
+    Object.defineProperty(prototype, HOST_LIFECYCLE_PATCH, {value: true});
+
+    const originalAdded = prototype.onAdded;
+    prototype.onAdded = function h3WidthFixHostAdded(...args) {
+        const result = originalAdded?.apply(this, args);
+        controller.addHost(this);
+        return result;
+    };
+
+    const originalRemoved = prototype.onRemoved;
+    prototype.onRemoved = function h3WidthFixHostRemoved(...args) {
+        try {
+            return originalRemoved?.apply(this, args);
+        } finally {
+            controller.removeHost(this);
+        }
+    };
+}
+
+function patchStandaloneRemoval(nodeTypeDefinition) {
+    const prototype = nodeTypeDefinition?.prototype;
+    if (!prototype || prototype[LEGACY_LIFECYCLE_PATCH]) return;
+    Object.defineProperty(prototype, LEGACY_LIFECYCLE_PATCH, {value: true});
+    const originalRemoved = prototype.onRemoved;
+    prototype.onRemoved = function h3WidthFixStandaloneRemoved(...args) {
+        try {
+            return originalRemoved?.apply(this, args);
+        } finally {
+            controller.scheduleRepairAll();
+        }
+    };
+}
+
+function settingEnabled() {
+    return app.ui?.settings?.getSettingValue?.(SETTING_ID) !== false;
+}
+
+app.registerExtension({
+    name: "MiniMaxH3ContexLoop.LegacyWidgetWidthFix",
+
+    init() {
+        controller.installHooks(globalThis.LGraphNode?.prototype);
+        app.ui?.settings?.addSetting?.({
+            id: SETTING_ID,
+            category: ["MiniMax H3 Context Loop", "Compatibility", "Widget widths"],
+            name: "Repair legacy widget widths while H3 nodes are present",
+            tooltip: "Works around ComfyUI frontend issue #12443 across the whole canvas. Disable only if your frontend has fixed the LiteGraph widget-width regression.",
+            type: "boolean",
+            defaultValue: true,
+            onChange(value) {
+                controller.setAllowed(value !== false);
+            },
+        });
+        controller.setAllowed(settingEnabled());
+    },
+
+    beforeRegisterNodeDef(nodeTypeDefinition, nodeData) {
+        controller.installHooks(globalThis.LGraphNode?.prototype);
+        if (H3_NODE_TYPES.has(nodeData?.name)) {
+            patchHostLifecycle(nodeTypeDefinition);
+        } else if (nodeData?.name === LEGACY_FIX_NODE) {
+            patchStandaloneRemoval(nodeTypeDefinition);
+        }
+    },
+
+    nodeCreated(node) {
+        controller.installHooks(globalThis.LGraphNode?.prototype);
+        correctLegacyNodeTitle(node);
+        if (isH3Host(node)) controller.addHost(node);
+        controller.nodeCreated(node);
+    },
+
+    afterConfigureGraph() {
+        correctLegacyGraphTitles(app.graph);
+        controller.syncHosts(graphNodes(app.graph), isH3Host);
+        controller.scheduleRepairAll();
+    },
+
+    setup() {
+        controller.installHooks(globalThis.LGraphNode?.prototype);
+        controller.setAllowed(settingEnabled());
+        correctLegacyGraphTitles(app.graph);
+        controller.syncHosts(graphNodes(app.graph), isH3Host);
+        controller.scheduleRepairAll();
+    },
+});
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_legacy_widget_width_fix_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_legacy_widget_width_fix_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..c09871b81913b76505463629738b32fa2bb87270
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_legacy_widget_width_fix_core.mjs
@@ -0,0 +1,227 @@
+// Canvas-wide compatibility helper for ComfyUI_frontend #12443.
+//
+// Adapted with permission from pekkAi-dev/ComfyUI-LegacyWidgetWidthFix. The
+// controller form lets this pack activate the workaround while one of its H3
+// nodes is present, without adding a dedicated workflow node.
+
+export const LEGACY_WIDTH_KEY = "__lwwf_width";
+export const LEGACY_GUARD_KEY = "__lwwf_guarded";
+
+const OWNER_KEY = "__h3_lwwf_owner";
+const HOOK_KEY = "__h3_lwwf_hook";
+const HOOK_METHODS = ["addWidget", "addDOMWidget", "addCustomWidget"];
+
+export function graphNodes(graph, output = [], seen = new Set()) {
+    if (!graph || seen.has(graph)) return output;
+    seen.add(graph);
+    for (const node of graph._nodes ?? []) {
+        output.push(node);
+        if (node?.subgraph) graphNodes(node.subgraph, output, seen);
+    }
+    return output;
+}
+
+export function createLegacyWidgetWidthController({
+    getGraph,
+    getLiteGraph = () => globalThis.LiteGraph,
+    requestFrame = (callback) => globalThis.requestAnimationFrame?.(callback),
+    onRelinquish = () => {},
+} = {}) {
+    const owner = {};
+    const hosts = new Set();
+    const hookedMethods = new WeakMap();
+    let allowed = true;
+    let active = false;
+    let repairQueued = false;
+
+    function inVueMode() {
+        return !!getLiteGraph?.()?.vueNodesMode;
+    }
+
+    function ownsWidget(widget) {
+        const descriptor = Object.getOwnPropertyDescriptor(widget ?? {}, "width");
+        return descriptor?.set?.[OWNER_KEY] === owner;
+    }
+
+    function guardWidget(widget) {
+        if (!active || !widget) return false;
+        if (ownsWidget(widget)) return true;
+
+        let width;
+        try {
+            width = Object.prototype.hasOwnProperty.call(widget, LEGACY_WIDTH_KEY)
+                ? widget[LEGACY_WIDTH_KEY]
+                : widget.width;
+            widget[LEGACY_WIDTH_KEY] = width;
+
+            const setter = function setLegacyWidgetWidth(value) {
+                if (!active || inVueMode()) this[LEGACY_WIDTH_KEY] = value;
+            };
+            Object.defineProperty(setter, OWNER_KEY, {value: owner});
+            Object.defineProperty(widget, "width", {
+                configurable: true,
+                enumerable: true,
+                get() {
+                    return this[LEGACY_WIDTH_KEY];
+                },
+                set: setter,
+            });
+            if (!widget[LEGACY_GUARD_KEY]) {
+                Object.defineProperty(widget, LEGACY_GUARD_KEY, {
+                    value: true,
+                    configurable: true,
+                    enumerable: false,
+                });
+            }
+            return true;
+        } catch (_error) {
+            return false;
+        }
+    }
+
+    function repairWidget(widget) {
+        if (!active || inVueMode() || !guardWidget(widget)) return false;
+        widget[LEGACY_WIDTH_KEY] = undefined;
+        return true;
+    }
+
+    function unguardWidget(widget) {
+        if (!ownsWidget(widget)) return false;
+        const width = widget[LEGACY_WIDTH_KEY];
+        try {
+            delete widget.width;
+            delete widget[LEGACY_WIDTH_KEY];
+            delete widget[LEGACY_GUARD_KEY];
+            widget.width = width;
+            return true;
+        } catch (_error) {
+            return false;
+        }
+    }
+
+    function eachWidget(callback) {
+        for (const node of graphNodes(getGraph?.())) {
+            for (const widget of node?.widgets ?? []) callback(widget, node);
+        }
+    }
+
+    function dirtyCanvas() {
+        getGraph?.()?.setDirtyCanvas?.(true, true);
+    }
+
+    function repairNode(node) {
+        if (!active) return;
+        for (const widget of node?.widgets ?? []) repairWidget(widget);
+    }
+
+    function repairAll() {
+        if (!active) return;
+        eachWidget((widget) => repairWidget(widget));
+        dirtyCanvas();
+    }
+
+    function scheduleRepairAll() {
+        if (!active || repairQueued) return;
+        repairQueued = true;
+        const callback = () => {
+            repairQueued = false;
+            repairAll();
+        };
+        if (typeof requestFrame === "function") requestFrame(callback);
+        else globalThis.setTimeout?.(callback, 0);
+    }
+
+    function nodeCreated(node) {
+        if (!active) return;
+        repairNode(node);
+        const callback = () => {
+            if (active && node?.graph) repairNode(node);
+        };
+        if (typeof requestFrame === "function") requestFrame(callback);
+        else globalThis.setTimeout?.(callback, 0);
+    }
+
+    function updateActive() {
+        const next = allowed && hosts.size > 0;
+        if (next === active) return;
+        active = next;
+        if (active) {
+            repairAll();
+            scheduleRepairAll();
+            return;
+        }
+        eachWidget((widget) => unguardWidget(widget));
+        dirtyCanvas();
+        onRelinquish?.();
+    }
+
+    function addHost(node) {
+        if (!node || hosts.has(node)) return;
+        hosts.add(node);
+        updateActive();
+    }
+
+    function removeHost(node) {
+        if (!hosts.delete(node)) return;
+        updateActive();
+    }
+
+    function syncHosts(nodes, isHost) {
+        hosts.clear();
+        for (const node of nodes ?? []) {
+            if (isHost(node)) hosts.add(node);
+        }
+        updateActive();
+    }
+
+    function setAllowed(value) {
+        allowed = value !== false;
+        updateActive();
+    }
+
+    function installHooks(prototype) {
+        if (!prototype) return;
+        let installed = hookedMethods.get(prototype);
+        if (!installed) {
+            installed = new Map();
+            hookedMethods.set(prototype, installed);
+        }
+        for (const name of HOOK_METHODS) {
+            const original = prototype[name];
+            if (typeof original !== "function") continue;
+            if (original === installed.get(name) || original[HOOK_KEY] === owner) {
+                continue;
+            }
+            const patched = function h3LegacyWidthPatchedWidgetMethod(...args) {
+                const widget = original.apply(this, args);
+                if (active && widget) repairWidget(widget);
+                return widget;
+            };
+            Object.defineProperty(patched, HOOK_KEY, {value: owner});
+            prototype[name] = patched;
+            installed.set(name, patched);
+        }
+    }
+
+    return {
+        addHost,
+        installHooks,
+        nodeCreated,
+        ownsWidget,
+        removeHost,
+        repairAll,
+        repairNode,
+        scheduleRepairAll,
+        setAllowed,
+        syncHosts,
+        get active() {
+            return active;
+        },
+        get allowed() {
+            return allowed;
+        },
+        get hostCount() {
+            return hosts.size;
+        },
+    };
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_lora_scheduler_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_lora_scheduler_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..362e021eea1b706ca46efb757d30a4950a5a672b
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_lora_scheduler_core.mjs
@@ -0,0 +1,81 @@
+export const LORA_SCHEDULER_NODE = "MiniMaxH3ChainLoRAScheduler";
+export const LORA_ROUTE_LETTERS = Object.freeze([
+    ..."abcdefghijklmnopqrstuvwxyz",
+]);
+
+export function loraInputRoute(name) {
+    const match = /^lora_([a-z])$/.exec(String(name ?? ""));
+    return match?.[1] ?? null;
+}
+
+export function connectedLoRARoutes(node) {
+    const connected = new Set();
+    for (const input of node?.inputs ?? []) {
+        const route = loraInputRoute(input.name);
+        if (route && input.link != null) connected.add(route);
+    }
+    return LORA_ROUTE_LETTERS.filter((route) => connected.has(route));
+}
+
+export function nextLoRARoute(node) {
+    const connected = new Set(connectedLoRARoutes(node));
+    return LORA_ROUTE_LETTERS.find((route) => !connected.has(route)) ?? null;
+}
+
+export function loraRouteLabel(route) {
+    return route === "base" ? "Base model" : `LoRA ${String(route).toUpperCase()}`;
+}
+
+function nodeType(node) {
+    return node?.comfyClass ?? node?.type ?? null;
+}
+
+function allNodes(graph, result = []) {
+    for (const node of graph?._nodes ?? []) {
+        result.push(node);
+        if (node.subgraph) allNodes(node.subgraph, result);
+    }
+    return result;
+}
+
+function hasUpstreamNode(start, target) {
+    if (!start || !target) return false;
+    const queue = [start];
+    const seen = new Set();
+    while (queue.length) {
+        const node = queue.shift();
+        if (!node || seen.has(node)) continue;
+        if (node === target) return true;
+        seen.add(node);
+        for (const input of node.inputs ?? []) {
+            if (input.link == null) continue;
+            const link = node.graph?.links?.[input.link];
+            const parent = link
+                ? node.graph?.getNodeById?.(link.origin_id) ?? null
+                : null;
+            if (parent) queue.push(parent);
+        }
+    }
+    return false;
+}
+
+export function availableLoRARoutes(
+    graph, owners = [], currentRoute = "base",
+) {
+    const ownerList = owners.filter(Boolean);
+    const available = new Set(["base"]);
+    for (const scheduler of allNodes(graph)) {
+        if (nodeType(scheduler) !== LORA_SCHEDULER_NODE) continue;
+        if (ownerList.length && !ownerList.some(
+            (owner) => hasUpstreamNode(scheduler, owner),
+        )) continue;
+        for (const route of connectedLoRARoutes(scheduler)) available.add(route);
+    }
+    const current = String(currentRoute ?? "base").trim().toLowerCase();
+    if (current === "base" || LORA_ROUTE_LETTERS.includes(current)) {
+        available.add(current);
+    }
+    return ["base", ...LORA_ROUTE_LETTERS.filter(
+        (route) => available.has(route),
+    )];
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_plan_restore_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_plan_restore_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..dabde9fa3846e028d2e315886138d21786f87d27
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_plan_restore_core.mjs
@@ -0,0 +1,374 @@
+import {
+    ADVANCED_TRANSITION_PRESETS,
+    GENERATION_AUDIO_PROFILES,
+    GENERATION_SCENE_PROFILES,
+    LEGACY_AUDIO_POLICIES,
+    PRIMARY_TRANSITION_PRESETS,
+    transitionPreset,
+    transitionPresetName,
+} from "./h3_policy_core.mjs?v=0.6.6";
+
+const CHAIN_POLICY_NODE = "MiniMaxH3ChainPolicy";
+const PROFILE_POLICY_NODE = "MiniMaxH3GenerationProfile";
+const ADVANCED_POLICY_NODE = "MiniMaxH3AdvancedPolicy";
+const LEGACY_POLICY_NODE = "MiniMaxH3Legacy04PolicyAdapter";
+
+function nodeType(node) {
+    return node?.comfyClass ?? node?.type ?? null;
+}
+
+function graphLink(graph, linkId) {
+    return graph?.links?.[linkId] ?? graph?.links?.get?.(linkId) ?? null;
+}
+
+function widgetByName(node, name) {
+    return node?.widgets?.find((item) => item.name === name);
+}
+
+function allNodes(graph, output = []) {
+    for (const node of graph?._nodes ?? []) {
+        output.push(node);
+        if (node.subgraph) allNodes(node.subgraph, output);
+    }
+    return output;
+}
+
+function linkedInputOrigin(node, inputName) {
+    const input = node?.inputs?.find((item) => item.name === inputName);
+    if (input?.link == null) return null;
+    const link = graphLink(node.graph, input.link);
+    return link ? node.graph?.getNodeById?.(link.origin_id) ?? null : null;
+}
+
+function findUpstreamType(start, wantedType) {
+    const queue = [start];
+    const seen = new Set();
+    while (queue.length) {
+        const node = queue.shift();
+        if (!node || seen.has(node)) continue;
+        seen.add(node);
+        if (nodeType(node) === wantedType) return node;
+        for (const input of node.inputs ?? []) {
+            if (input.link == null) continue;
+            const link = graphLink(node.graph, input.link);
+            const parent = link ? node.graph?.getNodeById?.(link.origin_id) : null;
+            if (parent) queue.push(parent);
+        }
+    }
+    return null;
+}
+
+function findFirstUpstreamType(start, wantedTypes) {
+    const queue = [start];
+    const seen = new Set();
+    while (queue.length) {
+        const node = queue.shift();
+        if (!node || seen.has(node)) continue;
+        seen.add(node);
+        if (wantedTypes.has(nodeType(node))) return node;
+        for (const input of node.inputs ?? []) {
+            if (input.link == null) continue;
+            const link = graphLink(node.graph, input.link);
+            const parent = link ? node.graph?.getNodeById?.(link.origin_id) : null;
+            if (parent) queue.push(parent);
+        }
+    }
+    return null;
+}
+
+function writeWidget(node, name, value, unavailable, label) {
+    const widget = widgetByName(node, name);
+    if (!widget) {
+        unavailable.push(`${label}.${name}`);
+        return false;
+    }
+    widget.value = value;
+    widget.callback?.(value);
+    return true;
+}
+
+function effectiveTransition(values) {
+    if (!values || typeof values !== "object") return null;
+    if (Boolean(values.expert_override)) {
+        const continuationMode = String(
+            values.expert_continuation_mode ?? values.continuation_mode ?? "");
+        const contextLength = Number(
+            values.expert_context_length ?? values.context_length);
+        if (!continuationMode || !Number.isInteger(contextLength)) return null;
+        return {continuationMode, contextLength};
+    }
+    const preset = transitionPreset(String(values.preset ?? ""));
+    return preset ? {
+        continuationMode: preset.continuationMode,
+        contextLength: preset.contextLength,
+    } : null;
+}
+
+function restoreCompactAudio(node, policyInputs, applied, unavailable) {
+    const audio = policyInputs.audio_policy;
+    if (audio && typeof audio === "object") {
+        const entries = [
+            ["final_audio", audio.final_audio],
+            ["source_reference", audio.source_reference],
+            ["generated_continuity", audio.generated_continuity],
+        ].filter(([name]) => Object.hasOwn(audio, name));
+        // The disabled spelling is intentionally omitted from canonical
+        // policies. Restore its absence as false so loading an older run also
+        // clears a currently enabled compact-policy switch.
+        entries.push([
+            "lock_source_audio",
+            audio.source_audio_target === "locked",
+        ]);
+        const complete = entries.every(([name, value]) => writeWidget(
+            node, name, value, unavailable, "audio_policy"));
+        if (complete) applied.push("audio_policy");
+    }
+}
+
+function restoreProfileAudio(node, policyInputs, applied, unavailable) {
+    const audio = policyInputs.audio_policy;
+    if (!audio || typeof audio !== "object") return;
+    const completeAxes = [
+        "final_audio", "source_reference", "generated_continuity",
+    ].every((name) => Object.hasOwn(audio, name));
+    if (!completeAxes) {
+        unavailable.push("audio_policy (incomplete saved audio profile)");
+        return;
+    }
+    const sourceAudioTarget = audio.source_audio_target === "locked"
+        ? "locked" : "off";
+    const selected = Object.entries(GENERATION_AUDIO_PROFILES).find(
+        ([, profile]) => (
+            profile.finalAudio === String(audio.final_audio)
+            && profile.sourceReference === String(audio.source_reference)
+            && profile.generatedContinuity === String(
+                audio.generated_continuity)
+            && profile.sourceAudioTarget === sourceAudioTarget
+        ),
+    )?.[0];
+    if (!selected) {
+        unavailable.push(
+            "audio_policy (saved combination needs the Manual Chain Policy)",
+        );
+        return;
+    }
+    if (writeWidget(
+        node, "audio_profile", selected, unavailable, "audio_policy",
+    )) applied.push("audio_policy");
+}
+
+function restoreCompactTransition(node, policyInputs, planInputs,
+                                  applied, unavailable) {
+    const transition = policyInputs.transition_policy;
+    if (!transition || typeof transition !== "object") return;
+    const effective = effectiveTransition(transition);
+    const preset = effective ? transitionPresetName(
+        effective.continuationMode, effective.contextLength) : "custom";
+    const savedAudioContext = Number(planInputs?.audio_context_length);
+    const audioContextMatches = !Number.isInteger(savedAudioContext)
+        || savedAudioContext === effective?.contextLength;
+    if (!PRIMARY_TRANSITION_PRESETS.includes(preset)
+            || !audioContextMatches) {
+        unavailable.push(
+            "transition_policy (saved boundary needs Advanced Policy or the "
+            + "Legacy 0.4 Policy Adapter)",
+        );
+        return;
+    }
+    if (writeWidget(
+        node, "incoming_transition", preset, unavailable,
+        "transition_policy",
+    )) applied.push("transition_policy");
+}
+
+function restoreProfileTransition(node, policyInputs, planInputs,
+                                  applied, unavailable) {
+    const transition = policyInputs.transition_policy;
+    if (!transition || typeof transition !== "object") return;
+    const effective = effectiveTransition(transition);
+    const preset = effective ? transitionPresetName(
+        effective.continuationMode, effective.contextLength) : "custom";
+    const selected = Object.entries(GENERATION_SCENE_PROFILES).find(
+        ([, profilePreset]) => profilePreset === preset,
+    )?.[0];
+    const savedAudioContext = Number(planInputs?.audio_context_length);
+    const audioContextMatches = !Number.isInteger(savedAudioContext)
+        || savedAudioContext === effective?.contextLength;
+    if (!selected || !audioContextMatches) {
+        unavailable.push(
+            "transition_policy (saved boundary needs Advanced Policy or the "
+            + "Legacy 0.4 Policy Adapter)",
+        );
+        return;
+    }
+    if (writeWidget(
+        node, "scene_continuity", selected, unavailable,
+        "transition_policy",
+    )) applied.push("transition_policy");
+}
+
+function restoreLegacyAudio(node, policyInputs, applied, unavailable) {
+    const audio = policyInputs.audio_policy;
+    if (audio && typeof audio === "object") {
+        if (audio.source_audio_target === "locked") {
+            unavailable.push(
+                "audio_policy (source target lock needs Generation Profile "
+                + "or Manual Chain Policy)");
+        } else {
+            const completeAxes = [
+                "final_audio", "source_reference", "generated_continuity",
+            ].every((name) => Object.hasOwn(audio, name));
+            if (!completeAxes) {
+                unavailable.push(
+                    "audio_policy (incomplete saved legacy 0.4 axes)");
+            } else {
+                const axes = [
+                    String(audio.final_audio), String(audio.source_reference),
+                    String(audio.generated_continuity),
+                ];
+                const audioMode = Object.entries(LEGACY_AUDIO_POLICIES).find(
+                    ([, value]) => value.every(
+                        (item, index) => item === axes[index]),
+                )?.[0];
+                if (!audioMode) {
+                    unavailable.push(
+                        "audio_policy (unsupported legacy 0.4 axes)");
+                } else if (writeWidget(
+                    node, "audio_mode", audioMode, unavailable, "audio_policy",
+                )) applied.push("audio_policy");
+            }
+        }
+    }
+}
+
+function restoreLegacyTransition(node, policyInputs, planInputs,
+                                 applied, unavailable) {
+    const transition = policyInputs.transition_policy;
+    if (!transition || typeof transition !== "object") return;
+    const effective = effectiveTransition(transition);
+    if (!effective) {
+        unavailable.push("transition_policy (invalid saved boundary)");
+        return;
+    }
+    const audioContext = Number(planInputs?.audio_context_length);
+    const resolvedAudioContext = Number.isInteger(audioContext)
+        ? audioContext : effective.contextLength;
+    const complete = [
+        ["continuation_mode", effective.continuationMode],
+        ["context_length", effective.contextLength],
+        ["audio_context_length", resolvedAudioContext],
+    ].every(([name, value]) => writeWidget(
+        node, name, value, unavailable, "transition_policy"));
+    if (complete) applied.push("transition_policy");
+}
+
+function restoreAdvancedTransition(node, policyInputs, planInputs,
+                                   applied, unavailable) {
+    const transition = policyInputs.transition_policy;
+    if (!transition || typeof transition !== "object") return;
+    const effective = effectiveTransition(transition);
+    if (!effective) {
+        unavailable.push("transition_policy (invalid saved boundary)");
+        return;
+    }
+    const preset = transitionPresetName(
+        effective.continuationMode, effective.contextLength);
+    const savedAudioContext = Number(planInputs?.audio_context_length);
+    const audioContextMatches = !Number.isInteger(savedAudioContext)
+        || savedAudioContext === effective.contextLength;
+    if (!ADVANCED_TRANSITION_PRESETS.includes(preset)
+            || !audioContextMatches) {
+        unavailable.push(
+            "transition_policy (saved raw boundary needs the Legacy 0.4 "
+            + "Policy Adapter as the final policy layer)",
+        );
+        return;
+    }
+    if (writeWidget(
+        node, "incoming_transition", preset, unavailable,
+        "transition_policy",
+    )) applied.push("transition_policy");
+}
+
+/** Restore normalized policy records onto the one-wire policy node already
+ * connected to Plan. Connections are never replaced or invented. */
+export function restoreConnectedPolicyInputs(
+    planNode, policyInputs, planInputs = {},
+) {
+    const applied = [];
+    const unavailable = [];
+    if (!policyInputs || typeof policyInputs !== "object") {
+        return {applied, unavailable};
+    }
+    const graph = planNode?.graph;
+    graph?.beforeChange?.();
+    try {
+        const combinedOrigin = linkedInputOrigin(planNode, "chain_policy");
+        const profile = findUpstreamType(
+            combinedOrigin, PROFILE_POLICY_NODE);
+        const compact = findUpstreamType(combinedOrigin, CHAIN_POLICY_NODE);
+        const legacy = findUpstreamType(combinedOrigin, LEGACY_POLICY_NODE);
+        if (profile) {
+            restoreProfileAudio(
+                profile, policyInputs, applied, unavailable);
+            profile.graph?.setDirtyCanvas?.(true, true);
+        } else if (compact) {
+            restoreCompactAudio(
+                compact, policyInputs, applied, unavailable);
+            compact.graph?.setDirtyCanvas?.(true, true);
+        } else if (legacy) {
+            restoreLegacyAudio(legacy, policyInputs, applied, unavailable);
+            legacy.graph?.setDirtyCanvas?.(true, true);
+        }
+
+        const transitionTarget = findFirstUpstreamType(
+            combinedOrigin,
+            new Set([
+                ADVANCED_POLICY_NODE, LEGACY_POLICY_NODE,
+                PROFILE_POLICY_NODE, CHAIN_POLICY_NODE,
+            ]),
+        );
+        if (nodeType(transitionTarget) === ADVANCED_POLICY_NODE) {
+            restoreAdvancedTransition(
+                transitionTarget, policyInputs, planInputs,
+                applied, unavailable);
+        } else if (nodeType(transitionTarget) === LEGACY_POLICY_NODE) {
+            restoreLegacyTransition(
+                transitionTarget, policyInputs, planInputs,
+                applied, unavailable);
+        } else if (nodeType(transitionTarget) === PROFILE_POLICY_NODE) {
+            restoreProfileTransition(
+                transitionTarget, policyInputs, planInputs,
+                applied, unavailable);
+        } else if (nodeType(transitionTarget) === CHAIN_POLICY_NODE) {
+            restoreCompactTransition(
+                transitionTarget, policyInputs, planInputs,
+                applied, unavailable);
+        } else {
+            unavailable.push(
+                "chain_policy (connect MiniMax H3 Generation Profile, "
+                + "Manual Chain Policy, Advanced Policy, or the Legacy 0.4 "
+                + "Policy Adapter)",
+            );
+        }
+    } finally {
+        graph?.afterChange?.();
+    }
+    return {applied, unavailable};
+}
+
+/** Force every authoring surface bound to the restored Plan to reparse it.
+ * This avoids waiting for polling and prevents a prompt editor from continuing
+ * to display a stale pre-restore scene prompt. */
+export function refreshRestoredPlanEditors(planNode) {
+    planNode?._h3ChainEditorRefresh?.();
+    const graph = planNode?.graph?.rootGraph ?? planNode?.graph;
+    for (const node of allNodes(graph)) {
+        if (node === planNode) continue;
+        node._h3ScenePromptEditorRefresh?.();
+        node._h3RichPromptRefresh?.();
+        node._h3PlanStudioRefresh?.();
+    }
+    planNode?.graph?.setDirtyCanvas?.(true, true);
+    graph?.setDirtyCanvas?.(true, true);
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_plan_upgrade_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_plan_upgrade_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..56c1cabded9133fe362af27582728a2ab035b97e
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_plan_upgrade_core.mjs
@@ -0,0 +1,109 @@
+export const LEGACY_PLAN_NODE = "MiniMaxH3ChainPlan";
+export const MODERN_PLAN_NODE = "MiniMaxH3ChainPlanModern";
+export const MODERN_PLAN_WIDGET_NAMES = Object.freeze([
+    "plan_json", "run_name", "generation_fingerprint", "width", "height",
+    "encode_mode", "crop", "default_duration_seconds", "default_steps",
+    "base_seed", "segment_crf", "video_blend_frames",
+]);
+
+function graphLink(graph, id) {
+    if (id == null) return null;
+    return graph?.links?.[id] ?? graph?.links?.get?.(id) ?? null;
+}
+
+function inputConnected(node, name) {
+    const input = node?.inputs?.find((item) => item.name === name);
+    return input?.link !== null && input?.link !== undefined;
+}
+
+function widgetValue(node, name) {
+    return node?.widgets?.find((item) => item.name === name)?.value;
+}
+
+function cloneSerializable(value, fallback) {
+    try {
+        return typeof structuredClone === "function"
+            ? structuredClone(value) : JSON.parse(JSON.stringify(value));
+    } catch (_error) {
+        return fallback;
+    }
+}
+
+/** Replace one legacy Plan without interpreting its positional widget array.
+ *
+ * Connections and supported values are resolved by name. The caller owns all
+ * confirmation/error UI so this helper remains testable without ComfyUI's DOM.
+ */
+export function upgradeLegacyPlanNode(node, {
+    createNode,
+    confirmUpgrade = () => true,
+} = {}) {
+    const graph = node?.graph;
+    if (!graph || typeof createNode !== "function") {
+        return {ok:false, reason:"create_unavailable"};
+    }
+    if (!inputConnected(node, "chain_policy")) {
+        return {ok:false, reason:"policy_required"};
+    }
+    if (!confirmUpgrade()) return {ok:false, reason:"cancelled"};
+
+    const incoming = (node.inputs ?? []).map((input) => {
+        const link = graphLink(graph, input.link);
+        return link ? {
+            name: input.name,
+            originId: link.origin_id,
+            originSlot: link.origin_slot,
+        } : null;
+    }).filter(Boolean);
+    const outgoing = [];
+    for (const output of node.outputs ?? []) {
+        for (const linkId of output.links ?? []) {
+            const link = graphLink(graph, linkId);
+            if (link) outgoing.push({
+                name: output.name,
+                targetId: link.target_id,
+                targetSlot: link.target_slot,
+            });
+        }
+    }
+
+    const replacement = createNode(MODERN_PLAN_NODE);
+    if (!replacement) return {ok:false, reason:"modern_unregistered"};
+    for (const name of MODERN_PLAN_WIDGET_NAMES) {
+        const value = widgetValue(node, name);
+        if (value === undefined) continue;
+        const widget = replacement.widgets?.find((item) => item.name === name);
+        if (widget) widget.value = value;
+    }
+    replacement.pos = Array.isArray(node.pos) ? [...node.pos] : node.pos;
+    replacement.properties = cloneSerializable(node.properties, {});
+    replacement.color = node.color;
+    replacement.bgcolor = node.bgcolor;
+    replacement.mode = node.mode;
+
+    graph.add(replacement);
+    if (node.size != null) {
+        replacement.setSize?.(
+            Array.isArray(node.size) ? [...node.size] : node.size);
+    }
+    graph.remove(node);
+
+    for (const item of incoming) {
+        const origin = graph.getNodeById?.(item.originId);
+        const targetSlot = replacement.inputs?.findIndex(
+            (input) => input.name === item.name);
+        if (origin && targetSlot >= 0) {
+            origin.connect?.(item.originSlot, replacement, targetSlot);
+        }
+    }
+    for (const item of outgoing) {
+        const target = graph.getNodeById?.(item.targetId);
+        const originSlot = replacement.outputs?.findIndex(
+            (output) => output.name === item.name);
+        if (target && originSlot >= 0) {
+            replacement.connect?.(originSlot, target, item.targetSlot);
+        }
+    }
+    graph.setDirtyCanvas?.(true, true);
+    return {ok:true, node:replacement};
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_policy_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_policy_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..ed9884e17a738faaec8b266530924a049eb0430f
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_policy_core.mjs
@@ -0,0 +1,289 @@
+// Shared authoring vocabulary for compact 0.5 policy controls. Runtime Python
+// remains authoritative; this module prevents the editor, Studio, socket
+// presentation, and restore UI from inventing different preset mappings.
+
+export const PRIMARY_TRANSITION_PRESETS = Object.freeze([
+    "cut", "guide", "hard_av", "soft_av",
+]);
+
+export const GENERATION_SCENE_PROFILES = Object.freeze({
+    "Visual continuity": "guide",
+    "Independent scenes": "cut",
+    "Hard picture + protected audio": "hard_av",
+    "Hard picture + smooth audio": "soft_av",
+});
+
+export const GENERATION_AUDIO_PROFILES = Object.freeze({
+    "Generate audio": Object.freeze({
+        finalAudio:"generated", sourceReference:"off",
+        generatedContinuity:"on", sourceAudioTarget:"off",
+    }),
+    "Generate fresh audio per scene": Object.freeze({
+        finalAudio:"generated", sourceReference:"off",
+        generatedContinuity:"off", sourceAudioTarget:"off",
+    }),
+    "Lip-sync to source audio": Object.freeze({
+        finalAudio:"source", sourceReference:"off",
+        generatedContinuity:"off", sourceAudioTarget:"locked",
+    }),
+    "Generate audio from source guide": Object.freeze({
+        finalAudio:"generated", sourceReference:"on",
+        generatedContinuity:"off", sourceAudioTarget:"off",
+    }),
+    "Use source soundtrack only": Object.freeze({
+        finalAudio:"source", sourceReference:"off",
+        generatedContinuity:"off", sourceAudioTarget:"off",
+    }),
+    "No final audio": Object.freeze({
+        finalAudio:"none", sourceReference:"off",
+        generatedContinuity:"off", sourceAudioTarget:"off",
+    }),
+});
+
+export const TRANSITION_PRESETS = Object.freeze({
+    cut: Object.freeze({
+        continuationMode: "guide", contextLength: 0,
+        label: "Visual Cut", description: "No carried picture",
+    }),
+    guide: Object.freeze({
+        continuationMode: "guide", contextLength: 22,
+        label: "Guide", description: "22-frame RGB continuation",
+    }),
+    tone_guide: Object.freeze({
+        continuationMode: "tone_carry_guide", contextLength: 22,
+        label: "Tone Guide", description: "Experimental corrected RGB guide",
+    }),
+    latent_guide: Object.freeze({
+        continuationMode: "latent_guide", contextLength: 22,
+        label: "Latent Guide", description: "Direct generated-latent guide",
+    }),
+    detail_guide: Object.freeze({
+        continuationMode: "tapered_guide", contextLength: 22,
+        label: "Detail Guide", description: "Experimental tapered chroma guide",
+    }),
+    detail_av: Object.freeze({
+        continuationMode: "tapered_av", contextLength: 39,
+        label: "Detail AV", description: "Experimental latent taper",
+    }),
+    drift_av: Object.freeze({
+        continuationMode: "drift_control_av", contextLength: 39,
+        label: "Drift-Control AV", description: "Experimental schedule-matched mask",
+    }),
+    color_drift_av: Object.freeze({
+        continuationMode: "color_stable_drift_av", contextLength: 39,
+        label: "Color-Stable Drift AV",
+        description: "Drift-Control plus tapered scene-one latent color delta",
+    }),
+    hard_av: Object.freeze({
+        continuationMode: "masked_av", contextLength: 39,
+        label: "Hard AV", description: "Protected 39-frame AV prefix",
+    }),
+    soft_av: Object.freeze({
+        continuationMode: "audio_feathered_av", contextLength: 39,
+        label: "Soft AV", description: "Hard picture with a short audio release",
+    }),
+    // Read-only migration alias. Never expose this as a normal selector item.
+    audio_feather_av: Object.freeze({
+        continuationMode: "audio_feathered_av", contextLength: 39,
+        label: "Soft AV", description: "Legacy preset alias",
+    }),
+});
+
+// Semantic recipes accepted by the composable Advanced Policy node. The
+// audio_feather_av spelling is a read-only migration alias for soft_av.
+export const ADVANCED_TRANSITION_PRESETS = Object.freeze([
+    "cut", "guide", "tone_guide", "latent_guide", "detail_guide",
+    "detail_av", "drift_av", "color_drift_av", "hard_av", "soft_av",
+]);
+
+export const LEGACY_AUDIO_POLICIES = Object.freeze({
+    source_track: Object.freeze(["source", "on", "off"]),
+    generated_audio: Object.freeze(["generated", "off", "on"]),
+    source_plus_timeline: Object.freeze(["source", "on", "on"]),
+});
+
+export function transitionPreset(name) {
+    return TRANSITION_PRESETS[String(name)] ?? null;
+}
+
+export function transitionPresetName(
+    continuationMode, contextLength, {includeAlias = false} = {},
+) {
+    const mode = String(continuationMode ?? "");
+    const context = Number(contextLength);
+    for (const [name, preset] of Object.entries(TRANSITION_PRESETS)) {
+        if (!includeAlias && name === "audio_feather_av") continue;
+        if (preset.continuationMode === mode && preset.contextLength === context) {
+            return name;
+        }
+    }
+    return "custom";
+}
+
+export function transitionPresetLabel(name) {
+    if (name === "inherit") return "Inherit Chain Policy";
+    if (name === "custom") return "Custom · Advanced controls";
+    return transitionPreset(name)?.label ?? String(name ?? "Unknown");
+}
+
+export function sceneTransitionPreset(
+    shot, defaultContinuationMode = "guide", defaultContextLength = 22,
+    defaultAudioContextLength = defaultContextLength,
+) {
+    const hasAudioContext = Object.hasOwn(shot ?? {}, "audio_context_length")
+        && shot.audio_context_length !== null
+        && !(typeof shot.audio_context_length === "string"
+            && !String(shot.audio_context_length).trim());
+    const hasMode = Object.hasOwn(shot ?? {}, "continuation_mode")
+        && shot.continuation_mode !== null
+        && !(typeof shot.continuation_mode === "string"
+            && !shot.continuation_mode.trim());
+    const hasContext = Object.hasOwn(shot ?? {}, "context_length")
+        && shot.context_length !== null
+        && !(typeof shot.context_length === "string"
+            && !String(shot.context_length).trim());
+    if (!hasMode && !hasContext && !hasAudioContext) {
+        return "inherit";
+    }
+    const selected = transitionPresetName(
+        hasMode ? shot.continuation_mode : defaultContinuationMode,
+        hasContext ? shot.context_length : defaultContextLength,
+    );
+    const effectiveAudioContext = hasAudioContext
+        ? Number(shot.audio_context_length) : Number(defaultAudioContextLength);
+    if ((hasMode || hasContext || hasAudioContext) && (
+        selected === "custom"
+        || effectiveAudioContext !== transitionPreset(selected)?.contextLength
+    )) return "custom";
+    return selected;
+}
+
+export function applySceneTransitionPreset(shot, name) {
+    if (!shot || typeof shot !== "object" || Array.isArray(shot)) {
+        throw new Error("A scene transition requires a scene object.");
+    }
+    const selected = String(name);
+    if (selected === "custom") return shot;
+    if (selected === "inherit") {
+        delete shot.continuation_mode;
+        delete shot.context_length;
+        delete shot.audio_context_length;
+        return shot;
+    }
+    if (!PRIMARY_TRANSITION_PRESETS.includes(selected)) {
+        throw new Error(`Unknown compact scene transition “${selected}”.`);
+    }
+    const preset = transitionPreset(selected);
+    shot.continuation_mode = preset.continuationMode;
+    shot.context_length = preset.contextLength;
+    // Keep generated-audio carry on the same tested boundary without
+    // exposing a second normal-user duration choice.
+    shot.audio_context_length = preset.contextLength;
+    return shot;
+}
+
+export function primaryTransitionOptions() {
+    return PRIMARY_TRANSITION_PRESETS.map((name) => {
+        const preset = transitionPreset(name);
+        return {
+            name,
+            label: preset.label,
+            description: preset.description,
+            continuationMode: preset.continuationMode,
+            contextLength: preset.contextLength,
+        };
+    });
+}
+
+const SCENE_AUDIO_AXES = Object.freeze({
+    source_reference: Object.freeze(["off", "on"]),
+    generated_continuity: Object.freeze(["off", "on"]),
+    source_audio_target: Object.freeze(["off", "locked"]),
+});
+
+function sceneAudioAxis(shot, key, fallback) {
+    const raw = shot?.[key];
+    if (raw === undefined || raw === null || String(raw).trim() === ""
+            || String(raw).trim().toLowerCase() === "inherit") {
+        return fallback;
+    }
+    const value = String(raw).trim().toLowerCase();
+    if (!SCENE_AUDIO_AXES[key]?.includes(value)) {
+        throw new Error(`Unknown scene ${key.replaceAll("_", " ")} override “${raw}”.`);
+    }
+    return value;
+}
+
+export function sceneAudioPolicy(shot, planPolicy = {}) {
+    const finalAudio = String(planPolicy.finalAudio ?? "generated");
+    const sourceReference = sceneAudioAxis(
+        shot, "source_reference", String(planPolicy.sourceReference ?? "off"),
+    );
+    const generatedContinuity = sceneAudioAxis(
+        shot, "generated_continuity",
+        String(planPolicy.generatedContinuity ?? "on"),
+    );
+    const sourceAudioTarget = sceneAudioAxis(
+        shot, "source_audio_target",
+        String(planPolicy.sourceAudioTarget ?? "off"),
+    );
+    if (sourceAudioTarget === "locked") {
+        return {
+            finalAudio, sourceReference:"off", generatedContinuity:"off",
+            sourceAudioTarget,
+        };
+    }
+    return {
+        finalAudio, sourceReference, generatedContinuity, sourceAudioTarget,
+    };
+}
+
+export function sceneAudioOverride(shot, key) {
+    if (!Object.hasOwn(SCENE_AUDIO_AXES, key)) {
+        throw new Error(`Unknown scene audio override axis “${key}”.`);
+    }
+    if (!Object.hasOwn(shot ?? {}, key) || shot[key] === null
+            || String(shot[key]).trim() === ""
+            || String(shot[key]).trim().toLowerCase() === "inherit") {
+        return "inherit";
+    }
+    return sceneAudioAxis(shot, key, null);
+}
+
+export function applySceneAudioOverride(shot, key, value) {
+    if (!shot || typeof shot !== "object" || Array.isArray(shot)) {
+        throw new Error("A scene audio override requires a scene object.");
+    }
+    if (!Object.hasOwn(SCENE_AUDIO_AXES, key)) {
+        throw new Error(`Unknown scene audio override axis “${key}”.`);
+    }
+    const selected = String(value ?? "inherit").trim().toLowerCase();
+    if (!selected || selected === "inherit") {
+        delete shot[key];
+        return shot;
+    }
+    if (!SCENE_AUDIO_AXES[key].includes(selected)) {
+        throw new Error(`Unknown scene ${key.replaceAll("_", " ")} override “${value}”.`);
+    }
+    shot[key] = selected;
+    return shot;
+}
+
+export function sceneLipSyncMode(shot) {
+    const keys = ["source_audio_target", "source_reference", "generated_continuity"];
+    if (keys.every((key) => sceneAudioOverride(shot, key) === "inherit")) return "inherit";
+    if (sceneAudioOverride(shot, "source_audio_target") === "locked") return "on";
+    if (keys.every((key) => sceneAudioOverride(shot, key) === "off")) return "off";
+    return "custom";
+}
+
+export function applySceneLipSync(shot, value) {
+    if (!["inherit", "on", "off"].includes(value)) {
+        throw new Error("Choose Inherit, On, or Off for scene lip-sync.");
+    }
+    for (const key of ["source_audio_target", "source_reference", "generated_continuity"]) {
+        applySceneAudioOverride(shot, key, value === "inherit" ? "inherit"
+            : value === "on" && key === "source_audio_target" ? "locked" : "off");
+    }
+    return shot;
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_project_asset_editor_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_project_asset_editor_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..5c5a5a0ddad1c10feb98a266a922bc172c18325d
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_project_asset_editor_core.mjs
@@ -0,0 +1,136 @@
+export const AUDIO_TRACK_ROLES = Object.freeze([
+    ["full_mix", "Full mix · final soundtrack"],
+    ["vocals", "Vocals · lip-sync driver"],
+    ["instrumental", "Instrumental · optional backing"],
+]);
+
+export function projectAudioTrackBindings(asset) {
+    const saved = asset?.options?.audio_tracks;
+    return Object.fromEntries(AUDIO_TRACK_ROLES.map(([role]) => [role,
+        String(saved ? saved[role] ?? "" : role === "full_mix" ? asset?.id ?? "" : ""),
+    ]));
+}
+
+export function setProjectAudioTrack(asset, role, assetId) {
+    if (!AUDIO_TRACK_ROLES.some(([key]) => key === role)) throw new Error("Unknown audio track role.");
+    const bindings = projectAudioTrackBindings(asset);
+    const id = String(assetId ?? "");
+    for (const key of Object.keys(bindings)) {
+        if (key !== role && id && bindings[key] === id) bindings[key] = "";
+    }
+    bindings[role] = id;
+    if (!Object.values(bindings).some(Boolean)) throw new Error("Keep at least one audio track, or reset to single track.");
+    return bindings;
+}
+
+function positiveNumber(value, fallback = 0) {
+    const number = Number(value);
+    return Number.isFinite(number) && number > 0 ? number : fallback;
+}
+
+export function imageMegapixels(width, height) {
+    return positiveNumber(width) * positiveNumber(height) / 1_000_000;
+}
+
+function normalizedMultiple(value) {
+    const multiple = Math.round(positiveNumber(value, 1));
+    return multiple > 1 ? multiple : 1;
+}
+
+function snappedDimension(value, multiple) {
+    const step = normalizedMultiple(multiple);
+    return Math.max(step, Math.round(positiveNumber(value, step) / step) * step);
+}
+
+function greatestCommonDivisor(left, right) {
+    let a = Math.abs(Math.round(left));
+    let b = Math.abs(Math.round(right));
+    while (b) [a, b] = [b, a % b];
+    return a || 1;
+}
+
+function leastCommonMultiple(left, right) {
+    return Math.abs(left * right) / greatestCommonDivisor(left, right);
+}
+
+function approximateFraction(value, maximumDenominator = 256) {
+    let best = {numerator: Math.max(1, Math.round(value)), denominator: 1};
+    let bestError = Math.abs(best.numerator / best.denominator - value);
+    for (let denominator = 1; denominator <= maximumDenominator; denominator += 1) {
+        const numerator = Math.max(1, Math.round(value * denominator));
+        const error = Math.abs(numerator / denominator - value);
+        if (error < bestError - Number.EPSILON) {
+            best = {numerator, denominator}; bestError = error;
+        }
+    }
+    const divisor = greatestCommonDivisor(best.numerator, best.denominator);
+    return {
+        numerator: best.numerator / divisor,
+        denominator: best.denominator / divisor,
+    };
+}
+
+export function dimensionsForMegapixels(
+        megapixels, aspectRatio, multiple = 1) {
+    const pixels = positiveNumber(megapixels, 0.01) * 1_000_000;
+    const ratio = positiveNumber(aspectRatio, 1);
+    const idealWidth = Math.sqrt(pixels * ratio);
+    const idealHeight = idealWidth / ratio;
+    const step = normalizedMultiple(multiple);
+    if (step === 1) {
+        const width = Math.max(1, Math.round(idealWidth));
+        const height = Math.max(1, Math.round(width / ratio));
+        return {width, height};
+    }
+    // Preserve the locked ratio exactly. Reducing it to a small rational pair
+    // lets us find the nearest scale where both dimensions share the requested
+    // model-friendly multiple.
+    const fraction = approximateFraction(ratio);
+    const scaleStep = leastCommonMultiple(
+        step / greatestCommonDivisor(fraction.numerator, step),
+        step / greatestCommonDivisor(fraction.denominator, step),
+    );
+    const idealScale = Math.sqrt(
+        pixels / (fraction.numerator * fraction.denominator));
+    const lowerScale = Math.max(
+        scaleStep, Math.floor(idealScale / scaleStep) * scaleStep);
+    const upperScale = Math.max(
+        scaleStep, Math.ceil(idealScale / scaleStep) * scaleStep);
+    const candidates = [lowerScale, upperScale].map((scale) => ({
+        width: fraction.numerator * scale,
+        height: fraction.denominator * scale,
+    }));
+    candidates.sort((left, right) => (
+        Math.abs(Math.log((left.width * left.height) / pixels))
+        - Math.abs(Math.log((right.width * right.height) / pixels))
+    ));
+    return candidates[0];
+}
+
+export function coupledOutputDimensions(
+        width, height, changed, aspectRatio, locked = true, multiple = 1) {
+    const step = normalizedMultiple(multiple);
+    let outputWidth = snappedDimension(width, step);
+    let outputHeight = snappedDimension(height, step);
+    if (!locked) return {width: outputWidth, height: outputHeight};
+    const ratio = positiveNumber(aspectRatio, outputWidth / outputHeight);
+    if (step > 1) {
+        const pixels = changed === "height"
+            ? outputHeight * (outputHeight * ratio)
+            : outputWidth * (outputWidth / ratio);
+        return dimensionsForMegapixels(pixels / 1_000_000, ratio, step);
+    }
+    if (changed === "height") {
+        outputWidth = snappedDimension(outputHeight * ratio, step);
+    } else {
+        outputHeight = snappedDimension(outputWidth / ratio, step);
+    }
+    return {width: outputWidth, height: outputHeight};
+}
+
+export function formatMegapixels(value) {
+    const megapixels = positiveNumber(value);
+    if (megapixels >= 10) return megapixels.toFixed(1);
+    if (megapixels >= 1) return megapixels.toFixed(2);
+    return megapixels.toFixed(3);
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_project_asset_manager.js b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_project_asset_manager.js
new file mode 100644
index 0000000000000000000000000000000000000000..418c90746377c1ac8b2c5a2282238292b9909d9b
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_project_asset_manager.js
@@ -0,0 +1,2265 @@
+import {app} from "/scripts/app.js";
+import {api} from "/scripts/api.js";
+import {
+    coupledOutputDimensions,
+    AUDIO_TRACK_ROLES,
+    projectAudioTrackBindings,
+    setProjectAudioTrack,
+    dimensionsForMegapixels,
+    formatMegapixels,
+    imageMegapixels,
+} from "./h3_project_asset_editor_core.mjs?v=0.6.6";
+import {
+    publishProjectAssetCatalogChanged,
+    serializedProjectAssetCatalog,
+    serializedProjectAssetIdentity,
+} from "./h3_project_asset_sync_core.mjs?v=0.6.2";
+
+const NODE_NAME = "MiniMaxH3ProjectAssetManager";
+const SEMANTIC_SETTING_WIDGETS = [
+    "semantic_anchor_size", "semantic_anchor_mode",
+];
+const PLAN_TYPES = new Set([
+    "MiniMaxH3ChainPlan", "MiniMaxH3ChainPlanModern",
+    "MiniMaxH3ChainPlanStudio",
+]);
+const ROLES = {
+    image: ["picture", "semantic_anchor"],
+    video: ["video", "motion", "source_track"],
+    audio: ["audio_reference", "source_track"],
+};
+const ROLE_LABELS = {
+    picture: "picture reference",
+    semantic_anchor: "semantic anchor",
+    video: "video reference",
+    motion: "motion reference",
+    audio_reference: "tagged audio reference",
+    source_track: "source track",
+};
+
+function displayRole(role) {
+    return ROLE_LABELS[role] ?? String(role || "").replaceAll("_", " ");
+}
+
+function nodeType(node) {
+    return node?.comfyClass ?? node?.type ?? "";
+}
+
+function widget(node, name) {
+    return node?.widgets?.find((item) => item.name === name) ?? null;
+}
+
+function partialExecutionId(node) {
+    const graph = node?.graph;
+    const root = graph?.rootGraph ?? app.graph;
+    if (!graph || !root || graph === root || graph.isRootGraph) return String(node.id);
+    function pathTo(target, current) {
+        for (const candidate of current?.nodes ?? current?._nodes ?? []) {
+            const subgraph = candidate?.subgraph;
+            if (!subgraph) continue;
+            if (subgraph === target) return String(candidate.id);
+            const child = pathTo(target, subgraph);
+            if (child !== undefined) return `${candidate.id}:${child}`;
+        }
+        return undefined;
+    }
+    const parent = pathTo(graph, root);
+    if (parent === undefined) {
+        throw new Error("Could not resolve this Carousel inside its subgraph.");
+    }
+    return `${parent}:${node.id}`;
+}
+
+function el(tag, className = "", text = null) {
+    const item = document.createElement(tag);
+    if (className) item.className = className;
+    if (text !== null) item.textContent = text;
+    return item;
+}
+
+function button(label, action, title = "") {
+    const item = el("button", "h3pa-button", label);
+    item.type = "button";
+    item.title = title;
+    item.addEventListener("click", action);
+    return item;
+}
+
+async function jsonRequest(route, options = {}) {
+    const response = await api.fetchApi(route, options);
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok) throw new Error(payload.error || `${response.status}`);
+    return payload;
+}
+
+function mediaUrl(project, asset, variant) {
+    const query = new URLSearchParams({
+        project, asset: String(asset.id), variant,
+    });
+    return api.apiURL(
+        `/minimax_h3_context_loop/project-assets/media?${query}`,
+    );
+}
+
+function formatBytes(value) {
+    let number = Number(value) || 0;
+    const units = ["B", "KiB", "MiB", "GiB", "TiB"];
+    let index = 0;
+    while (number >= 1024 && index < units.length - 1) {
+        number /= 1024;
+        index += 1;
+    }
+    return `${number.toFixed(index ? 1 : 0)} ${units[index]}`;
+}
+
+function formatLyricsTimestamp(seconds) {
+    const centiseconds = Math.max(0, Math.round((Number(seconds) || 0) * 100));
+    const minutes = Math.floor(centiseconds / 6000);
+    const remainder = centiseconds - minutes * 6000;
+    return `[${String(minutes).padStart(2, "0")}:${String(
+        Math.floor(remainder / 100),
+    ).padStart(2, "0")}.${String(remainder % 100).padStart(2, "0")}]`;
+}
+
+function assetDetail(asset) {
+    const meta = asset.metadata ?? {};
+    const pieces = [asset.kind, formatBytes(asset.size)];
+    if (meta.width && meta.height) pieces.push(`${meta.width}×${meta.height}`);
+    if (meta.duration_seconds) pieces.push(`${Number(meta.duration_seconds).toFixed(2)}s`);
+    if (meta.fps) pieces.push(`${Number(meta.fps).toFixed(3)} fps`);
+    if (meta.sample_rate) pieces.push(`${meta.sample_rate} Hz`);
+    if (meta.has_audio) pieces.push("embedded audio");
+    return pieces.join(" · ");
+}
+
+function promptTag(asset) {
+    const prefix = asset?.role === "semantic_anchor" ? "#" : "@";
+    return `${prefix}${asset?.tag ?? ""}`;
+}
+
+function matchesTab(asset, filter) {
+    if (filter === "all") return true;
+    // Assignment is an orthogonal status. Unresolved templates stay visible
+    // in their declared media/role category as well as the Unassigned queue.
+    if (filter === "unassigned") return Boolean(asset._unresolved);
+    if (filter === "semantic") return asset.role === "semantic_anchor";
+    if (filter === "image") return asset.role === "picture";
+    if (filter === "video") return ["video", "motion"].includes(asset.role);
+    if (filter === "audio") return asset.role === "audio_reference";
+    if (filter === "source_track") return asset.role === "source_track";
+    return false;
+}
+
+function injectStyles() {
+    if (document.getElementById("h3-project-assets-style")) return;
+    const style = document.createElement("style");
+    style.id = "h3-project-assets-style";
+    style.textContent = `
+        /* Keep text and surfaces paired with ComfyUI's palette. Dialogs live
+           on body, so they need the same tokens as the in-node carousel. */
+        .h3pa-root,.h3pa-modal{
+          --h3pa-text:var(--input-text,#eee);--h3pa-bg:var(--comfy-menu-bg,#202124);
+          --h3pa-panel:var(--comfy-input-bg,#151820);--h3pa-border:var(--border-color,#566174);
+          --h3pa-muted:color-mix(in srgb,var(--h3pa-text) 82%,var(--h3pa-panel));
+          --h3pa-soft:color-mix(in srgb,var(--h3pa-text) 6%,var(--h3pa-panel));
+          --h3pa-accent:color-mix(in srgb,var(--h3pa-text) 65%,#3979da);
+          --h3pa-selected:color-mix(in srgb,var(--h3pa-accent) 18%,var(--h3pa-panel));
+          --h3pa-danger:color-mix(in srgb,var(--h3pa-text) 60%,#e53935);
+          --h3pa-warning:color-mix(in srgb,var(--h3pa-text) 65%,#c88a26);
+          --h3pa-success:color-mix(in srgb,var(--h3pa-text) 65%,#219653);
+          color:var(--h3pa-text)}
+        .h3pa-root{box-sizing:border-box;height:100%;min-height:520px;padding:12px;
+          display:flex;flex-direction:column;gap:10px;overflow:hidden;color:var(--h3pa-text);
+          background:var(--h3pa-bg);font:12px/1.35 system-ui}
+        .h3pa-root *{box-sizing:border-box}.h3pa-row{display:flex;gap:7px;align-items:center;min-width:0}
+        .h3pa-row input,.h3pa-row select,.h3pa-editor input,.h3pa-editor select,.h3pa-editor textarea{
+          min-width:0;padding:6px 8px;border:1px solid var(--h3pa-border);border-radius:6px;
+          background:var(--h3pa-panel);color:var(--h3pa-text)}.h3pa-project-picker{display:flex;flex:1;min-width:160px}.h3pa-project{flex:1;font-weight:650;border-radius:6px 0 0 6px!important}.h3pa-project-menu{flex:0 0 38px;width:38px;padding:6px 4px!important;border-left:0!important;border-radius:0 6px 6px 0!important;cursor:pointer}
+        .h3pa-button{padding:6px 9px;border:1px solid var(--h3pa-border);border-radius:6px;
+          background:var(--h3pa-panel);color:var(--h3pa-text);cursor:pointer}.h3pa-button:hover{border-color:var(--h3pa-accent)}
+        .h3pa-status{min-height:18px;color:var(--h3pa-muted);white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+        .h3pa-tabs{display:flex;gap:5px;overflow-x:auto;align-items:center;flex:0 0 auto}.h3pa-tab.active{background:var(--h3pa-selected);border-color:var(--h3pa-accent)}
+        .h3pa-folder-tools{display:flex;gap:5px;align-items:center;margin-left:auto;padding-left:7px;border-left:1px solid var(--h3pa-border);flex:0 0 auto}.h3pa-folder-tools select{max-width:190px;min-width:110px;padding:6px 8px;border:1px solid var(--h3pa-border);border-radius:6px;background:var(--h3pa-panel);color:var(--h3pa-text)}
+        .h3pa-stage{flex:1 1 auto;min-height:230px;display:grid;grid-template-columns:minmax(0,1fr) 260px;gap:10px;overflow:hidden}
+        .h3pa-preview{position:relative;display:grid;place-items:center;min-width:0;min-height:220px;
+          overflow:hidden;border:1px solid var(--h3pa-border);border-radius:9px;background:#090b10;color:#eee}
+        .h3pa-preview>img,.h3pa-preview>video{position:absolute;inset:0;display:block;width:100%;height:100%;
+          min-width:0;min-height:0;object-fit:contain}
+        .h3pa-preview>.h3pa-empty{color:#9eabc0}
+        .h3pa-preview audio{width:min(94%,650px)}.h3pa-empty{color:var(--h3pa-muted);text-align:center;padding:24px}
+        .h3pa-preview.h3pa-audio-preview{background:var(--h3pa-bg);color:var(--h3pa-text);display:grid;grid-template-columns:minmax(240px,.72fr) minmax(300px,1.28fr);
+          place-items:stretch;gap:18px;padding:18px}
+        .h3pa-audio-player{display:flex;flex-direction:column;justify-content:center;align-items:center;gap:10px;
+          min-width:0;padding:18px;border:1px solid var(--h3pa-border);border-radius:9px;background:var(--h3pa-panel)}
+        .h3pa-audio-player strong{max-width:100%;overflow:hidden;text-overflow:ellipsis;white-space:nowrap}
+        .h3pa-audio-player audio{width:100%}
+        .h3pa-lyrics{display:flex;flex-direction:column;min-width:0;min-height:0;padding:12px;border:1px solid var(--h3pa-border);
+          border-radius:9px;background:var(--h3pa-panel);text-align:left}
+        .h3pa-lyrics-head{display:flex;justify-content:space-between;gap:12px;align-items:baseline;margin-bottom:8px}
+        .h3pa-lyrics-head strong{font-size:14px}.h3pa-lyrics-head small{color:var(--h3pa-muted);text-align:right}
+        .h3pa-lyrics-actions{display:flex;align-items:center;justify-content:space-between;gap:8px;margin:0 0 8px}
+        .h3pa-lyrics-time{color:var(--h3pa-muted);font-variant-numeric:tabular-nums}
+        .h3pa-lyrics textarea{flex:1;min-width:0;min-height:150px;width:100%;padding:10px 11px;resize:none;
+          border:1px solid var(--h3pa-border);border-radius:7px;background:var(--h3pa-panel);color:var(--h3pa-text);font:13px/1.55 system-ui;
+          white-space:pre-wrap}.h3pa-lyrics textarea:focus{outline:1px solid var(--h3pa-accent);border-color:var(--h3pa-accent)}
+        .h3pa-editor{display:flex;flex-direction:column;gap:8px;padding:10px;overflow:auto;border:1px solid
+          var(--h3pa-border);border-radius:9px;background:var(--h3pa-panel)}
+        .h3pa-editor label{display:flex;flex-direction:column;gap:3px;color:var(--h3pa-muted)}.h3pa-editor textarea{min-height:62px;resize:vertical}
+        .h3pa-editor label.h3pa-toggle,.h3pa-crop-controls label.h3pa-toggle{display:grid;grid-template-columns:18px minmax(0,1fr);gap:8px;align-items:start;
+          padding:8px;border:1px solid color-mix(in srgb,var(--h3pa-border) 72%,transparent);border-radius:7px;
+          background:var(--h3pa-soft);cursor:pointer}
+        .h3pa-editor .h3pa-toggle input,.h3pa-crop-controls .h3pa-toggle input{width:16px;height:16px;min-width:16px;margin:2px 0 0;padding:0;cursor:pointer}
+        .h3pa-toggle-copy{display:flex;flex-direction:column;gap:2px;min-width:0}.h3pa-toggle-copy strong{color:inherit}
+        .h3pa-toggle-copy small{color:var(--h3pa-muted);font-size:11px;line-height:1.3}
+        .h3pa-carousel{position:relative;display:flex;gap:8px;overflow-x:auto;overflow-y:hidden;padding:4px 1px 7px;min-height:126px;
+          border:1px solid transparent;border-radius:9px;transition:border-color .12s ease,background .12s ease,box-shadow .12s ease}
+        .h3pa-carousel.h3pa-drop-active{border-color:var(--h3pa-accent);background:var(--h3pa-selected);box-shadow:inset 0 0 0 2px color-mix(in srgb,var(--h3pa-accent) 35%,transparent)}
+        .h3pa-carousel.h3pa-drop-active::before{content:"Drop to create assets";position:sticky;left:10px;align-self:flex-start;z-index:20;
+          flex:0 0 auto;margin:7px 0 0 -1px;padding:6px 9px;border:1px dashed var(--h3pa-accent);border-radius:6px;
+          background:var(--h3pa-panel);color:var(--h3pa-text);font-size:12px;font-weight:700;pointer-events:none}
+        .h3pa-carousel-empty{flex:1 0 100%;display:grid;place-items:center;min-height:112px;color:var(--h3pa-muted);text-align:center}
+        .h3pa-card{position:relative;flex:0 0 150px;height:112px;padding:0;border:1px solid var(--h3pa-border);border-radius:8px;
+          overflow:hidden;background:var(--h3pa-panel);color:var(--h3pa-text);text-align:left;cursor:pointer}.h3pa-card.selected{border:2px solid var(--h3pa-accent)}
+        .h3pa-card[draggable="true"]{cursor:grab}.h3pa-card.dragging{opacity:.42;cursor:grabbing}
+        .h3pa-card.drag-over{border-color:var(--h3pa-success);box-shadow:0 0 0 2px color-mix(in srgb,var(--h3pa-success) 40%,transparent)}
+        .h3pa-folder-group{flex:0 0 auto;display:flex;gap:8px;align-items:stretch;padding:0;border-radius:10px}
+        .h3pa-folder-group.expanded{padding:4px;background:var(--h3pa-selected);box-shadow:inset 0 0 0 1px var(--h3pa-border)}
+        .h3pa-folder-card{position:relative;flex:0 0 112px;height:112px;padding:7px;border:1px solid var(--h3pa-border);border-radius:10px;
+          overflow:hidden;background:var(--h3pa-panel);color:var(--h3pa-text);text-align:left;cursor:pointer}
+        .h3pa-folder-card:hover,.h3pa-folder-card.selected{border-color:var(--h3pa-accent)}.h3pa-folder-card.expanded{background:var(--h3pa-selected);border-color:var(--h3pa-accent)}
+        .h3pa-folder-card.drag-over{border-color:var(--h3pa-success);box-shadow:0 0 0 2px color-mix(in srgb,var(--h3pa-success) 40%,transparent)}
+        .h3pa-folder-mosaic{display:grid;grid-template-columns:1fr 1fr;grid-template-rows:1fr 1fr;gap:3px;height:70px;padding:3px;
+          overflow:hidden;border-radius:7px;background:var(--h3pa-bg)}
+        .h3pa-folder-tile{display:grid;place-items:center;min-width:0;min-height:0;overflow:hidden;border-radius:4px;background:var(--h3pa-soft);color:var(--h3pa-accent);font-size:15px}
+        .h3pa-folder-tile img{display:block;width:100%;height:100%;object-fit:cover}.h3pa-folder-name{display:block;margin-top:5px;padding-right:22px;
+          white-space:nowrap;overflow:hidden;text-overflow:ellipsis;font-weight:650}.h3pa-folder-count{position:absolute;right:7px;bottom:7px;color:var(--h3pa-muted);font-size:10px}
+        .h3pa-folder-member{border-color:var(--h3pa-accent)}
+        .h3pa-card.unresolved{border-style:dashed;background:var(--h3pa-panel)}.h3pa-card.unresolved.stale{opacity:.58}
+        .h3pa-card.unresolved .fallback{color:var(--h3pa-warning)}.h3pa-unassigned{color:var(--h3pa-warning);font-weight:650}
+        .h3pa-card img{width:100%;height:78px;object-fit:cover;background:#090b10}.h3pa-card .fallback{height:78px;display:grid;
+          place-items:center;font-size:24px;color:var(--h3pa-accent)}.h3pa-card span{display:block;padding:4px 6px;white-space:nowrap;overflow:hidden;text-overflow:ellipsis}
+        .h3pa-badge{position:absolute;top:5px;left:5px;padding:2px 5px!important;border-radius:4px;background:#111c;color:#fff;font-size:10px}
+        .h3pa-drag-handle{position:absolute;top:4px;right:4px;width:24px;padding:2px 4px!important;border-radius:4px;
+          background:#111c;color:#dce8ff;text-align:center;font-size:14px;line-height:16px}
+        .h3pa-editor-actions{display:flex;flex-direction:column;gap:6px;margin-top:auto;padding-top:8px;
+          border-top:1px solid color-mix(in srgb,var(--h3pa-border) 55%,transparent)}
+        .h3pa-editor-actions .h3pa-button{height:30px;padding:3px 7px;min-width:0;white-space:nowrap}
+        .h3pa-action-label{color:var(--h3pa-muted);font-size:11px}.h3pa-action-primary{display:grid;grid-template-columns:repeat(2,minmax(0,1fr));gap:6px}
+        .h3pa-action-primary>.h3pa-button:only-child{grid-column:1/-1}
+        .h3pa-action-manage{display:grid;grid-template-columns:34px 34px minmax(0,1fr);gap:6px}
+        .h3pa-editor-actions .h3pa-button:disabled{opacity:.35;cursor:default}
+        .h3pa-button.danger{border-color:var(--h3pa-danger);color:var(--h3pa-danger)}.h3pa-button.danger:hover{border-color:var(--h3pa-danger)}
+        .h3pa-modal{position:fixed;z-index:100000;left:50%;top:50%;transform:translate(-50%,-50%);
+          width:min(760px,calc(100vw - 32px));height:min(520px,calc(100vh - 48px));
+          display:flex;flex-direction:column;gap:8px;padding:14px;
+          border:1px solid var(--h3pa-border);border-radius:10px;background:var(--h3pa-bg);color:var(--h3pa-text);box-shadow:0 20px 70px #000b}
+        .h3pa-source-list{overflow:auto;display:flex;flex-direction:column;gap:5px}.h3pa-source-item{display:grid;
+          grid-template-columns:1fr auto auto;gap:8px;align-items:center;padding:7px;border:1px solid var(--h3pa-border);border-radius:6px}
+        .h3pa-crop-modal{width:min(1180px,calc(100vw - 28px));height:min(780px,calc(100vh - 32px))}
+        .h3pa-crop-layout{display:grid;grid-template-columns:minmax(0,1fr) 290px;gap:12px;min-height:0;flex:1}
+        .h3pa-crop-canvas-wrap{min-width:0;min-height:0;display:grid;place-items:center;overflow:hidden;border:1px solid var(--h3pa-border);border-radius:8px;background:#080a0f}
+        @media (max-width:900px){.h3pa-preview.h3pa-audio-preview{grid-template-columns:1fr;grid-template-rows:auto minmax(180px,1fr)}}
+        .h3pa-crop-canvas{display:block;width:100%;height:100%;touch-action:none;cursor:crosshair;outline:none;user-select:none}
+        .h3pa-crop-controls{display:flex;flex-direction:column;gap:9px;min-height:0;overflow:auto;padding:10px;border:1px solid var(--h3pa-border);border-radius:8px;background:var(--h3pa-panel)}
+        .h3pa-crop-controls label{display:flex;flex-direction:column;gap:3px;color:var(--h3pa-muted)}.h3pa-crop-grid{display:grid;grid-template-columns:1fr 1fr;gap:7px}
+        .h3pa-crop-controls input,.h3pa-crop-controls select{width:100%;min-width:0;padding:6px 7px;border:1px solid var(--h3pa-border);border-radius:6px;background:var(--h3pa-panel);color:var(--h3pa-text)}
+        .h3pa-mp-presets{display:grid;grid-template-columns:repeat(6,minmax(0,1fr));gap:4px}.h3pa-mp-presets .h3pa-button{min-width:0;padding:4px 2px;font-size:10px;white-space:nowrap}
+        .h3pa-snap-options{display:grid;grid-template-columns:repeat(5,minmax(0,1fr));gap:4px;align-items:center}.h3pa-snap-options .h3pa-button{min-width:0;padding:4px 3px;white-space:nowrap}
+        .h3pa-snap-options .h3pa-button.active{background:var(--h3pa-selected);border-color:var(--h3pa-accent)}.h3pa-snap-label{grid-column:1/-1;color:var(--h3pa-muted);font-size:11px}
+        .h3pa-size-summary{padding:8px;border:1px solid var(--h3pa-border);border-radius:7px;background:var(--h3pa-soft);color:var(--h3pa-muted);line-height:1.4}
+        .h3pa-crop-actions{display:flex;flex-wrap:wrap;gap:6px;margin-top:auto}.h3pa-crop-note{color:var(--h3pa-muted);font-size:11px}
+        @media(max-width:850px){.h3pa-crop-layout{grid-template-columns:1fr}.h3pa-crop-controls{max-height:320px}}
+        @media(max-width:800px){.h3pa-stage{grid-template-columns:1fr}.h3pa-editor{max-height:190px}}
+    `;
+    document.head.appendChild(style);
+}
+
+function collapseWidget(item) {
+    if (!item || item._h3paCollapsed) return;
+    item._h3paOriginalPresentation = {
+        type: item.type,
+        hidden: item.hidden,
+        computeSize: item.computeSize,
+        draw: item.draw,
+    };
+    item._h3paCollapsed = true;
+    item.hidden = true;
+    item.computeSize = () => [0, -4];
+    item.type = "hidden";
+    item.draw = () => {};
+}
+
+function restoreWidget(item) {
+    if (!item?._h3paCollapsed) return;
+    const original = item._h3paOriginalPresentation ?? {};
+    item.type = original.type;
+    item.hidden = original.hidden;
+    item.computeSize = original.computeSize;
+    item.draw = original.draw;
+    item._h3paCollapsed = false;
+}
+
+function refreshSemanticSettingVisibility(node) {
+    const visible = node?.properties?.h3_show_semantic_anchor_settings !== false;
+    for (const name of SEMANTIC_SETTING_WIDGETS) {
+        const item = widget(node, name);
+        if (visible) restoreWidget(item);
+        else collapseWidget(item);
+    }
+    node?.graph?.setDirtyCanvas?.(true, true);
+}
+
+function syncDownstreamPlan(node, runName) {
+    for (const output of node.outputs ?? []) {
+        for (const linkId of output.links ?? []) {
+            const link = node.graph?.links?.[linkId];
+            const target = link ? node.graph?.getNodeById?.(link.target_id) : null;
+            if (!target || !PLAN_TYPES.has(nodeType(target))) continue;
+            const run = widget(target, "run_name");
+            if (run && run.value !== runName) {
+                run.value = runName;
+                run.callback?.(runName);
+            }
+        }
+    }
+}
+
+function downstreamPlanRunName(node) {
+    for (const output of node.outputs ?? []) {
+        for (const linkId of output.links ?? []) {
+            const link = node.graph?.links?.[linkId];
+            const target = link ? node.graph?.getNodeById?.(link.target_id) : null;
+            if (!target || !PLAN_TYPES.has(nodeType(target))) continue;
+            const value = String(widget(target, "run_name")?.value ?? "").trim();
+            if (value) return value;
+        }
+    }
+    return "";
+}
+
+function mount(node) {
+    if (node._h3ProjectAssetMounted) return;
+    node._h3ProjectAssetMounted = true;
+    injectStyles();
+    const runNameWidget = widget(node, "run_name");
+    const catalogWidget = widget(node, "catalog_json");
+    const operationWidget = widget(node, "operation_json");
+    [runNameWidget, catalogWidget, operationWidget].forEach(collapseWidget);
+
+    const root = el("div", "h3pa-root");
+    const top = el("div", "h3pa-row");
+    const runNameInput = el("input", "h3pa-project");
+    runNameInput.placeholder = "Run name";
+    runNameInput.title = "Type a new Run name, then press Enter or leave the field to load it. Spaces are converted to underscores when the name is committed, or choose an existing Asset Carousel project to switch this Carousel and its connected Plan.";
+    runNameInput.setAttribute("aria-label", "Run name");
+    runNameInput.autocomplete = "off";
+    const projectPicker = el("div", "h3pa-project-picker");
+    const projectMenu = el("select", "h3pa-project-menu");
+    projectMenu.title = "Switch to an existing Asset Carousel project";
+    projectMenu.setAttribute("aria-label", "Switch Asset Carousel project");
+    const projectMenuPlaceholder = el("option", "", "▾");
+    projectMenuPlaceholder.value = "";
+    projectMenu.append(projectMenuPlaceholder);
+    projectPicker.append(runNameInput, projectMenu);
+    const savedRunName = serializedProjectAssetIdentity(
+        runNameWidget?.value, catalogWidget?.value,
+    );
+    const connectedRunName = downstreamPlanRunName(node);
+    runNameInput.value = savedRunName || connectedRunName;
+    if (runNameWidget && runNameWidget.value !== runNameInput.value) {
+        runNameWidget.value = runNameInput.value;
+        runNameWidget.callback?.(runNameInput.value);
+    }
+    const sourceSelect = el("select");
+    for (const [value, label] of [
+        ["input", "ComfyUI input"], ["project", "Other Run"],
+        ["chains", "H3 backups"],
+    ]) {
+        const option = el("option", "", label); option.value = value;
+        sourceSelect.append(option);
+    }
+    sourceSelect.title = "Choose where Import browses for media to copy into this Run. Other Run reads the live Asset Carousel; H3 backups reads recovery snapshots.";
+    const previewSelect = el("select");
+    for (const [value, label] of [
+        ["light", "Light previews"],
+        ["full", "Full previews"],
+    ]) {
+        const option = el("option", "", label); option.value = value;
+        previewSelect.append(option);
+    }
+    previewSelect.value = String(
+        node.properties?.h3_project_asset_preview_mode ?? "light");
+    previewSelect.title = "Display quality for this Carousel only. Generation always uses the original stored asset. Light uses cached thumbnails and bounded JPEG previews; Full loads the selected original into the Carousel UI.";
+    previewSelect.setAttribute("aria-label", "Carousel display preview quality; generation always uses original assets");
+    top.append(el("span", "", "Run name"), projectPicker, sourceSelect, previewSelect);
+    const fileInput = el("input");
+    fileInput.type = "file"; fileInput.accept = "image/*,video/*,audio/*";
+    fileInput.hidden = true;
+    top.append(
+        button("Upload", () => {
+            state.bindingSlot = selectedUnassignedSlot();
+            fileInput.click();
+        }, "Choose a local media file, or drop files directly onto the Carousel. A selected Unassigned slot is bound; otherwise a new asset is created."),
+        button("Import", () => browseSource(selectedUnassignedSlot()),
+            "Create a project asset from the selected source: ComfyUI input, another Run, or an H3 backup. A selected Unassigned slot is bound instead."),
+        button("Duplicate project…", () => duplicateAssetProject(),
+            "Create a new Run containing this asset catalog, folders, lyrics, and project-owned media. Generated clips, checkpoints, and assembled renders are not copied. This Carousel stays on the current Run."),
+        button("Refresh", () => refresh()), fileInput,
+    );
+    const status = el("div", "h3pa-status", "Loading project assets…");
+    const tabs = el("div", "h3pa-tabs");
+    const stage = el("div", "h3pa-stage");
+    const preview = el("div", "h3pa-preview");
+    const editor = el("div", "h3pa-editor");
+    stage.append(preview, editor);
+    const carousel = el("div", "h3pa-carousel");
+    carousel.title = "Drop one or more image, video, or audio files here to create project assets immediately.";
+    root.append(top, status, tabs, stage, carousel);
+    const dom = node.addDOMWidget("project_asset_carousel", "div", root, {
+        serialize: false, hideOnZoom: false, getMinHeight: () => 560,
+    });
+    dom.serialize = false;
+    node.setSize?.([Math.max(node.size?.[0] ?? 680, 760), Math.max(node.size?.[1] ?? 650, 700)]);
+
+    const savedCatalog = serializedProjectAssetCatalog(
+        catalogWidget?.value, runNameInput.value,
+    );
+    const state = {
+        catalog:savedCatalog ?? {assets: [], reference_slots: [], folders: []}, selected: "",
+        filter: "all", folder: "", media: null, bindingSlot: null,
+        dragging: "", uploading: false, duplicatingProject: false,
+        projects: [], projectNames: new Set(),
+        expandedFolders: new Set(Array.isArray(
+            node.properties?.h3_project_asset_expanded_folders,
+        ) ? node.properties.h3_project_asset_expanded_folders.map(String) : []),
+        previewMode: previewSelect.value === "full" ? "full" : "light",
+    };
+    const project = () => String(runNameInput.value || "").trim();
+    // Tokens distinguish A -> B -> A from an uninterrupted operation on A.
+    let projectEpoch = 0;
+    let projectDisposed = false;
+    function captureProjectOperation() {
+        return {run:project(), epoch:projectEpoch};
+    }
+    function isCurrentProjectOperation(operation) {
+        return !projectDisposed && operation.epoch === projectEpoch
+            && operation.run === project();
+    }
+    function requireCurrentProjectOperation(operation) {
+        if (isCurrentProjectOperation(operation)) return;
+        const error = new Error("The Run changed; the old asset operation will not update this Carousel.");
+        error.staleProject = true;
+        throw error;
+    }
+    async function mutationRequest(route, options = {}, operation = captureProjectOperation()) {
+        requireCurrentProjectOperation(operation);
+        if (state.catalog?.project && state.catalog.project !== operation.run) {
+            throw new Error("Wait for the selected Run's assets to finish loading.");
+        }
+        let result;
+        try {
+            result = await jsonRequest(route, options);
+        } catch (error) {
+            requireCurrentProjectOperation(operation);
+            throw error;
+        }
+        requireCurrentProjectOperation(operation);
+        return result;
+    }
+    let refreshSequence = 0;
+    const graphSyncTimers = new Set();
+    function setStatus(text, error = false) {
+        status.textContent = text;
+        status.style.color = error ? "var(--h3pa-danger)" : "";
+    }
+    function stopMedia() {
+        if (state.media?.pause) state.media.pause();
+        state.media = null;
+        preview.classList.remove("h3pa-audio-preview");
+        preview.replaceChildren();
+    }
+    async function refreshProjectSuggestions() {
+        try {
+            const payload = await jsonRequest(
+                "/minimax_h3_context_loop/project-assets/projects");
+            const projects = Array.isArray(payload.items) ? payload.items : [];
+            state.projects = projects;
+            state.projectNames = new Set(projects.map(
+                (item) => String(item.project ?? ""),
+            ).filter(Boolean));
+            projectMenu.replaceChildren(projectMenuPlaceholder);
+            for (const item of projects) {
+                const option = el("option");
+                option.value = String(item.project ?? "");
+                option.textContent = (
+                    `${String(item.project ?? "")} — ` +
+                    `${Number(item.asset_count ?? 0)} asset${Number(item.asset_count ?? 0) === 1 ? "" : "s"}` +
+                    ` · ${Number(item.unassigned_count ?? 0)} unassigned`
+                );
+                projectMenu.append(option);
+            }
+        } catch {
+            state.projects = [];
+            state.projectNames = new Set();
+            projectMenu.replaceChildren(projectMenuPlaceholder);
+        }
+    }
+    function persistCatalog(catalog) {
+        if (projectDisposed || (catalog?.project && catalog.project !== project())) return false;
+        state.catalog = catalog ?? {assets: [], reference_slots: [], folders: []};
+        state.catalog.folders ??= [];
+        const canonicalProject = String(state.catalog.project || project());
+        runNameInput.value = canonicalProject;
+        if (catalogWidget) {
+            catalogWidget.value = JSON.stringify(state.catalog);
+            catalogWidget.callback?.(catalogWidget.value);
+        }
+        runNameWidget.value = canonicalProject;
+        runNameWidget.callback?.(canonicalProject);
+        syncDownstreamPlan(node, canonicalProject);
+        publishProjectAssetCatalogChanged(node, state.catalog);
+        node.graph?.setDirtyCanvas?.(true, true);
+    }
+    function allItems() {
+        return [
+            ...(state.catalog.assets ?? []),
+            ...(state.catalog.reference_slots ?? []).map((slot) => ({
+                ...slot, _unresolved: true,
+            })),
+        ];
+    }
+    function selectedUnassignedSlot() {
+        return allItems().find((asset) => (
+            asset.id === state.selected && asset._unresolved
+        )) ?? null;
+    }
+    function saveExpandedFolders() {
+        node.properties ??= {};
+        node.properties.h3_project_asset_expanded_folders = [
+            ...state.expandedFolders,
+        ];
+        node.graph?.setDirtyCanvas?.(true, true);
+    }
+    function setFolderExpanded(folderId, expanded) {
+        const id = String(folderId ?? "");
+        if (!id) return;
+        if (expanded) state.expandedFolders.add(id);
+        else state.expandedFolders.delete(id);
+        saveExpandedFolders();
+    }
+    function filteredAssets() {
+        return allItems().filter((asset) => matchesTab(asset, state.filter));
+    }
+    function renderTabs() {
+        tabs.replaceChildren();
+        for (const [key, label] of [["all", "All"], ["image", "Images"],
+            ["semantic", "Semantic"], ["video", "Video"],
+            ["audio", "Audio"], ["unassigned", "Unassigned"],
+            ["source_track", "Source track"]]) {
+            const count = allItems().filter((asset) => matchesTab(asset, key)).length;
+            const item = button(`${label} ${count}`, () => {
+                state.filter = key; render();
+            });
+            item.classList.add("h3pa-tab");
+            item.classList.toggle("active", state.filter === key);
+            tabs.append(item);
+        }
+    }
+    async function folderRequest(body, success) {
+        try {
+            setStatus("Saving asset folders…");
+            const result = await mutationRequest(
+                "/minimax_h3_context_loop/project-assets/folder", {
+                    method: "POST", headers: {"Content-Type": "application/json"},
+                    body: JSON.stringify({project: project(), ...body}),
+                });
+            persistCatalog(result.catalog); render(); setStatus(success);
+            return result;
+        } catch (error) { if (!error.staleProject) setStatus(error.message, true); return null; }
+    }
+    function renderFolders() {
+        const assetList = state.catalog.assets ?? [];
+        const folderList = state.catalog.folders ?? [];
+        const tools = el("div", "h3pa-folder-tools");
+        const addFolder = button("+ Folder", async () => {
+            const name = window.prompt("New asset folder name");
+            if (!name?.trim()) return;
+            const result = await folderRequest(
+                {action: "create", name}, `Created folder ${name.trim()}.`,
+            );
+            if (result?.folder?.id) {
+                state.folder = result.folder.id;
+                setFolderExpanded(result.folder.id, true);
+                render();
+            }
+        }, "Create a presentation-only folder. Folders never affect prompts, fingerprints, or generation.");
+        tools.append(addFolder);
+        if (!folderList.length) {
+            state.folder = "";
+            tabs.append(tools);
+            return;
+        }
+        const folderSelect = el("select");
+        folderSelect.title = "Choose a folder to rename or remove. Folder cards in the Carousel expand and collapse their assets.";
+        const placeholder = el("option", "", "Manage folders…");
+        placeholder.value = ""; folderSelect.append(placeholder);
+        for (const folder of folderList.map((folder) => ({
+            ...folder,
+            count: assetList.filter((asset) => asset.folder_id === folder.id).length,
+        }))) {
+            const option = el("option", "", `${folder.name} (${folder.count})`);
+            option.value = folder.id;
+            folderSelect.append(option);
+        }
+        folderSelect.value = state.folder;
+        folderSelect.addEventListener("change", () => {
+            state.folder = folderSelect.value;
+            if (state.folder) setFolderExpanded(state.folder, true);
+            render();
+        });
+        tools.append(folderSelect);
+        const active = folderList.find(
+            (folder) => folder.id === state.folder,
+        );
+        if (active) {
+            tools.append(
+                button("Rename", async () => {
+                    const name = window.prompt("Rename asset folder", active.name);
+                    if (!name?.trim() || name.trim() === active.name) return;
+                    await folderRequest({
+                        action: "update", folder_id: active.id,
+                        changes: {name: name.trim()},
+                    }, `Renamed folder to ${name.trim()}.`);
+                }),
+                button("Remove folder", async () => {
+                    if (!window.confirm(
+                        `Remove folder ${active.name}? Its assets will move to No folder; no media is deleted.`,
+                    )) return;
+                    const result = await folderRequest({
+                        action: "delete", folder_id: active.id,
+                    }, `Removed folder ${active.name}.`);
+                    if (result) {
+                        state.expandedFolders.delete(active.id);
+                        saveExpandedFolders();
+                        state.folder = "";
+                        render();
+                    }
+                }),
+            );
+        }
+        tabs.append(tools);
+    }
+    function renderPreview(asset) {
+        const operation = captureProjectOperation();
+        stopMedia();
+        if (!asset) {
+            preview.append(el("div", "h3pa-empty", "Upload or import a project asset."));
+            return;
+        }
+        if (asset._unresolved) {
+            preview.append(el(
+                "div", "h3pa-empty",
+                asset.available === false
+                    ? `${promptTag(asset)} is no longer present on the connected reference line.`
+                    : `${promptTag(asset)} is unassigned. Choose its ${asset.kind} from ComfyUI input or upload it.`,
+            ));
+            return;
+        }
+        if (asset.kind === "image") {
+            const image = el("img");
+            image.alt = asset.tag;
+            image.src = mediaUrl(
+                project(), asset,
+                state.previewMode === "full" ? "original" : "poster",
+            );
+            preview.append(image); state.media = image;
+        } else if (asset.kind === "video") {
+            const video = el("video");
+            video.controls = true; video.preload = "metadata";
+            video.poster = mediaUrl(project(), asset, "poster");
+            video.src = mediaUrl(project(), asset, "preview");
+            preview.append(video); state.media = video;
+        } else {
+            preview.classList.add("h3pa-audio-preview");
+            const player = el("section", "h3pa-audio-player");
+            player.append(el("strong", "", asset.original_name || promptTag(asset)));
+            const audio = el("audio");
+            audio.controls = true; audio.preload = "metadata";
+            audio.src = mediaUrl(project(), asset, "original");
+            player.append(audio);
+            const lyricsPanel = el("section", "h3pa-lyrics");
+            const lyricsHead = el("div", "h3pa-lyrics-head");
+            lyricsHead.append(
+                el("strong", "", "Lyrics"),
+                el("small", "", "Saved with the project · generation unchanged"),
+            );
+            const lyrics = el("textarea");
+            lyrics.value = String(asset.lyrics ?? "");
+            lyrics.placeholder = "Paste lyrics, then stamp each line while the song plays…";
+            lyrics.title = "Lyrics are project notes stored with this audio asset. Add [MM:SS.xx] timestamps or paste SRT to show them in sync in Plan Studio. They do not enter prompts, generation, or the reference fingerprint. Changes save when you leave the field; Ctrl/Cmd+Enter saves immediately.";
+            lyrics.setAttribute("aria-label", `Lyrics for ${asset.original_name || promptTag(asset)}`);
+            let savedLyrics = lyrics.value;
+            lyrics.addEventListener("change", async () => {
+                const nextLyrics = lyrics.value.replaceAll("\r\n", "\n").replaceAll("\r", "\n");
+                if (nextLyrics === savedLyrics) return;
+                const result = await updateAsset(
+                    asset, {lyrics: nextLyrics}, {
+                        operation, renderAfter: false,
+                        success: `Saved lyrics for ${promptTag(asset)}.`,
+                    },
+                );
+                if (!result) return;
+                savedLyrics = String(result.asset?.lyrics ?? "");
+                lyrics.value = savedLyrics;
+            });
+            lyrics.addEventListener("keydown", (event) => {
+                if (event.key !== "Enter" || (!event.ctrlKey && !event.metaKey)) return;
+                event.preventDefault(); lyrics.blur();
+            });
+            const lyricsActions = el("div", "h3pa-lyrics-actions");
+            const currentTime = el(
+                "span", "h3pa-lyrics-time", formatLyricsTimestamp(0),
+            );
+            audio.addEventListener("timeupdate", () => {
+                currentTime.textContent = formatLyricsTimestamp(audio.currentTime);
+            });
+            const stamp = button(
+                "Stamp selected line",
+                () => {
+                    const caret = lyrics.selectionStart ?? 0;
+                    const start = lyrics.value.lastIndexOf("\n", Math.max(0, caret - 1)) + 1;
+                    const nextBreak = lyrics.value.indexOf("\n", caret);
+                    const end = nextBreak < 0 ? lyrics.value.length : nextBreak;
+                    const line = lyrics.value.slice(start, end)
+                        .replace(/^(?:\[\d{1,3}:\d{2}(?:[.:]\d{1,3})?\])+\s*/, "");
+                    const stamped = `${formatLyricsTimestamp(audio.currentTime)}${line}`;
+                    lyrics.setRangeText(stamped, start, end, "end");
+                    const nextStart = Math.min(
+                        lyrics.value.length,
+                        start + stamped.length + (nextBreak < 0 ? 0 : 1),
+                    );
+                    const followingBreak = lyrics.value.indexOf("\n", nextStart);
+                    lyrics.setSelectionRange(
+                        nextStart,
+                        followingBreak < 0 ? lyrics.value.length : followingBreak,
+                    );
+                    lyrics.focus();
+                },
+                "Insert the player's current [MM:SS.xx] time at the beginning of the selected lyric line, then select the next line.",
+            );
+            lyricsActions.append(stamp, currentTime);
+            lyricsPanel.append(lyricsHead, lyricsActions, lyrics);
+            preview.append(player, lyricsPanel); state.media = audio;
+        }
+    }
+    async function updateAsset(asset, changes, options = {}) {
+        const operation = options.operation ?? captureProjectOperation();
+        try {
+            requireCurrentProjectOperation(operation);
+            setStatus(`Updating ${promptTag(asset)}…`);
+            const result = await mutationRequest(
+                "/minimax_h3_context_loop/project-assets/update", {
+                    method: "POST", headers: {"Content-Type": "application/json"},
+                    body: JSON.stringify({project: operation.run, asset_id: asset.id, changes}),
+                }, operation);
+            persistCatalog(result.catalog);
+            if (options.renderAfter !== false) render();
+            setStatus(options.success || `Updated ${promptTag(result.asset)}.`);
+            return result;
+        } catch (error) { if (!error.staleProject) setStatus(error.message, true); return null; }
+    }
+    async function reorderAssets(assetIds) {
+        try {
+            setStatus("Saving asset order…");
+            const result = await mutationRequest(
+                "/minimax_h3_context_loop/project-assets/reorder", {
+                    method: "POST", headers: {"Content-Type": "application/json"},
+                    body: JSON.stringify({project: project(), asset_ids: assetIds}),
+                });
+            persistCatalog(result.catalog); render();
+            setStatus("Asset order saved.");
+        } catch (error) { if (!error.staleProject) setStatus(error.message, true); }
+    }
+    function moveAsset(asset, offset) {
+        const assetIds = (state.catalog.assets ?? []).map((item) => item.id);
+        const index = assetIds.indexOf(asset.id);
+        const target = Math.max(0, Math.min(assetIds.length - 1, index + offset));
+        if (index < 0 || index === target) return;
+        assetIds.splice(index, 1);
+        assetIds.splice(target, 0, asset.id);
+        void reorderAssets(assetIds);
+    }
+    async function deleteAsset(asset) {
+        const confirmed = window.confirm(
+            `Delete ${promptTag(asset)} from this project?\n\n` +
+            "This removes the Carousel-owned input copy and its H3 backup. " +
+            "The original file you imported is not touched.",
+        );
+        if (!confirmed) return;
+        const previous = state.catalog.assets ?? [];
+        const previousIndex = previous.findIndex((item) => item.id === asset.id);
+        try {
+            setStatus(`Deleting ${promptTag(asset)}…`);
+            const result = await mutationRequest(
+                "/minimax_h3_context_loop/project-assets/delete", {
+                    method: "POST", headers: {"Content-Type": "application/json"},
+                    body: JSON.stringify({project: project(), asset_id: asset.id}),
+                });
+            persistCatalog(result.catalog);
+            const remaining = result.catalog.assets ?? [];
+            state.selected = remaining[
+                Math.min(Math.max(previousIndex, 0), remaining.length - 1)
+            ]?.id ?? "";
+            render();
+            setStatus(`Deleted ${promptTag(result.asset)}.`);
+        } catch (error) { if (!error.staleProject) setStatus(error.message, true); }
+    }
+    async function duplicateAsset(asset) {
+        try {
+            setStatus(`Duplicating ${promptTag(asset)}…`);
+            const result = await mutationRequest(
+                "/minimax_h3_context_loop/project-assets/duplicate", {
+                    method: "POST", headers: {"Content-Type": "application/json"},
+                    body: JSON.stringify({project: project(), asset_id: asset.id}),
+                });
+            persistCatalog(result.catalog); state.selected = result.asset.id; render();
+            setStatus(`Duplicated ${promptTag(asset)} as ${promptTag(result.asset)} without copying media bytes.`);
+        } catch (error) { if (!error.staleProject) setStatus(error.message, true); }
+    }
+    async function duplicateAssetProject() {
+        const sourceProject = project();
+        if (!sourceProject) {
+            setStatus("Enter a Run name before duplicating its asset project.", true);
+            return;
+        }
+        if (state.duplicatingProject) {
+            setStatus("This asset project is already being duplicated.");
+            return;
+        }
+        const requested = window.prompt(
+            `New Run name for a copy of ${sourceProject}\n\n` +
+            "Only Carousel assets, folders, lyrics, and their recovery mirror are copied. Generated clips, checkpoints, and rendered outputs are not copied.",
+            `${sourceProject}_copy`,
+        );
+        if (requested === null) return;
+        const newProject = String(requested).trim();
+        if (!newProject) {
+            setStatus("The duplicated asset project needs a new Run name.", true);
+            return;
+        }
+        state.duplicatingProject = true;
+        try {
+            setStatus(`Duplicating ${sourceProject} assets into ${newProject}…`);
+            const result = await mutationRequest(
+                "/minimax_h3_context_loop/project-assets/duplicate-project", {
+                    method: "POST", headers: {"Content-Type": "application/json"},
+                    body: JSON.stringify({
+                        project: sourceProject, new_project: newProject,
+                    }),
+                });
+            setStatus(
+                `Created ${result.target_project} with ${result.asset_count} asset${result.asset_count === 1 ? "" : "s"} ` +
+                `and ${result.media_file_count} copied media file${result.media_file_count === 1 ? "" : "s"}. ` +
+                "No generated clips, checkpoints, or renders were copied; the current Run remains selected.",
+            );
+            await refreshProjectSuggestions();
+        } catch (error) {
+            if (!error.staleProject) setStatus(error.message, true);
+        } finally {
+            state.duplicatingProject = false;
+        }
+    }
+    function openImageEditor(asset) {
+        const operation = captureProjectOperation();
+        const modal = el("div", "h3pa-modal h3pa-crop-modal");
+        const heading = el("div", "h3pa-row");
+        heading.append(
+            el("strong", "h3pa-project", `Edit / upscale image variant · ${promptTag(asset)}`),
+            button("Close", () => modal.remove()),
+        );
+        const layout = el("div", "h3pa-crop-layout");
+        const canvasWrap = el("div", "h3pa-crop-canvas-wrap");
+        const canvas = el("canvas", "h3pa-crop-canvas"); canvas.tabIndex = 0;
+        canvas.setAttribute("aria-label", "Crop selector; drag outside the crop to draw, drag inside to move, drag any corner to resize, arrow keys nudge");
+        canvasWrap.append(canvas);
+        const controls = el("div", "h3pa-crop-controls");
+        layout.append(canvasWrap, controls); modal.append(heading, layout); document.body.append(modal);
+
+        const image = new Image(); image.decoding = "async";
+        const crop = {x: 0, y: 0, width: 1, height: 1};
+        let sourceWidth = 1; let sourceHeight = 1;
+        let drawScale = 1; let drawX = 0; let drawY = 0;
+        let drag = null;
+        let lockedRatio = 1;
+        let outputMultiple = 8;
+        const cropInputs = {};
+        function numberField(name, label, value, minimum = 0) {
+            const wrapper = el("label", "", label);
+            const input = el("input"); input.type = "number"; input.step = "1";
+            input.min = String(minimum); input.value = String(value);
+            wrapper.append(input); cropInputs[name] = input; return wrapper;
+        }
+        const cropGrid = el("div", "h3pa-crop-grid");
+        cropGrid.append(
+            numberField("x", "Crop X", 0), numberField("y", "Crop Y", 0),
+            numberField("width", "Crop width", 1, 1),
+            numberField("height", "Crop height", 1, 1),
+        );
+        const targetGrid = el("div", "h3pa-crop-grid");
+        targetGrid.append(
+            numberField("targetWidth", "Output width", 1, 1),
+            numberField("targetHeight", "Output height", 1, 1),
+        );
+        const megapixelLabel = el("label", "", "Target megapixels");
+        megapixelLabel.title = "Set the final asset size by megapixels. This works with the full image or a crop, and with ordinary resampling or the connected upscale model.";
+        const megapixelInput = el("input"); megapixelInput.type = "number";
+        megapixelInput.min = "0.01"; megapixelInput.step = "0.05";
+        megapixelInput.value = "0.01"; megapixelLabel.append(megapixelInput);
+        const megapixelPresets = el("div", "h3pa-mp-presets");
+        for (const value of [0.25, 0.5, 1, 2, 4, 8]) {
+            megapixelPresets.append(button(`${value} MP`, () => {
+                megapixelInput.value = String(value);
+                applyMegapixelTarget();
+            }, `Set the final image near ${value} megapixels while preserving the current output ratio`));
+        }
+        const snapOptions = el("div", "h3pa-snap-options");
+        snapOptions.title = "Snap both final dimensions to a model-friendly multiple. Aspect ratio has priority, so the actual megapixel count may move slightly.";
+        snapOptions.append(el("span", "h3pa-snap-label", "Output multiple"));
+        const snapButtons = new Map();
+        for (const [label, value] of [["Off", 1], ["8", 8], ["16", 16], ["32", 32], ["64", 64]]) {
+            const item = button(label, () => applyOutputMultiple(value),
+                value === 1 ? "Allow any integer output dimensions" : `Keep both output dimensions divisible by ${value}`);
+            item.classList.toggle("active", value === outputMultiple);
+            snapButtons.set(value, item); snapOptions.append(item);
+        }
+        const ratioLabel = el("label", "h3pa-toggle");
+        const ratioLock = el("input"); ratioLock.type = "checkbox"; ratioLock.checked = true;
+        const ratioCopy = el("span", "h3pa-toggle-copy");
+        ratioCopy.append(
+            el("strong", "", "Lock output aspect ratio"),
+            el("small", "", "Changing output width updates height (and vice versa); crop resizing uses the same ratio."),
+        );
+        ratioLabel.append(ratioLock, ratioCopy);
+        const resampleLabel = el("label", "", "Resampling");
+        const resample = el("select");
+        for (const value of ["lanczos", "bicubic", "bilinear", "nearest"]) {
+            const option = el("option", "", value); option.value = value; resample.append(option);
+        }
+        resampleLabel.append(resample);
+        const tagLabel = el("label", "", "Variant prompt tag");
+        const variantTag = el("input"); variantTag.value = `${asset.tag}_variant`;
+        tagLabel.append(variantTag);
+        const sizeStatus = el("div", "h3pa-size-summary", "Loading full source image…");
+        const cropStatus = el("div", "h3pa-crop-note", "");
+        controls.append(
+            el("div", "h3pa-crop-note", "Coordinates are oriented source-image pixels. Drag anywhere to draw a crop; drag inside it to move; drag any corner to resize. Arrow keys nudge by 1 px (Shift: 10 px)."),
+            cropGrid, targetGrid, ratioLabel, megapixelLabel, megapixelPresets,
+            snapOptions, resampleLabel, tagLabel, sizeStatus, cropStatus,
+        );
+        const actions = el("div", "h3pa-crop-actions");
+        const reset = button("Use full image", () => {
+            const targetMegapixels = imageMegapixels(
+                cropInputs.targetWidth.value, cropInputs.targetHeight.value);
+            crop.x = 0; crop.y = 0; crop.width = sourceWidth; crop.height = sourceHeight;
+            if (ratioLock.checked) {
+                lockedRatio = sourceWidth / sourceHeight;
+                setTargetSize(dimensionsForMegapixels(
+                    targetMegapixels, lockedRatio, outputMultiple));
+            }
+            syncInputs(); draw();
+        }, "Remove the crop while keeping the current megapixel target; with ratio lock enabled, the target follows the full image ratio");
+        const resetAll = button("Reset all", () => resetImageEditor(),
+            "Restore the full image, source aspect ratio, model-friendly multiple of 8, source-sized output, Lanczos, and the default variant tag");
+        const startCrop = button("Start centered crop", () => {
+            const ratio = outputRatio();
+            let width = Math.max(1, Math.round(sourceWidth * 0.8));
+            let height = Math.max(1, Math.round(width / ratio));
+            if (height > sourceHeight * 0.8) {
+                height = Math.max(1, Math.round(sourceHeight * 0.8));
+                width = Math.max(1, Math.round(height * ratio));
+            }
+            crop.width = Math.min(sourceWidth, width);
+            crop.height = Math.min(sourceHeight, height);
+            crop.x = Math.round((sourceWidth - crop.width) / 2);
+            crop.y = Math.round((sourceHeight - crop.height) / 2);
+            syncInputs(); draw();
+        }, "Create a visible centered crop using the selected output ratio");
+        const save = button("Save resize / crop", async () => {
+            const payload = operationPayload("resample"); if (!payload) return;
+            try {
+                save.disabled = true; modelButton.disabled = true;
+                cropStatus.textContent = "Creating full-resolution variant…";
+                const result = await mutationRequest(
+                    "/minimax_h3_context_loop/project-assets/derive", {
+                        method: "POST", headers: {"Content-Type": "application/json"},
+                        body: JSON.stringify({...payload, resample: resample.value}),
+                    }, operation);
+                persistCatalog(result.catalog); state.selected = result.asset.id;
+                modal.remove(); render();
+                setStatus(`Created ${promptTag(result.asset)} from the full stored image.`);
+            } catch (error) {
+                cropStatus.textContent = error.message; save.disabled = false;
+                modelButton.disabled = !modelConnected();
+            }
+        }, "Create a new full-quality PNG variant; the source asset remains unchanged");
+        const modelButton = button("Model upscale", async () => {
+            const payload = operationPayload("model"); if (!payload) return;
+            if (!modelConnected()) {
+                cropStatus.textContent = "Connect a core UPSCALE_MODEL to the Carousel first."; return;
+            }
+            try {
+                operationWidget.value = JSON.stringify(payload);
+                operationWidget.callback?.(operationWidget.value);
+                node.graph?.setDirtyCanvas?.(true, true);
+                save.disabled = true; modelButton.disabled = true;
+                cropStatus.textContent = "Queued asset-only model upscale…";
+                await app.queuePrompt(0, 1, [partialExecutionId(node)]);
+                // queuePrompt has already serialized and submitted this one-shot
+                // operation. Clear the workflow state immediately so a failed
+                // model run cannot poison the user's next normal H3 queue.
+                operationWidget.value = ""; operationWidget.callback?.("");
+                modal.remove();
+                setStatus("Asset-only model upscale queued; the H3 chain was not queued.");
+            } catch (error) {
+                operationWidget.value = ""; operationWidget.callback?.("");
+                save.disabled = false; modelButton.disabled = !modelConnected();
+                cropStatus.textContent = error.message;
+            }
+        }, "Run only this Carousel and its connected core upscale model; downstream H3 nodes are excluded");
+        function modelConnected() {
+            return (node.inputs ?? []).some((input) => (
+                input.name === "upscale_model" && input.link != null
+            ));
+        }
+        modelButton.disabled = !modelConnected();
+        actions.append(startCrop, reset, resetAll, save, modelButton); controls.append(actions);
+
+        function operationPayload(mode) {
+            if (!isCurrentProjectOperation(operation)) {
+                cropStatus.textContent = "Run changed. Reopen the editor from the selected Run.";
+                return null;
+            }
+            applyNumericInputs();
+            const targetWidth = Math.round(Number(cropInputs.targetWidth.value));
+            const targetHeight = Math.round(Number(cropInputs.targetHeight.value));
+            if (!targetWidth || !targetHeight) {
+                cropStatus.textContent = "Output width and height must be positive."; return null;
+            }
+            return {
+                project: project(), asset_id: asset.id, mode,
+                operation_id: globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random()}`,
+                crop: {x: crop.x, y: crop.y, width: crop.width, height: crop.height},
+                target: {width: targetWidth, height: targetHeight},
+                tag: variantTag.value, folder_id: asset.folder_id ?? "",
+            };
+        }
+        function currentTargetSize() {
+            return {
+                width: Math.max(1, Math.round(Number(
+                    cropInputs.targetWidth.value) || 1)),
+                height: Math.max(1, Math.round(Number(
+                    cropInputs.targetHeight.value) || 1)),
+            };
+        }
+        function setTargetSize(size) {
+            cropInputs.targetWidth.value = String(Math.max(1, Math.round(size.width)));
+            cropInputs.targetHeight.value = String(Math.max(1, Math.round(size.height)));
+        }
+        function updateSnapButtons() {
+            for (const [value, item] of snapButtons) {
+                item.classList.toggle("active", value === outputMultiple);
+            }
+        }
+        function applyOutputMultiple(value) {
+            const targetMegapixels = imageMegapixels(
+                cropInputs.targetWidth.value, cropInputs.targetHeight.value);
+            outputMultiple = value;
+            updateSnapButtons();
+            setTargetSize(dimensionsForMegapixels(
+                targetMegapixels, outputRatio(), outputMultiple));
+            cropStatus.textContent = "";
+            syncInputs("position"); draw();
+        }
+        function resetImageEditor() {
+            outputMultiple = 8; updateSnapButtons();
+            ratioLock.checked = true;
+            lockedRatio = sourceWidth / sourceHeight;
+            crop.x = 0; crop.y = 0;
+            crop.width = sourceWidth; crop.height = sourceHeight;
+            setTargetSize(dimensionsForMegapixels(
+                imageMegapixels(sourceWidth, sourceHeight),
+                lockedRatio, outputMultiple));
+            resample.value = "lanczos";
+            variantTag.value = `${asset.tag}_variant`;
+            cropStatus.textContent = "";
+            syncInputs(); draw();
+        }
+        function outputRatio() {
+            if (ratioLock.checked) return lockedRatio;
+            const target = currentTargetSize();
+            return target.width / target.height;
+        }
+        function isFullCrop() {
+            return crop.x === 0 && crop.y === 0
+                && crop.width === sourceWidth && crop.height === sourceHeight;
+        }
+        function clampCrop(preference = "size") {
+            if (preference === "position") {
+                crop.width = Math.max(1, Math.min(sourceWidth, Math.round(crop.width)));
+                crop.height = Math.max(1, Math.min(sourceHeight, Math.round(crop.height)));
+                crop.x = Math.max(0, Math.min(sourceWidth - crop.width, Math.round(crop.x)));
+                crop.y = Math.max(0, Math.min(sourceHeight - crop.height, Math.round(crop.y)));
+                return;
+            }
+            // Numeric X/Y are authoritative: when a full-width crop is moved,
+            // shorten it to the remaining source area instead of resetting X/Y.
+            crop.x = Math.max(0, Math.min(sourceWidth - 1, Math.round(crop.x)));
+            crop.y = Math.max(0, Math.min(sourceHeight - 1, Math.round(crop.y)));
+            if (ratioLock.checked) {
+                let width = Math.max(1, Math.round(crop.width));
+                let height = Math.max(1, width / lockedRatio);
+                const fit = Math.min(
+                    1,
+                    (sourceWidth - crop.x) / width,
+                    (sourceHeight - crop.y) / height,
+                );
+                width *= fit; height *= fit;
+                crop.width = Math.max(1, Math.round(width));
+                crop.height = Math.max(1, Math.round(height));
+                return;
+            }
+            crop.width = Math.max(1, Math.min(sourceWidth - crop.x, Math.round(crop.width)));
+            crop.height = Math.max(1, Math.min(sourceHeight - crop.y, Math.round(crop.height)));
+        }
+        function updateSizeSummary() {
+            const target = currentTargetSize();
+            const inputMp = formatMegapixels(imageMegapixels(crop.width, crop.height));
+            const targetMp = formatMegapixels(imageMegapixels(
+                target.width, target.height));
+            megapixelInput.value = targetMp;
+            const inputName = isFullCrop() ? "full image" : "selected crop";
+            const snapText = outputMultiple > 1
+                ? ` Output dimensions are multiples of ${outputMultiple}.`
+                : " Output dimension snapping is off.";
+            if (modelConnected()) {
+                sizeStatus.textContent = `Connected model input (${inputName}): ${crop.width}×${crop.height} (${inputMp} MP). Final saved asset: ${target.width}×${target.height} (${targetMp} MP).${snapText} The model runs at its native scale before the final fit.`;
+                modelButton.title = `Run only this Carousel. The connected model receives ${crop.width}×${crop.height}; its result is fitted to ${target.width}×${target.height}.`;
+            } else {
+                sizeStatus.textContent = `${inputName[0].toUpperCase()}${inputName.slice(1)}: ${crop.width}×${crop.height} (${inputMp} MP) → final saved asset ${target.width}×${target.height} (${targetMp} MP).${snapText} Connect UPSCALE_MODEL to enable model upscale.`;
+                modelButton.title = "Connect a core UPSCALE_MODEL to enable asset-only model upscale.";
+            }
+        }
+        function syncInputs(preference = "size") {
+            clampCrop(preference);
+            for (const key of ["x", "y", "width", "height"]) cropInputs[key].value = String(crop[key]);
+            updateSizeSummary();
+        }
+        function fitCropToLockedRatio() {
+            const centerX = crop.x + crop.width / 2;
+            const centerY = crop.y + crop.height / 2;
+            let width = crop.width;
+            let height = width / lockedRatio;
+            if (height > crop.height) {
+                height = crop.height;
+                width = height * lockedRatio;
+            }
+            crop.width = width; crop.height = height;
+            crop.x = centerX - width / 2; crop.y = centerY - height / 2;
+            clampCrop("position");
+        }
+        function applyNumericInputs(changed = "") {
+            for (const key of ["x", "y", "width", "height"]) {
+                const value = Math.round(Number(cropInputs[key].value));
+                if (Number.isFinite(value)) crop[key] = value;
+            }
+            let target = currentTargetSize();
+            if (["targetWidth", "targetHeight"].includes(changed)) {
+                target = coupledOutputDimensions(
+                    target.width, target.height,
+                    changed === "targetHeight" ? "height" : "width",
+                    lockedRatio, ratioLock.checked, outputMultiple,
+                );
+            }
+            if (ratioLock.checked && ["width", "height"].includes(changed)) {
+                if (changed === "height") crop.width = Math.round(crop.height * lockedRatio);
+                else crop.height = Math.round(crop.width / lockedRatio);
+            }
+            setTargetSize(target);
+            syncInputs(["x", "y", "width", "height"].includes(changed)
+                ? "size" : "position");
+            draw();
+        }
+        for (const [name, input] of Object.entries(cropInputs)) {
+            input.addEventListener("change", () => applyNumericInputs(name));
+        }
+        function applyMegapixelTarget() {
+            const value = Number(megapixelInput.value);
+            if (!Number.isFinite(value) || value <= 0) {
+                cropStatus.textContent = "Target megapixels must be positive.";
+                return;
+            }
+            setTargetSize(dimensionsForMegapixels(
+                value, outputRatio(), outputMultiple));
+            cropStatus.textContent = "";
+            syncInputs("position"); draw();
+        }
+        megapixelInput.addEventListener("change", applyMegapixelTarget);
+        ratioLock.addEventListener("change", () => {
+            if (ratioLock.checked) {
+                const target = currentTargetSize();
+                lockedRatio = target.width / target.height;
+                fitCropToLockedRatio();
+            }
+            syncInputs("position"); draw();
+        });
+        function canvasPoint(event) {
+            const bounds = canvas.getBoundingClientRect();
+            return {
+                x: (event.clientX - bounds.left) * canvas.width / bounds.width,
+                y: (event.clientY - bounds.top) * canvas.height / bounds.height,
+            };
+        }
+        function sourcePoint(point) {
+            return {x: (point.x - drawX) / drawScale, y: (point.y - drawY) / drawScale};
+        }
+        function boundedSourcePoint(point) {
+            return {
+                x: Math.max(0, Math.min(sourceWidth, point.x)),
+                y: Math.max(0, Math.min(sourceHeight, point.y)),
+            };
+        }
+        function cornerPoints() {
+            return {
+                nw: {x: crop.x, y: crop.y},
+                ne: {x: crop.x + crop.width, y: crop.y},
+                se: {x: crop.x + crop.width, y: crop.y + crop.height},
+                sw: {x: crop.x, y: crop.y + crop.height},
+            };
+        }
+        function hitCorner(point) {
+            const threshold = Math.max(14 / drawScale, 7);
+            for (const [name, corner] of Object.entries(cornerPoints())) {
+                if (Math.hypot(point.x - corner.x, point.y - corner.y) <= threshold) return name;
+            }
+            return "";
+        }
+        function oppositeCorner(name) {
+            return ({nw: "se", ne: "sw", se: "nw", sw: "ne"})[name];
+        }
+        function rectangleFromPoints(anchor, moving) {
+            let width = Math.max(1, Math.abs(moving.x - anchor.x));
+            let height = Math.max(1, Math.abs(moving.y - anchor.y));
+            const horizontal = moving.x >= anchor.x ? 1 : -1;
+            const vertical = moving.y >= anchor.y ? 1 : -1;
+            if (ratioLock.checked) {
+                const ratio = outputRatio();
+                if (width / height > ratio) height = width / ratio;
+                else width = height * ratio;
+                const maximumWidth = horizontal > 0 ? sourceWidth - anchor.x : anchor.x;
+                const maximumHeight = vertical > 0 ? sourceHeight - anchor.y : anchor.y;
+                const fit = Math.min(1, maximumWidth / width, maximumHeight / height);
+                width *= fit; height *= fit;
+            }
+            return {
+                x: horizontal > 0 ? anchor.x : anchor.x - width,
+                y: vertical > 0 ? anchor.y : anchor.y - height,
+                width, height,
+            };
+        }
+        function insideCrop(point) {
+            return point.x >= crop.x && point.x <= crop.x + crop.width
+                && point.y >= crop.y && point.y <= crop.y + crop.height;
+        }
+        function updateCanvasCursor(point) {
+            const corner = hitCorner(point);
+            if (corner === "nw" || corner === "se") canvas.style.cursor = "nwse-resize";
+            else if (corner === "ne" || corner === "sw") canvas.style.cursor = "nesw-resize";
+            else if (!isFullCrop() && insideCrop(point)) canvas.style.cursor = "move";
+            else canvas.style.cursor = "crosshair";
+        }
+        function draw() {
+            const bounds = canvasWrap.getBoundingClientRect();
+            const density = Math.min(globalThis.devicePixelRatio || 1, 2);
+            const width = Math.max(320, Math.round(bounds.width * density));
+            const height = Math.max(260, Math.round(bounds.height * density));
+            if (canvas.width !== width || canvas.height !== height) { canvas.width = width; canvas.height = height; }
+            const context = canvas.getContext("2d"); context.clearRect(0, 0, width, height);
+            context.fillStyle = "#080a0f"; context.fillRect(0, 0, width, height);
+            if (!image.complete || !image.naturalWidth) return;
+            drawScale = Math.min((width - 24) / sourceWidth, (height - 24) / sourceHeight);
+            drawX = (width - sourceWidth * drawScale) / 2;
+            drawY = (height - sourceHeight * drawScale) / 2;
+            context.drawImage(image, drawX, drawY, sourceWidth * drawScale, sourceHeight * drawScale);
+            const x = drawX + crop.x * drawScale; const y = drawY + crop.y * drawScale;
+            const w = crop.width * drawScale; const h = crop.height * drawScale;
+            context.save(); context.fillStyle = "#0009"; context.beginPath();
+            context.rect(drawX, drawY, sourceWidth * drawScale, sourceHeight * drawScale);
+            context.rect(x, y, w, h); context.fill("evenodd");
+            context.strokeStyle = "#72a9ff"; context.lineWidth = Math.max(2, density * 1.5);
+            context.strokeRect(x, y, w, h);
+            context.strokeStyle = "#dbe9ff99"; context.lineWidth = Math.max(1, density);
+            for (const fraction of [1 / 3, 2 / 3]) {
+                context.beginPath(); context.moveTo(x + w * fraction, y); context.lineTo(x + w * fraction, y + h); context.stroke();
+                context.beginPath(); context.moveTo(x, y + h * fraction); context.lineTo(x + w, y + h * fraction); context.stroke();
+            }
+            context.fillStyle = "#72a9ff";
+            const handle = 12 * density;
+            for (const corner of [
+                [x, y], [x + w, y], [x + w, y + h], [x, y + h],
+            ]) {
+                context.fillRect(corner[0] - handle / 2, corner[1] - handle / 2, handle, handle);
+            }
+            context.restore();
+        }
+        canvas.addEventListener("pointerdown", (event) => {
+            if (!image.naturalWidth) return;
+            const point = boundedSourcePoint(sourcePoint(canvasPoint(event)));
+            const corner = hitCorner(point);
+            const previous = {...crop};
+            if (corner) {
+                const corners = cornerPoints();
+                drag = {
+                    mode: "resize", anchor: corners[oppositeCorner(corner)],
+                    previous,
+                };
+            } else if (!isFullCrop() && insideCrop(point)) {
+                drag = {mode: "move", point, start: {...crop}, previous};
+            } else {
+                crop.x = point.x; crop.y = point.y; crop.width = 1; crop.height = 1;
+                drag = {mode: "create", anchor: point, previous};
+                syncInputs("position"); draw();
+            }
+            canvas.setPointerCapture(event.pointerId); canvas.focus(); event.preventDefault();
+        });
+        canvas.addEventListener("pointermove", (event) => {
+            const point = boundedSourcePoint(sourcePoint(canvasPoint(event)));
+            if (!drag) { updateCanvasCursor(point); return; }
+            if (drag.mode === "move") {
+                const dx = point.x - drag.point.x;
+                const dy = point.y - drag.point.y;
+                crop.x = drag.start.x + dx; crop.y = drag.start.y + dy;
+            } else {
+                Object.assign(crop, rectangleFromPoints(drag.anchor, point));
+            }
+            clampCrop("position"); syncInputs("position"); draw(); event.preventDefault();
+        });
+        const endDrag = () => {
+            if (drag && drag.mode === "create" && crop.width <= 2 && crop.height <= 2) {
+                Object.assign(crop, drag.previous);
+                syncInputs("position"); draw();
+            }
+            drag = null;
+        };
+        canvas.addEventListener("pointerup", endDrag); canvas.addEventListener("pointercancel", endDrag);
+        canvas.addEventListener("keydown", (event) => {
+            const step = event.shiftKey ? 10 : 1;
+            if (event.key === "ArrowLeft") crop.x -= step;
+            else if (event.key === "ArrowRight") crop.x += step;
+            else if (event.key === "ArrowUp") crop.y -= step;
+            else if (event.key === "ArrowDown") crop.y += step;
+            else return;
+            clampCrop("position"); syncInputs("position"); draw(); event.preventDefault();
+        });
+        image.addEventListener("load", () => {
+            sourceWidth = image.naturalWidth; sourceHeight = image.naturalHeight;
+            resetImageEditor();
+        });
+        image.addEventListener("error", () => { cropStatus.textContent = "Could not load the full stored source image."; });
+        image.src = mediaUrl(project(), asset, "original");
+        const observer = new ResizeObserver(draw); observer.observe(canvasWrap);
+        const removeModal = modal.remove.bind(modal);
+        modal.remove = () => { observer.disconnect(); removeModal(); };
+    }
+    function renderEditor(asset) {
+        editor.replaceChildren();
+        if (!asset) return;
+        if (asset._unresolved) {
+            editor.append(el("strong", "h3pa-unassigned", `${promptTag(asset)} · Unassigned`));
+            editor.append(el(
+                "div", "h3pa-status",
+                `${asset.kind} · ${displayRole(asset.role)}`,
+            ));
+            const pairedTag = String(asset.options?.audio_tag ?? "");
+            if (pairedTag) editor.append(el("div", "h3pa-status", `Paired alias @${pairedTag}`));
+            if (asset.content_hash) editor.append(el(
+                "small", "h3pa-status", `Source fingerprint ${asset.content_hash.slice(0, 16)}`,
+            ));
+            if (asset.available === false) editor.append(el(
+                "div", "h3pa-status",
+                "This tag disappeared from the connected carrier. The placeholder is retained and inactive.",
+            ));
+            editor.append(
+                button("Choose from ComfyUI Input", () => browseSource(asset, "input"),
+                    "Bind an existing ComfyUI input file without importing data from the Tagged Reference carrier"),
+                button("Upload media", () => {
+                    state.bindingSlot = asset;
+                    fileInput.click();
+                }),
+                button("Choose another source", () => browseSource(asset)),
+            );
+            return;
+        }
+        editor.append(el("strong", "", asset.original_name || asset.tag));
+        editor.append(el("div", "h3pa-status", assetDetail(asset)));
+        const isAudio = asset.kind === "audio";
+        const isSourceTrack = asset.role === "source_track";
+        const audioMode = String(asset.options?.timeline_mode ?? "standalone");
+        if (isAudio) {
+            const audioUseLabel = el("label", "", "Audio use");
+            audioUseLabel.title = "Tagged clip sends the complete audio only when @tag is present. Tagged timeline slice follows the current scene position only when @tag is present and requires Chain Policy Source reference=on. Project timeline source selects the project's full audio track. No @tag is required: Chain Policy decides whether scenes use it as generation reference audio and whether it becomes the final soundtrack.";
+            const audioUse = el("select");
+            const currentUse = isSourceTrack
+                ? "source_track"
+                : (audioMode === "source_timeline" ? "tagged_timeline" : "tagged_clip");
+            for (const [value, label] of [
+                ["tagged_clip", "Tagged clip (@tag)"],
+                ["tagged_timeline", "Tagged timeline slice (@tag)"],
+                ["source_track", "Project timeline source"],
+            ]) {
+                const option = el("option", "", label);
+                option.value = value; option.selected = value === currentUse;
+                audioUse.append(option);
+            }
+            audioUse.addEventListener("change", () => {
+                const use = audioUse.value;
+                updateAsset(asset, use === "source_track" ? {
+                    role: "source_track",
+                } : {
+                    role: "audio_reference",
+                    options: {
+                        timeline_mode: use === "tagged_timeline"
+                            ? "source_timeline" : "standalone",
+                        ...(use === "tagged_clip"
+                            ? {align_audio_reference: false} : {}),
+                    },
+                });
+            });
+            audioUseLabel.append(audioUse); editor.append(audioUseLabel);
+        } else {
+            const roleLabel = el("label", "", "Asset use");
+            const role = el("select");
+            for (const value of ROLES[asset.kind] ?? []) {
+                const option = el("option", "", displayRole(value));
+                option.value = value; option.selected = value === asset.role; role.append(option);
+            }
+            role.addEventListener("change", () => updateAsset(asset, {role: role.value}));
+            roleLabel.append(role); editor.append(roleLabel);
+        }
+        if (isAudio && isSourceTrack) {
+            const tracks = el("div", "h3pa-audio-tracks");
+            tracks.append(el("strong", "", "Synchronized audio tracks"));
+            tracks.append(el("small", "h3pa-status",
+                "Keep every stem at the full song length, including silence. "
+                + "The full mix is exported unchanged. Without it, vocals and "
+                + "instrumental are mixed; stems are never layered over a full mix. "
+                + "Use the scene Lip-sync control in Plan Studio."));
+            const bindings = projectAudioTrackBindings(asset);
+            for (const [role, title] of AUDIO_TRACK_ROLES) {
+                const label = el("label", "", title);
+                const select = el("select");
+                const empty = el("option", "", role === "full_mix" ? "Auto mix supplied stems" : "Not supplied");
+                empty.value = ""; select.append(empty);
+                const audioAssets = (state.catalog.assets ?? []).filter((item) => item.kind === "audio" && !item._unresolved);
+                for (const item of audioAssets) {
+                    const option = el("option", "", `${item.id === asset.id ? "This file · " : ""}${item.original_name || item.tag}`);
+                    option.value = item.id; select.append(option);
+                }
+                if (bindings[role] && !audioAssets.some((item) => item.id === bindings[role])) {
+                    const missing = el("option", "", `Missing track · ${bindings[role]}`);
+                    missing.value = bindings[role]; select.append(missing);
+                }
+                select.value = bindings[role];
+                select.addEventListener("change", () => {
+                    try {
+                        void updateAsset(asset, {options: {
+                            audio_tracks: setProjectAudioTrack(asset, role, select.value),
+                        }});
+                    } catch (error) {
+                        select.value = bindings[role];
+                        status.textContent = String(error.message || error);
+                    }
+                });
+                label.append(select); tracks.append(label);
+            }
+            tracks.append(button("Reset to single track", () => updateAsset(
+                asset, {options: {audio_tracks: null}},
+            ), "Use this file alone, with the original source-track behavior"));
+            editor.append(tracks);
+        }
+        const tagLabel = el("label", "", isSourceTrack ? "Catalog tag" : "Prompt tag");
+        tagLabel.title = isSourceTrack
+            ? "Internal catalog identifier. A Project source track is not activated from scene prompts."
+            : `Scene prompts activate this asset by including ${promptTag(asset)}.`;
+        const tag = el("input"); tag.value = asset.tag ?? "";
+        tag.addEventListener("change", () => updateAsset(asset, {tag: tag.value}));
+        tagLabel.append(tag); editor.append(tagLabel);
+        const folderLabel = el("label", "", "Folder");
+        folderLabel.title = "Presentation only. Folder membership never changes prompts, references, fingerprints, or generation.";
+        const folderSelect = el("select");
+        const noFolder = el("option", "", "No folder"); noFolder.value = "";
+        folderSelect.append(noFolder);
+        for (const folder of state.catalog.folders ?? []) {
+            const option = el("option", "", folder.name); option.value = folder.id;
+            option.selected = folder.id === String(asset.folder_id ?? "");
+            folderSelect.append(option);
+        }
+        folderSelect.addEventListener("change", () => {
+            if (folderSelect.value) {
+                state.folder = folderSelect.value;
+                setFolderExpanded(folderSelect.value, true);
+            }
+            void updateAsset(asset, {folder_id: folderSelect.value});
+        });
+        folderLabel.append(folderSelect); editor.append(folderLabel);
+        const enabledTitle = isSourceTrack ? "Selected timeline source" : "Available to prompts";
+        const enabledSummary = isSourceTrack
+            ? "Makes this file available to the Plan; Chain Policy decides how it is used."
+            : `${promptTag(asset)} is used only when a scene prompt includes its tag. Turn off to archive it from suggestions without deleting it.`;
+        const enabledHelp = isSourceTrack
+            ? "Select this file as the Plan's project timeline source. This does not activate it in sampling or final audio: Chain Policy Source reference and Final audio remain authoritative. Turn it off to retain the stored file without exporting its Source Timeline."
+            : `Keep ${promptTag(asset)} registered in prompt suggestions and reference fingerprinting. Scene prompts still control where it is used. Turn it off to archive it without deleting the stored file.`;
+        const enabledLabel = el("label", "h3pa-toggle");
+        enabledLabel.title = enabledHelp;
+        const enabled = el("input"); enabled.type = "checkbox"; enabled.checked = asset.enabled !== false;
+        enabled.setAttribute("aria-label", enabledTitle);
+        enabled.title = enabledHelp;
+        enabled.addEventListener("change", () => updateAsset(asset, {enabled: enabled.checked}));
+        const enabledCopy = el("span", "h3pa-toggle-copy");
+        enabledCopy.append(
+            el("strong", "", enabledTitle),
+            el("small", "", enabledSummary),
+        );
+        enabledLabel.append(enabled, enabledCopy); editor.append(enabledLabel);
+        if (asset.role === "audio_reference" && audioMode === "source_timeline") {
+                const alignHelp = "Apply the optional H3 audio-grid alignment to the per-scene reference slice. The stored full track and final assembled audio are unchanged.";
+                const alignLabel = el("label", "h3pa-toggle");
+                alignLabel.title = alignHelp;
+                const align = el("input"); align.type = "checkbox";
+                align.checked = Boolean(asset.options?.align_audio_reference);
+                align.title = alignHelp;
+                align.setAttribute("aria-label", "Align tagged audio reference to the H3 grid");
+                align.addEventListener("change", () => updateAsset(
+                    asset, {options: {align_audio_reference: align.checked}},
+                ));
+                const alignCopy = el("span", "h3pa-toggle-copy");
+                alignCopy.append(
+                    el("strong", "", "Align audio reference"),
+                    el("small", "", "Align only the derived per-scene reference slice."),
+                );
+                alignLabel.append(align, alignCopy); editor.append(alignLabel);
+        }
+        if (["video", "motion"].includes(asset.role)) {
+            const timelineLabel = el("label", "", "Timeline mode");
+            const timeline = el("select");
+            for (const value of ["restart_each_scene", "sequential"]) {
+                const option = el("option", "", value.replaceAll("_", " "));
+                option.value = value; option.selected = value === (asset.options?.timeline_mode ?? "restart_each_scene");
+                timeline.append(option);
+            }
+            timeline.addEventListener("change", () => updateAsset(asset, {options: {timeline_mode: timeline.value}}));
+            timelineLabel.append(timeline); editor.append(timelineLabel);
+            if (asset.metadata?.has_audio) {
+                const pairedLabel = el("label");
+                const paired = el("input"); paired.type = "checkbox";
+                paired.checked = Boolean(
+                    asset.options?.use_embedded_audio ?? true);
+                paired.addEventListener("change", () => updateAsset(
+                    asset, {options: {use_embedded_audio: paired.checked}},
+                ));
+                pairedLabel.append(
+                    paired, document.createTextNode(" Use embedded audio as paired reference"),
+                );
+                editor.append(pairedLabel);
+            }
+        }
+        if (asset.role === "motion") {
+            const edgeLabel = el("label", "", "Reference short edge");
+            const edge = el("select");
+            for (const value of ["source", "384", "512", "768"]) {
+                const option = el("option", "", value);
+                option.value = value;
+                option.selected = value === String(
+                    asset.options?.reference_short_edge ?? "384");
+                edge.append(option);
+            }
+            edge.addEventListener("change", () => updateAsset(
+                asset, {options: {reference_short_edge: edge.value}},
+            ));
+            edgeLabel.append(edge); editor.append(edgeLabel);
+            for (const [name, label, fallback] of [
+                ["target_subject", "Target Subject", "<Subject 1>"],
+                ["motion_description", "Motion description", "the supplied pose sequence, action, and motion timing"],
+            ]) {
+                const wrapper = el("label", "", label);
+                const input = name === "motion_description" ? el("textarea") : el("input");
+                input.value = asset.options?.[name] ?? fallback;
+                input.addEventListener("change", () => updateAsset(asset, {options: {[name]: input.value}}));
+                wrapper.append(input); editor.append(wrapper);
+            }
+        }
+        editor.append(el("small", "h3pa-status", `input/${asset.input_path}`));
+        const actions = el("div", "h3pa-editor-actions");
+        const primaryActions = el("div", "h3pa-action-primary");
+        const manageActions = el("div", "h3pa-action-manage");
+        const assetIndex = (state.catalog.assets ?? []).findIndex(
+            (item) => item.id === asset.id,
+        );
+        const earlier = button("←", () => moveAsset(asset, -1),
+            "Move this asset one position earlier in the project Carousel");
+        earlier.setAttribute("aria-label", "Move asset earlier");
+        earlier.disabled = assetIndex <= 0;
+        const later = button("→", () => moveAsset(asset, 1),
+            "Move this asset one position later in the project Carousel");
+        later.setAttribute("aria-label", "Move asset later");
+        later.disabled = assetIndex < 0 || assetIndex >= state.catalog.assets.length - 1;
+        const remove = button("Delete", () => deleteAsset(asset),
+            "Permanently remove this project-owned copy and its H3 backup");
+        remove.setAttribute("aria-label", "Delete asset");
+        remove.classList.add("danger");
+        primaryActions.append(
+            ...(asset.kind === "image" ? [button(
+                "Edit / upscale", () => openImageEditor(asset),
+                "Resize, crop, or model-upscale a nondestructive image variant from exact source pixels",
+            )] : []),
+            button("Duplicate", () => duplicateAsset(asset),
+                "Create another catalog card that initially shares the same stored media bytes"),
+        );
+        manageActions.append(earlier, later, remove);
+        actions.append(
+            el("span", "h3pa-action-label", "Asset actions"),
+            primaryActions, manageActions,
+        );
+        editor.append(actions);
+    }
+    function assetCard(asset, folderMember = false) {
+        const card = el("button", "h3pa-card"); card.type = "button";
+        card.classList.toggle("selected", asset.id === state.selected);
+        card.classList.toggle("unresolved", Boolean(asset._unresolved));
+        card.classList.toggle("stale", asset._unresolved && asset.available === false);
+        card.classList.toggle("h3pa-folder-member", folderMember);
+        if (!asset._unresolved) {
+            card.draggable = true;
+            card.title = folderMember
+                ? "Drag to reorder this asset, or drop it onto another folder."
+                : "Drag to reorder this project asset.";
+        }
+        if (!asset._unresolved && ["image", "video"].includes(asset.kind)) {
+            const image = el("img"); image.loading = "lazy";
+            image.draggable = false;
+            image.src = mediaUrl(project(), asset, "thumbnail"); card.append(image);
+        } else card.append(el(
+            "div", "fallback", asset._unresolved ? "?" : "♫",
+        ));
+        card.append(el(
+            "span", "h3pa-badge",
+            `${displayRole(asset.role)}${asset._unresolved ? " · unassigned" : ""}`,
+        ));
+        if (!asset._unresolved) card.append(el(
+            "span", "h3pa-drag-handle", "↔",
+        ));
+        card.append(el(
+            "span", "",
+            `${asset.available === false || asset.enabled === false ? "○ " : ""}${promptTag(asset)}`,
+        ));
+        card.addEventListener("click", () => { state.selected = asset.id; render(); });
+        if (!asset._unresolved) {
+            card.addEventListener("dragstart", (event) => {
+                state.dragging = asset.id;
+                clearFileDropState();
+                card.classList.add("dragging");
+                event.dataTransfer.effectAllowed = "move";
+                event.dataTransfer.setData("text/plain", asset.id);
+            });
+            card.addEventListener("dragover", (event) => {
+                if (!state.dragging || state.dragging === asset.id) return;
+                event.preventDefault();
+                event.dataTransfer.dropEffect = "move";
+                card.classList.add("drag-over");
+            });
+            card.addEventListener("dragleave", () => {
+                card.classList.remove("drag-over");
+            });
+            card.addEventListener("drop", (event) => {
+                event.preventDefault();
+                card.classList.remove("drag-over");
+                const dragged = state.dragging || event.dataTransfer.getData("text/plain");
+                if (!dragged || dragged === asset.id) return;
+                const assetIds = (state.catalog.assets ?? []).map((item) => item.id);
+                const from = assetIds.indexOf(dragged);
+                if (from < 0) return;
+                assetIds.splice(from, 1);
+                let target = assetIds.indexOf(asset.id);
+                if (target < 0) return;
+                const bounds = card.getBoundingClientRect();
+                if (event.clientX >= bounds.left + bounds.width / 2) target += 1;
+                assetIds.splice(target, 0, dragged);
+                state.selected = dragged;
+                void reorderAssets(assetIds);
+            });
+            card.addEventListener("dragend", () => {
+                state.dragging = "";
+                clearFileDropState();
+                for (const item of carousel.querySelectorAll(
+                    ".h3pa-card,.h3pa-folder-card",
+                )) item.classList.remove("dragging", "drag-over");
+            });
+        }
+        return card;
+    }
+    function folderCard(folder, previewAssets, totalCount) {
+        const folderId = String(folder.id);
+        const expanded = state.expandedFolders.has(folderId);
+        const card = el("button", "h3pa-folder-card"); card.type = "button";
+        card.classList.toggle("expanded", expanded);
+        card.classList.toggle("selected", state.folder === folderId);
+        card.title = `${expanded ? "Collapse" : "Expand"} ${folder.name}. Drag an asset here to move it into this folder.`;
+        const mosaic = el("span", "h3pa-folder-mosaic");
+        const tiles = previewAssets.slice(0, 4);
+        if (!tiles.length) tiles.push(null);
+        for (const asset of tiles) {
+            const tile = el("span", "h3pa-folder-tile");
+            if (asset && ["image", "video"].includes(asset.kind)) {
+                const image = el("img"); image.loading = "lazy";
+                image.draggable = false;
+                image.src = mediaUrl(project(), asset, "thumbnail");
+                tile.append(image);
+            } else {
+                tile.textContent = asset?.kind === "audio" ? "♫" : "▦";
+            }
+            mosaic.append(tile);
+        }
+        card.append(
+            mosaic,
+            el("span", "h3pa-folder-name", `${expanded ? "▾" : "▸"} ${folder.name}`),
+            el("span", "h3pa-folder-count", String(totalCount)),
+        );
+        card.addEventListener("click", () => {
+            state.folder = folderId;
+            setFolderExpanded(folderId, !expanded);
+            render();
+        });
+        card.addEventListener("dragover", (event) => {
+            if (!state.dragging) return;
+            event.preventDefault();
+            event.dataTransfer.dropEffect = "move";
+            card.classList.add("drag-over");
+        });
+        card.addEventListener("dragleave", () => card.classList.remove("drag-over"));
+        card.addEventListener("drop", (event) => {
+            if (!state.dragging) return;
+            event.preventDefault();
+            event.stopPropagation();
+            card.classList.remove("drag-over");
+            const asset = (state.catalog.assets ?? []).find(
+                (item) => item.id === state.dragging,
+            );
+            if (!asset) return;
+            state.folder = folderId;
+            setFolderExpanded(folderId, true);
+            if (String(asset.folder_id ?? "") !== folderId) {
+                void updateAsset(asset, {folder_id: folderId});
+            }
+        });
+        return card;
+    }
+    function renderCarousel() {
+        carousel.replaceChildren();
+        const assets = filteredAssets();
+        if (!assets.some((asset) => asset.id === state.selected)) {
+            state.selected = assets[0]?.id ?? "";
+        }
+        const folders = state.catalog.folders ?? [];
+        const folderById = new Map(folders.map(
+            (folder) => [String(folder.id), folder],
+        ));
+        const allMembers = new Map(folders.map(
+            (folder) => [String(folder.id), []],
+        ));
+        for (const asset of state.catalog.assets ?? []) {
+            const members = allMembers.get(String(asset.folder_id ?? ""));
+            if (members) members.push(asset);
+        }
+        const visibleMembers = new Map(folders.map(
+            (folder) => [String(folder.id), []],
+        ));
+        for (const asset of assets) {
+            const members = visibleMembers.get(String(asset.folder_id ?? ""));
+            if (members && !asset._unresolved) members.push(asset);
+        }
+        const renderedFolders = new Set();
+        let renderedItems = 0;
+        for (const asset of assets) {
+            const folder = !asset._unresolved
+                ? folderById.get(String(asset.folder_id ?? "")) : null;
+            if (!folder) {
+                carousel.append(assetCard(asset));
+                renderedItems += 1;
+                continue;
+            }
+            const folderId = String(folder.id);
+            if (renderedFolders.has(folderId)) continue;
+            renderedFolders.add(folderId);
+            const members = visibleMembers.get(folderId) ?? [];
+            const group = el("div", "h3pa-folder-group");
+            const expanded = state.expandedFolders.has(folderId);
+            group.classList.toggle("expanded", expanded);
+            group.append(folderCard(
+                folder, members, (allMembers.get(folderId) ?? []).length,
+            ));
+            if (expanded) {
+                for (const member of members) group.append(assetCard(member, true));
+            }
+            carousel.append(group);
+            renderedItems += 1;
+        }
+        if (state.filter === "all") {
+            for (const folder of folders) {
+                if (renderedFolders.has(String(folder.id))) continue;
+                const group = el("div", "h3pa-folder-group");
+                group.append(folderCard(folder, [], 0));
+                carousel.append(group);
+                renderedItems += 1;
+            }
+        }
+        if (!renderedItems) {
+            carousel.append(el(
+                "div", "h3pa-carousel-empty",
+                "Drop image, video, or audio files here, or use Upload / Import.",
+            ));
+        }
+    }
+    function render() {
+        const folderIds = new Set((state.catalog.folders ?? []).map(
+            (folder) => String(folder.id),
+        ));
+        let changed = false;
+        for (const folderId of state.expandedFolders) {
+            if (folderIds.has(folderId)) continue;
+            state.expandedFolders.delete(folderId);
+            changed = true;
+        }
+        if (changed) saveExpandedFolders();
+        if (state.folder && !folderIds.has(state.folder)) state.folder = "";
+        renderTabs(); renderFolders(); renderCarousel();
+        const selected = allItems().find((asset) => asset.id === state.selected);
+        renderPreview(selected); renderEditor(selected);
+    }
+    function restoreConfiguredProjectIdentity() {
+        const configuredProject = serializedProjectAssetIdentity(
+            runNameWidget?.value, catalogWidget?.value,
+        );
+        const changed = project() !== configuredProject;
+        if (changed) {
+            refreshSequence += 1;
+            runNameInput.value = configuredProject;
+        }
+        if (runNameWidget && runNameWidget.value !== configuredProject) {
+            // Old workflows may only carry the project in catalog_json.
+            runNameWidget.value = configuredProject;
+        }
+        return {configuredProject, changed};
+    }
+    function hydrateSerializedCatalog({fromConfiguration = false} = {}) {
+        if (fromConfiguration) projectEpoch += 1;
+        const restored = fromConfiguration
+            ? restoreConfiguredProjectIdentity()
+            : {configuredProject: project(), changed: false};
+        const catalog = serializedProjectAssetCatalog(
+            catalogWidget?.value, restored.configuredProject,
+        );
+        if (!catalog) {
+            if (restored.changed) {
+                stopMedia();
+                state.selected = "";
+                state.catalog = {
+                    project: restored.configuredProject,
+                    assets: [], reference_slots: [], folders: [],
+                };
+                render();
+            }
+            return false;
+        }
+        const currentSignature = `${String(state.catalog?.project ?? "")}\u0000${String(
+            state.catalog?.revision ?? "",
+        )}`;
+        const cachedSignature = `${String(catalog.project ?? "")}\u0000${String(
+            catalog.revision ?? "",
+        )}`;
+        if (currentSignature === cachedSignature
+                && (state.catalog?.assets?.length ?? 0) === catalog.assets.length
+                && (state.catalog?.reference_slots?.length ?? 0) ===
+                    catalog.reference_slots.length) return false;
+        state.catalog = catalog;
+        render();
+        setStatus(
+            `${catalog.assets.length} cached project assets · checking for changes…`,
+        );
+        return true;
+    }
+    async function refresh() {
+        const requestedProject = project();
+        const sequence = ++refreshSequence;
+        if (!requestedProject) {
+            void refreshProjectSuggestions();
+            setStatus("Enter a Run name, or connect this node to a named Plan.");
+            return;
+        }
+        try {
+            setStatus(`Loading ${requestedProject}…`);
+            const catalog = await jsonRequest(
+                `/minimax_h3_context_loop/project-assets?project=${encodeURIComponent(requestedProject)}`,
+            );
+            if (sequence !== refreshSequence || project() !== requestedProject) return;
+            persistCatalog(catalog); render();
+            void refreshProjectSuggestions();
+            setStatus(`${catalog.assets.length} project assets · ${(catalog.reference_slots ?? []).length} unassigned · revision ${(catalog.revision || "empty").slice(0, 12)}`);
+        } catch (error) { if (!error.staleProject) setStatus(error.message, true); }
+    }
+    function adoptConnectedRunName() {
+        const current = project();
+        if (current && current !== "h3_project") return false;
+        const connected = downstreamPlanRunName(node);
+        if (!connected) return false;
+        projectEpoch += 1;
+        refreshSequence += 1;
+        runNameInput.value = connected;
+        if (runNameWidget) {
+            runNameWidget.value = connected;
+            runNameWidget.callback?.(connected);
+        }
+        void refresh();
+        return true;
+    }
+    function scheduleGraphRunNameSync() {
+        for (const timer of graphSyncTimers) clearTimeout(timer);
+        graphSyncTimers.clear();
+        for (const delay of [0, 50, 200, 750]) {
+            const timer = setTimeout(() => {
+                graphSyncTimers.delete(timer);
+                if (adoptConnectedRunName()) {
+                    for (const pending of graphSyncTimers) clearTimeout(pending);
+                    graphSyncTimers.clear();
+                }
+            }, delay);
+            graphSyncTimers.add(timer);
+        }
+    }
+    async function importAsset(body) {
+        const result = await mutationRequest(
+            "/minimax_h3_context_loop/project-assets/import", {
+                method: "POST", headers: {"Content-Type": "application/json"},
+                body: JSON.stringify({project: project(), ...body}),
+            });
+        persistCatalog(result.catalog); state.selected = result.asset.id; render();
+        setStatus(`${result.bound_slot_id ? "Bound" : "Imported"} ${promptTag(result.asset)} as ${result.asset.role}.`);
+    }
+    async function uploadFiles(fileList, {slot = null, dropped = false} = {}) {
+        const files = Array.from(fileList ?? []).filter(
+            (file) => file && typeof file.name === "string" && file.name,
+        );
+        if (!files.length) {
+            setStatus("No media files were dropped.", true);
+            return;
+        }
+        if (!project()) {
+            setStatus("Enter a Run name, or connect this node to a named Plan before adding assets.", true);
+            return;
+        }
+        if (state.uploading) {
+            setStatus("Project assets are already being added. Wait for that batch to finish.", true);
+            return;
+        }
+        const operation = captureProjectOperation();
+        state.uploading = true;
+        let completed = 0;
+        let lastResult = null;
+        const failures = [];
+        try {
+            for (let index = 0; index < files.length; index += 1) {
+                if (!isCurrentProjectOperation(operation)) break;
+                const file = files[index];
+                const targetSlot = index === 0 ? slot : null;
+                const data = new FormData();
+                data.append("project", operation.run);
+                if (targetSlot?.id) data.append("slot_id", targetSlot.id);
+                data.append("file", file, file.name);
+                setStatus(
+                    `${targetSlot ? `Binding ${promptTag(targetSlot)} from` : "Creating asset from"} ${file.name}`
+                    + `${files.length > 1 ? ` (${index + 1}/${files.length})` : ""}…`,
+                );
+                try {
+                    lastResult = await mutationRequest(
+                        "/minimax_h3_context_loop/project-assets/upload",
+                        {method: "POST", body: data}, operation,
+                    );
+                    completed += 1;
+                } catch (error) {
+                    failures.push(`${file.name}: ${error.message}`);
+                }
+            }
+            if (!isCurrentProjectOperation(operation)) {
+                if (!projectDisposed) setStatus(
+                    `Upload batch stopped because the Run changed. Check ${operation.run} for files already submitted; no further files were submitted.`,
+                );
+                return;
+            }
+            if (lastResult) {
+                persistCatalog(lastResult.catalog);
+                state.selected = lastResult.asset.id;
+                render();
+            }
+            if (failures.length) {
+                setStatus(
+                    `${completed ? `Created ${completed} asset${completed === 1 ? "" : "s"}; ` : ""}`
+                    + `${failures.length} file${failures.length === 1 ? "" : "s"} failed: ${failures.join(" | ")}`,
+                    true,
+                );
+            } else if (slot && lastResult) {
+                setStatus(`Bound ${promptTag(lastResult.asset)} from ${files[0].name}.`);
+            } else if (dropped && lastResult) {
+                setStatus(files.length === 1
+                    ? `Created ${promptTag(lastResult.asset)} from dropped file.`
+                    : `Created ${completed} project assets from dropped files.`);
+            } else if (lastResult) {
+                setStatus(`Uploaded ${promptTag(lastResult.asset)}.`);
+            }
+        } finally {
+            state.uploading = false;
+        }
+    }
+    async function browseSource(slot = null, forcedSource = "") {
+        const operation = captureProjectOperation();
+        let source = forcedSource || sourceSelect.value;
+        const modal = el("div", "h3pa-modal");
+        const row = el("div", "h3pa-row");
+        const search = el("input", "h3pa-project"); search.placeholder = "Filter assets";
+        const sourceTitle = source === "input"
+            ? "ComfyUI input"
+            : (source === "project" ? "Other Run assets" : "H3 chain backups");
+        row.append(el("strong", "", sourceTitle), search,
+            button("Close", () => modal.remove()));
+        const list = el("div", "h3pa-source-list"); modal.append(row, list); document.body.append(modal);
+        async function load() {
+            list.textContent = "Loading…";
+            try {
+                const payload = await jsonRequest(
+                    `/minimax_h3_context_loop/project-assets/sources?source=${source}&q=${encodeURIComponent(search.value)}&project=${encodeURIComponent(project())}`,
+                );
+                list.replaceChildren();
+                const items = source === "chains"
+                    ? payload.items.flatMap((run) => run.assets.map((asset) => ({...asset, run_name: run.run_name})))
+                    : (source === "project"
+                        ? payload.items.flatMap((run) => run.assets.map((asset) => ({...asset, source_project: run.project})))
+                        : payload.items);
+                if (!items.length) {
+                    list.append(el("div", "h3pa-empty", source === "project"
+                        ? "No matching assets were found in another Run."
+                        : "No matching media was found."));
+                }
+                for (const item of items) {
+                    const rowItem = el("div", "h3pa-source-item");
+                    const sourceLabel = source === "chains"
+                        ? `${item.run_name} · ${promptTag(item)}`
+                        : (source === "project"
+                            ? `${item.source_project} · ${promptTag(item)} · ${item.original_name || "asset"}`
+                            : item.path);
+                    rowItem.append(el("span", "", sourceLabel),
+                    el("span", "", item.kind ?? ""), button(slot ? "Bind" : "Import", async () => {
+                        try {
+                            requireCurrentProjectOperation(operation);
+                            if (source === "chains") await importAsset({
+                                source, run_name: item.run_name, asset_id: item.id,
+                                slot_id: slot?.id ?? "",
+                            });
+                            else if (source === "project") await importAsset({
+                                source, source_project: item.source_project,
+                                asset_id: item.id, slot_id: slot?.id ?? "",
+                            });
+                            else await importAsset({
+                                source, path: item.path, slot_id: slot?.id ?? "",
+                            });
+                            modal.remove();
+                        } catch (error) { if (!error.staleProject) setStatus(error.message, true); }
+                    }));
+                    list.append(rowItem);
+                }
+            } catch (error) { list.textContent = error.message; }
+        }
+        let timer = 0;
+        search.addEventListener("input", () => { clearTimeout(timer); timer = setTimeout(load, 250); });
+        await load();
+    }
+    fileInput.addEventListener("change", async () => {
+        await uploadFiles(fileInput.files, {slot: state.bindingSlot});
+        state.bindingSlot = null;
+        fileInput.value = "";
+    });
+    const dropController = new AbortController();
+    const dropListenerOptions = {signal: dropController.signal};
+    let fileDragDepth = 0;
+    function hasDraggedFiles(event) {
+        if (state.dragging) return false;
+        return Array.from(event.dataTransfer?.types ?? []).includes("Files");
+    }
+    function clearFileDropState() {
+        fileDragDepth = 0;
+        carousel.classList.remove("h3pa-drop-active");
+    }
+    carousel.addEventListener("dragenter", (event) => {
+        if (!hasDraggedFiles(event)) return;
+        event.preventDefault();
+        fileDragDepth += 1;
+        carousel.classList.add("h3pa-drop-active");
+    }, dropListenerOptions);
+    carousel.addEventListener("dragover", (event) => {
+        if (!hasDraggedFiles(event)) return;
+        event.preventDefault();
+        event.dataTransfer.dropEffect = "copy";
+        carousel.classList.add("h3pa-drop-active");
+    }, dropListenerOptions);
+    carousel.addEventListener("dragleave", (event) => {
+        if (!hasDraggedFiles(event)) return;
+        fileDragDepth = Math.max(0, fileDragDepth - 1);
+        if (!fileDragDepth) carousel.classList.remove("h3pa-drop-active");
+    }, dropListenerOptions);
+    carousel.addEventListener("drop", (event) => {
+        if (!hasDraggedFiles(event)) return;
+        event.preventDefault();
+        event.stopPropagation();
+        const files = Array.from(event.dataTransfer?.files ?? []);
+        clearFileDropState();
+        void uploadFiles(files, {dropped: true});
+    }, dropListenerOptions);
+    function switchProject(selectedProject) {
+        if (!state.projectNames.has(selectedProject)) return false;
+        projectEpoch += 1;
+        refreshSequence += 1;
+        state.selected = "";
+        state.folder = "";
+        stopMedia();
+        runNameInput.value = selectedProject;
+        if (runNameWidget) {
+            runNameWidget.value = selectedProject;
+            runNameWidget.callback?.(selectedProject);
+        }
+        syncDownstreamPlan(node, selectedProject);
+        node.graph?.setDirtyCanvas?.(true, true);
+        void refresh();
+        return true;
+    }
+    runNameInput.addEventListener("input", () => {
+        projectEpoch += 1;
+        refreshSequence += 1;
+        const draft = String(runNameInput.value || "");
+        if (runNameWidget) {
+            runNameWidget.value = draft;
+            runNameWidget.callback?.(draft);
+        }
+        setStatus("Press Enter or leave the Run name field to load this project.");
+    });
+    runNameInput.addEventListener("change", () => {
+        if (!switchProject(project())) void refresh();
+    });
+    runNameInput.addEventListener("keydown", (event) => {
+        if (event.key !== "Enter") return;
+        event.preventDefault();
+        runNameInput.blur();
+    });
+    projectMenu.addEventListener("change", () => {
+        const selectedProject = String(projectMenu.value || "");
+        projectMenu.value = "";
+        if (selectedProject) switchProject(selectedProject);
+    });
+    previewSelect.addEventListener("change", () => {
+        state.previewMode = previewSelect.value === "full" ? "full" : "light";
+        node.properties ??= {};
+        node.properties.h3_project_asset_preview_mode = state.previewMode;
+        render();
+    });
+    const connectionsChanged = node.onConnectionsChange;
+    node.onConnectionsChange = function () {
+        const result = connectionsChanged?.apply(this, arguments);
+        scheduleGraphRunNameSync();
+        return result;
+    };
+    const removed = node.onRemoved;
+    node.onRemoved = function () {
+        projectDisposed = true;
+        projectEpoch += 1;
+        for (const timer of graphSyncTimers) clearTimeout(timer);
+        graphSyncTimers.clear();
+        dropController.abort();
+        stopMedia();
+        return removed?.apply(this, arguments);
+    };
+    const executed = node.onExecuted;
+    node.onExecuted = function () {
+        const result = executed?.apply(this, arguments);
+        if (operationWidget?.value) {
+            operationWidget.value = "";
+            operationWidget.callback?.("");
+        }
+        void refresh();
+        return result;
+    };
+    node._h3ProjectAssetRefresh = ({fromConfiguration = false} = {}) => {
+        refreshSemanticSettingVisibility(node);
+        hydrateSerializedCatalog({fromConfiguration});
+        if (!adoptConnectedRunName()) void refresh();
+        scheduleGraphRunNameSync();
+    };
+    if (savedCatalog) render();
+    node._h3ProjectAssetRefresh({fromConfiguration: true});
+}
+
+app.registerExtension({
+    name: "minimax_h3_context_loop.project_asset_manager",
+    async beforeRegisterNodeDef(nodeClass, nodeData) {
+        if (nodeData.name !== NODE_NAME) return;
+        const created = nodeClass.prototype.onNodeCreated;
+        nodeClass.prototype.onNodeCreated = function () {
+            const result = created?.apply(this, arguments);
+            setTimeout(() => mount(this), 0); return result;
+        };
+        const configured = nodeClass.prototype.onConfigure;
+        nodeClass.prototype.onConfigure = function () {
+            const result = configured?.apply(this, arguments);
+            setTimeout(() => this._h3ProjectAssetRefresh?.({
+                fromConfiguration: true,
+            }), 0); return result;
+        };
+        const graphConfigured = nodeClass.prototype.onGraphConfigured;
+        nodeClass.prototype.onGraphConfigured = function () {
+            const result = graphConfigured?.apply(this, arguments);
+            setTimeout(() => this._h3ProjectAssetRefresh?.({
+                fromConfiguration: true,
+            }), 0); return result;
+        };
+        const extraMenuOptions = nodeClass.prototype.getExtraMenuOptions;
+        nodeClass.prototype.getExtraMenuOptions = function (_, options) {
+            const result = extraMenuOptions?.apply(this, arguments);
+            const visible = this.properties?.h3_show_semantic_anchor_settings !== false;
+            options.push({
+                content: visible
+                    ? "Hide semantic anchor settings"
+                    : "Show semantic anchor settings",
+                callback: () => {
+                    this.properties ??= {};
+                    this.properties.h3_show_semantic_anchor_settings = !visible;
+                    refreshSemanticSettingVisibility(this);
+                },
+            });
+            return result;
+        };
+    },
+    async nodeCreated(node) { if (nodeType(node) === NODE_NAME) mount(node); },
+    async afterConfigureGraph() {
+        for (const node of app.graph?._nodes ?? []) {
+            if (nodeType(node) === NODE_NAME) {
+                setTimeout(() => node._h3ProjectAssetRefresh?.({
+                    fromConfiguration: true,
+                }), 0);
+            }
+        }
+    },
+});
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_project_asset_sync_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_project_asset_sync_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..9832d3e4c84e58b209b34df33df2d32444bc6ddf
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_project_asset_sync_core.mjs
@@ -0,0 +1,48 @@
+export const PROJECT_ASSET_CATALOG_CHANGED_EVENT =
+    "minimax-h3-project-assets-changed";
+
+export function serializedProjectAssetCatalog(value, requestedProject = "") {
+    let catalog = value;
+    if (typeof catalog === "string") {
+        try { catalog = JSON.parse(catalog); }
+        catch (_error) { return null; }
+    }
+    if (!catalog || typeof catalog !== "object" || Array.isArray(catalog)) {
+        return null;
+    }
+    const project = String(catalog.project ?? "").trim();
+    const requested = String(requestedProject ?? "").trim();
+    if (requested && project && requested !== project) return null;
+    if (!Array.isArray(catalog.assets)
+            || !Array.isArray(catalog.reference_slots ?? [])) return null;
+    return {
+        ...catalog,
+        project:project || requested,
+        assets:[...catalog.assets],
+        reference_slots:[...(catalog.reference_slots ?? [])],
+        folders:Array.isArray(catalog.folders) ? [...catalog.folders] : [],
+    };
+}
+
+export function serializedProjectAssetIdentity(runNameValue, catalogValue) {
+    const configured = String(runNameValue ?? "").trim();
+    if (configured && configured !== "h3_project") return configured;
+    const catalog = serializedProjectAssetCatalog(catalogValue);
+    const catalogProject = String(catalog?.project ?? "").trim();
+    return catalogProject === "h3_project" ? "" : catalogProject;
+}
+
+export function publishProjectAssetCatalogChanged(manager, catalog) {
+    const project = String(catalog?.project ?? "").trim();
+    const revision = String(catalog?.revision ?? "").trim();
+    const signature = `${project}\u0000${revision}`;
+    if (manager?._h3ProjectAssetPublishedSignature === signature) return false;
+    if (manager) manager._h3ProjectAssetPublishedSignature = signature;
+    if (typeof globalThis.dispatchEvent !== "function"
+            || typeof globalThis.CustomEvent !== "function") return false;
+    globalThis.dispatchEvent(new CustomEvent(
+        PROJECT_ASSET_CATALOG_CHANGED_EVENT,
+        {detail: {manager, project, revision}},
+    ));
+    return true;
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_assistant_client.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_assistant_client.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..3e6b24e7a7f0e0418b421ed76432bdf73a0cc169
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_assistant_client.mjs
@@ -0,0 +1,190 @@
+const DEFAULT_BRIDGE_URL = "ws://127.0.0.1:9180";
+const PANEL_BRIDGE_STORAGE_KEY = "comfyui-mcp.panel.bridgeUrl";
+
+function storedBridgeUrl(storage) {
+    try {
+        const value = storage?.getItem?.(PANEL_BRIDGE_STORAGE_KEY);
+        return typeof value === "string" && /^wss?:\/\//.test(value.trim())
+            ? value.trim() : null;
+    } catch (_error) {
+        return null;
+    }
+}
+
+async function jsonFrom(fetchImpl, path) {
+    try {
+        const response = await fetchImpl(path, {cache: "no-store"});
+        if (!response.ok) return null;
+        return await response.json();
+    } catch (_error) {
+        return null;
+    }
+}
+
+export async function discoverPromptAssistBridge({
+    fetchImpl = globalThis.fetch?.bind(globalThis),
+    locationLike = globalThis.location,
+    storage = globalThis.localStorage,
+} = {}) {
+    if (locationLike?.protocol === "https:" && fetchImpl) {
+        const advertised = await jsonFrom(fetchImpl, "/comfyui_mcp_panel/bridge_url");
+        if (typeof advertised?.url === "string" && advertised.url.startsWith("wss://")) {
+            return advertised.url;
+        }
+    }
+    const stored = storedBridgeUrl(storage);
+    if (stored) return stored;
+    if (fetchImpl) {
+        const status = await jsonFrom(fetchImpl, "/comfyui_mcp_panel/status");
+        if (typeof status?.bridge_url === "string" && /^wss?:\/\//.test(status.bridge_url)) {
+            return status.bridge_url;
+        }
+    }
+    return DEFAULT_BRIDGE_URL;
+}
+
+function randomId() {
+    return globalThis.crypto?.randomUUID?.()
+        ?? `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+
+function sessionIdentity(key) {
+    const storageKey = `h3.prompt-assistant.client.${key}`;
+    try {
+        let value = globalThis.sessionStorage?.getItem(storageKey);
+        if (!value) {
+            value = randomId();
+            globalThis.sessionStorage?.setItem(storageKey, value);
+        }
+        return value;
+    } catch (_error) {
+        return randomId();
+    }
+}
+
+export class PromptAssistantClient {
+    constructor({identityKey, onFrame, onStatus, discover = discoverPromptAssistBridge}) {
+        this.identity = sessionIdentity(identityKey || randomId());
+        this.routeId = `prompt-assistant:${this.identity}`;
+        this.conversationId = `h3-${this.identity}`;
+        this.onFrame = onFrame;
+        this.onStatus = onStatus;
+        this.discover = discover;
+        this.socket = null;
+        this.connecting = null;
+        this.closed = false;
+        this.needsReset = false;
+    }
+
+    status(value, detail) {
+        this.onStatus?.(value, detail);
+    }
+
+    async connect() {
+        if (this.closed) throw new Error("Prompt assistant client is closed.");
+        if (this.socket?.readyState === WebSocket.OPEN) return;
+        if (this.connecting) return this.connecting;
+        this.status("connecting");
+        this.connecting = (async () => {
+            const url = await this.discover();
+            await new Promise((resolve, reject) => {
+                let ready = false;
+                const socket = new WebSocket(url);
+                this.socket = socket;
+                const timer = globalThis.setTimeout(() => {
+                    if (ready) return;
+                    try { socket.close(); } catch (_error) { /* already closed */ }
+                    reject(new Error("The comfyui-mcp prompt-assist handshake timed out."));
+                }, 15_000);
+                socket.addEventListener("open", () => {
+                    socket.send(JSON.stringify({
+                        type: "hello",
+                        tab_id: this.routeId,
+                        tab_session_id: this.identity,
+                        title: "H3 Prompt Assistant",
+                        headless: true,
+                        client_kind: "prompt_assistant",
+                    }));
+                });
+                socket.addEventListener("message", (event) => {
+                    let frame;
+                    try { frame = JSON.parse(String(event.data ?? "")); } catch (_error) { return; }
+                    if (frame?.type === "prompt_assist_ready") {
+                        ready = true;
+                        globalThis.clearTimeout(timer);
+                        if (this.needsReset) {
+                            socket.send(JSON.stringify({
+                                tab_id: this.routeId,
+                                type: "prompt_assist_reset",
+                                conversation_id: this.conversationId,
+                            }));
+                            this.needsReset = false;
+                        }
+                        this.status("connected", frame);
+                        resolve();
+                    }
+                    this.onFrame?.(frame);
+                });
+                socket.addEventListener("error", () => {
+                    if (!ready) {
+                        globalThis.clearTimeout(timer);
+                        try { socket.close(); } catch (_error) { /* already closed */ }
+                        reject(new Error(`Could not connect to the comfyui-mcp bridge at ${url.split("?")[0]}.`));
+                    }
+                });
+                socket.addEventListener("close", () => {
+                    globalThis.clearTimeout(timer);
+                    if (this.socket === socket) this.socket = null;
+                    this.status("disconnected");
+                    if (!ready) reject(new Error("The comfyui-mcp bridge closed before prompt-assist was ready."));
+                });
+            });
+        })().finally(() => {
+            this.connecting = null;
+        });
+        return this.connecting;
+    }
+
+    async send(frame) {
+        await this.connect();
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN) {
+            throw new Error("Prompt assistant is not connected.");
+        }
+        this.socket.send(JSON.stringify({tab_id: this.routeId, ...frame}));
+    }
+
+    cancel(requestId) {
+        if (this.socket?.readyState !== WebSocket.OPEN) return false;
+        this.socket.send(JSON.stringify({
+            tab_id: this.routeId,
+            type: "prompt_assist_cancel",
+            request_id: requestId,
+        }));
+        return true;
+    }
+
+    reset() {
+        this.needsReset = true;
+        if (this.socket?.readyState !== WebSocket.OPEN) return false;
+        this.socket.send(JSON.stringify({
+            tab_id: this.routeId,
+            type: "prompt_assist_reset",
+            conversation_id: this.conversationId,
+        }));
+        this.needsReset = false;
+        return true;
+    }
+
+    close() {
+        this.closed = true;
+        if (this.socket?.readyState === WebSocket.OPEN) {
+            try {
+                this.socket.send(JSON.stringify({tab_id: this.routeId, type: "prompt_assist_close"}));
+            } catch (_error) {
+                // Socket is already going away.
+            }
+        }
+        try { this.socket?.close(); } catch (_error) { /* already closed */ }
+        this.socket = null;
+    }
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_assistant_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_assistant_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..85b0f18cbf19db3dc5131ebcd6193b946b0645ec
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_assistant_core.mjs
@@ -0,0 +1,109 @@
+import {promptValueToText, sharedPrompt} from "./h3_chain_plan_core.mjs?v=0.6.5";
+
+export const PROMPT_ASSIST_MODES = Object.freeze([
+    {id: "rewrite", label: "Rewrite"},
+    {id: "continuity", label: "Continuity"},
+    {id: "shorten", label: "Shorten"},
+    {id: "critique", label: "Critique"},
+    {id: "discuss", label: "Discuss"},
+]);
+
+export const PROMPT_ASSIST_DEFAULT_INSTRUCTIONS = Object.freeze({
+    rewrite: "Rewrite this scene prompt for clarity, controllability, and strong MiniMax H3 results.",
+    continuity: "Improve the opening and ending continuity with the adjacent scenes.",
+    shorten: "Make this scene prompt shorter without losing references, dialogue, timing, or continuity.",
+    critique: "Critique this scene prompt and identify the highest-impact improvements.",
+    discuss: "Help me think through this scene prompt.",
+});
+
+function fnv1a(text) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < text.length; index += 1) {
+        hash ^= text.charCodeAt(index);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return (hash >>> 0).toString(16).padStart(8, "0");
+}
+
+export function promptSourceRevision(sceneId, prompt) {
+    const source = `${String(sceneId ?? "")}\u0000${String(prompt ?? "")}`;
+    return `${String(sceneId ?? "scene")}:${source.length}:${fnv1a(source)}`;
+}
+
+export function promptSceneKey(sceneId, sceneIndex) {
+    return `${Number(sceneIndex) || 0}:${String(sceneId ?? "scene")}`;
+}
+
+function promptAt(plan, index) {
+    const shot = plan?.shots?.[index];
+    return shot ? promptValueToText(shot.prompt, `Scene ${index + 1} prompt`) : "";
+}
+
+export function buildPromptAssistantContext(plan, sceneIndex, sourcePrompt, options = {}) {
+    const shot = plan?.shots?.[sceneIndex] ?? {};
+    const sceneId = String(shot.id || `clip_${String(sceneIndex + 1).padStart(4, "0")}`);
+    const includeShared = options.includeShared !== false;
+    const includeAdjacent = options.includeAdjacent !== false;
+    const context = {
+        generation_mode: "h3_chain_scene",
+        scene_id: sceneId,
+        scene_index: sceneIndex,
+        scene_count: plan?.shots?.length ?? 1,
+        source_prompt: String(sourcePrompt ?? ""),
+    };
+    const selectedText = String(options.selectedText ?? "");
+    if (selectedText) context.selected_text = selectedText;
+    if (includeShared) {
+        const shared = sharedPrompt(plan).text;
+        if (shared.trim()) context.shared_prompt = shared;
+    }
+    if (includeAdjacent) {
+        const previous = sceneIndex > 0 ? promptAt(plan, sceneIndex - 1) : "";
+        const next = sceneIndex + 1 < (plan?.shots?.length ?? 0)
+            ? promptAt(plan, sceneIndex + 1) : "";
+        if (previous.trim()) context.previous_prompt = previous;
+        if (next.trim()) context.next_prompt = next;
+    }
+    const duration = Number(shot.duration_seconds ?? plan?.defaults?.duration_seconds);
+    const frames = Number(shot.length ?? shot.frames);
+    if (Number.isFinite(duration) && duration > 0) context.duration_seconds = duration;
+    if (Number.isFinite(frames) && frames > 0) context.frames = Math.trunc(frames);
+    return context;
+}
+
+export function draftConflict(draft, sceneId, currentPrompt) {
+    if (!draft) return {stale: false, reason: ""};
+    if (String(draft.sceneId) !== String(sceneId)) {
+        return {stale: true, reason: "This draft belongs to a different scene."};
+    }
+    const revision = promptSourceRevision(sceneId, currentPrompt);
+    if (draft.sourceRevision !== revision) {
+        return {
+            stale: true,
+            reason: "The scene prompt changed after this draft was requested.",
+        };
+    }
+    return {stale: false, reason: ""};
+}
+
+export function makePromptAssistRequest({
+    requestId,
+    conversationId,
+    provider,
+    mode,
+    instruction,
+    context,
+}) {
+    return {
+        type: "prompt_assist_request",
+        request_id: requestId,
+        conversation_id: conversationId,
+        provider,
+        mode,
+        instruction: String(instruction ?? "").trim()
+            || PROMPT_ASSIST_DEFAULT_INSTRUCTIONS[mode]
+            || PROMPT_ASSIST_DEFAULT_INSTRUCTIONS.rewrite,
+        source_revision: promptSourceRevision(context.scene_id, context.source_prompt),
+        context,
+    };
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_companion_sync.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_companion_sync.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..b2f6b4047022468880fe544a140beeafdb63f6b2
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_companion_sync.mjs
@@ -0,0 +1,190 @@
+export const PLAN_STUDIO_NODE_TYPE = "MiniMaxH3ChainPlanStudio";
+export const PROMPT_EDITOR_NODE_TYPES = Object.freeze([
+    "MiniMaxH3ChainScenePromptEditor",
+    "MiniMaxH3ChainRichScenePromptEditor",
+]);
+
+function nodeType(node) {
+    return node?.comfyClass ?? node?.type ?? null;
+}
+
+function graphLink(graph, linkId) {
+    return graph?.links?.[linkId] ?? graph?.links?.get?.(linkId) ?? null;
+}
+
+function allGraphNodes(graph, output = []) {
+    for (const node of graph?._nodes ?? []) {
+        output.push(node);
+        if (node.subgraph) allGraphNodes(node.subgraph, output);
+    }
+    return output;
+}
+
+function graphRoot(node) {
+    return node?.graph?.rootGraph ?? node?.graph;
+}
+
+/** Direct PLAN neighbours in either direction. Keeping this adjacency-scoped
+ * means two independent editor branches may share a Plan without unexpectedly
+ * taking over each other's scene selection. */
+export function adjacentPlanCompanions(node) {
+    const graph = node?.graph;
+    const found = [];
+    const seen = new Set();
+    const add = (candidate) => {
+        if (!candidate || candidate === node || seen.has(candidate)) return;
+        seen.add(candidate);
+        found.push(candidate);
+    };
+    for (const input of node?.inputs ?? []) {
+        if (input.link == null) continue;
+        const link = graphLink(graph, input.link);
+        add(link ? graph?.getNodeById?.(link.origin_id) : null);
+    }
+    for (const output of node?.outputs ?? []) {
+        for (const linkId of output.links ?? []) {
+            const link = graphLink(graph, linkId);
+            add(link ? graph?.getNodeById?.(link.target_id) : null);
+        }
+    }
+    return found;
+}
+
+export function connectedPromptEditors(node) {
+    const allowed = new Set(PROMPT_EDITOR_NODE_TYPES);
+    return adjacentPlanCompanions(node).filter((candidate) => allowed.has(nodeType(candidate)));
+}
+
+export function connectedPlanStudios(node) {
+    return adjacentPlanCompanions(node).filter(
+        (candidate) => nodeType(candidate) === PLAN_STUDIO_NODE_TYPE,
+    );
+}
+
+/** Merge a dedicated editor's active prompt onto a freshly parsed Plan while
+ * preserving the local Plan and active-shot object identities. DOM input
+ * handlers commonly close over that shot object; replacing it after the first
+ * keystroke would make later keystrokes write into a detached object. */
+export function rebaseScenePrompt(localPlan, livePlan, sceneIndex) {
+    if (!Array.isArray(localPlan?.shots) || !Array.isArray(livePlan?.shots)) return -1;
+    const localIndex = Math.max(0, Math.trunc(Number(sceneIndex) || 0));
+    const editedShot = localPlan.shots[localIndex];
+    if (!editedShot) return -1;
+    const editedId = String(editedShot.id ?? "").trim();
+    const targetIndex = editedId
+        ? livePlan.shots.findIndex((shot) => String(shot?.id ?? "").trim() === editedId)
+        : localIndex;
+    if (targetIndex < 0 || targetIndex >= livePlan.shots.length) return -1;
+
+    const targetShot = livePlan.shots[targetIndex];
+    targetShot.prompt = Array.isArray(editedShot.prompt)
+        ? [...editedShot.prompt] : editedShot.prompt;
+    for (const key of Object.keys(editedShot)) delete editedShot[key];
+    Object.assign(editedShot, targetShot);
+    livePlan.shots[targetIndex] = editedShot;
+
+    for (const key of Object.keys(localPlan)) delete localPlan[key];
+    Object.assign(localPlan, livePlan);
+    return targetIndex;
+}
+
+/** Keep a companion editor on the same logical scene when another Plan UI
+ * rewrites or reorders the Plan. Scene IDs are stable across prompt edits;
+ * the numeric position is only a safe fallback for legacy plans. */
+export function activeSceneIndexAfterRefresh(previousPlan, nextPlan, sceneIndex) {
+    if (!Array.isArray(nextPlan?.shots) || !nextPlan.shots.length) return 0;
+    const previousIndex = Math.max(0, Math.trunc(Number(sceneIndex) || 0));
+    const previousShot = Array.isArray(previousPlan?.shots)
+        ? previousPlan.shots[previousIndex] : null;
+    const previousId = String(previousShot?.id ?? "").trim();
+    if (previousId) {
+        const matched = nextPlan.shots.findIndex(
+            (shot) => String(shot?.id ?? "").trim() === previousId,
+        );
+        if (matched >= 0) return matched;
+    }
+    return Math.min(previousIndex, nextPlan.shots.length - 1);
+}
+
+/** Compare every persisted Plan field except scene prompt text.
+ *
+ * Prompt broadcasts deliberately update their text field in place to preserve
+ * browser selection and undo. They must not, however, mark a newer Plan JSON
+ * as consumed when that JSON also changes a seed, length, scene order, context
+ * setting, or any other Plan data. */
+export function planHasNonPromptChanges(previousPlan, nextPlan) {
+    const withoutScenePrompts = (plan) => {
+        if (!plan || typeof plan !== "object" || Array.isArray(plan)) {
+            return plan;
+        }
+        return {
+            ...plan,
+            shots:Array.isArray(plan.shots) ? plan.shots.map((shot) => {
+                if (!shot || typeof shot !== "object" || Array.isArray(shot)) {
+                    return shot;
+                }
+                const copy = {...shot};
+                delete copy.prompt;
+                return copy;
+            }) : plan.shots,
+        };
+    };
+    return JSON.stringify(withoutScenePrompts(previousPlan))
+        !== JSON.stringify(withoutScenePrompts(nextPlan));
+}
+
+/** Transient UI coordination only: no selection state is added to the Plan or
+ * workflow. Receivers verify that they currently resolve the same Plan node. */
+export function publishCompanionScene(source, planNode, sceneIndex) {
+    const index = Math.max(0, Math.trunc(Number(sceneIndex) || 0));
+    let delivered = 0;
+    for (const candidate of adjacentPlanCompanions(source)) {
+        const apply = candidate?._h3PromptCompanionSetActiveScene;
+        if (typeof apply !== "function") continue;
+        try {
+            if (apply.call(candidate, planNode, index, source) !== false) delivered += 1;
+        } catch (_error) {
+            // A companion UI must never break navigation in the source node.
+        }
+    }
+    return delivered;
+}
+
+/** A runtime component such as Review Gate is not directly adjacent to the
+ * Plan's authoring companions. Broadcast across the current graph instead;
+ * each receiver still verifies the exact Plan node before accepting. */
+export function publishPlanCompanionScene(source, planNode, sceneIndex) {
+    const index = Math.max(0, Math.trunc(Number(sceneIndex) || 0));
+    let delivered = 0;
+    for (const candidate of allGraphNodes(graphRoot(source))) {
+        if (!candidate || candidate === source) continue;
+        const apply = candidate._h3PromptCompanionSetActiveScene;
+        if (typeof apply !== "function") continue;
+        try {
+            if (apply.call(candidate, planNode, index, source) !== false) delivered += 1;
+        } catch (_error) {
+            // Synchronization must never interrupt review or execution.
+        }
+    }
+    return delivered;
+}
+
+/** Publish one already-written Plan prompt to every UI bound to that exact
+ * Plan. Receivers update their live field without writing back or rebroadcasting,
+ * which keeps this loop-free and preserves browser undo in the source editor. */
+export function publishCompanionPrompt(source, planNode, sceneIndex, prompt) {
+    const index = Math.max(0, Math.trunc(Number(sceneIndex) || 0));
+    const text = String(prompt ?? "").replace(/\r\n?/g, "\n");
+    let delivered = 0;
+    for (const candidate of allGraphNodes(graphRoot(source))) {
+        if (!candidate || candidate === source) continue;
+        const apply = candidate._h3PromptCompanionSetScenePrompt;
+        if (typeof apply !== "function") continue;
+        try {
+            if (apply.call(candidate, planNode, index, text, source) !== false) delivered += 1;
+        } catch (_error) {
+            // A companion UI must not make a Plan write fail.
+        }
+    }
+    return delivered;
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_completion_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_completion_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..42827ec9df0ea53121eb65c606ba3cb713af2b67
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_completion_core.mjs
@@ -0,0 +1,894 @@
+import {
+    effectiveH3Mode,
+    H3_ALL_SECTIONS,
+    H3_AUDIO_RETENTION_MARKERS,
+    H3_MINIMAX_SPECIAL_TOKENS,
+    H3_VISUAL_RETENTION_MARKERS,
+    H3_TASK_DIRECTIVES,
+    h3SectionsForMode,
+} from "./h3_prompt_schema_core.mjs?v=0.6.5";
+
+const [
+    DIALOGUE_START,
+    DIALOGUE_END,
+    CUTOFF_TOKEN,
+    LYRICS_START,
+    LYRICS_END,
+    CAPTION_START,
+    CAPTION_END,
+] = H3_MINIMAX_SPECIAL_TOKENS;
+
+export const H3_PROMPT_SECTIONS = Object.freeze(
+    H3_ALL_SECTIONS.map((section) => `${section}:`),
+);
+
+// These are the generation-intent declarations used by the H3 prompt
+// formats represented in the shipped workflows. Keep audio reference and
+// audio reuse separate: they describe different final-audio behavior.
+export const H3_LANGUAGE_MARKERS = Object.freeze([
+    "[English]", "[French]", "[Spanish]", "[German]", "[Italian]",
+    "[Portuguese]", "[Chinese]", "[Japanese]", "[Korean]", "[Arabic]",
+    "[unclear]",
+]);
+
+// Keep the chain editor's previously useful, validator-approved combinations
+// in addition to the standalone IDE's canonical authoring catalog.
+const H3_CHAIN_TASK_DIRECTIVES = Object.freeze([
+    "[reference generation + audio reference]",
+    "[reference generation + audio reuse]",
+    "[video editing + audio reference]",
+    "[video editing + audio reuse]",
+    "[video continuation + audio reference]",
+    "[video continuation + audio reuse]",
+]);
+
+export const H3_BRACKET_DIRECTIVES = Object.freeze([
+    ...new Set([...H3_TASK_DIRECTIVES, ...H3_CHAIN_TASK_DIRECTIVES]),
+    ...Array.from({length:12}, (_, index) => `[Shot ${index + 1}]`),
+    ...H3_LANGUAGE_MARKERS,
+]);
+
+function clampedCaret(text, caret) {
+    const numeric = Number(caret);
+    if (!Number.isFinite(numeric)) return text.length;
+    return Math.max(0, Math.min(text.length, Math.trunc(numeric)));
+}
+
+function specialQuery(before, trigger, pattern) {
+    const match = before.match(pattern);
+    if (!match) return null;
+    const typed = match[1];
+    return {
+        trigger,
+        start: before.length - typed.length,
+        end: before.length,
+        typed,
+        query: typed.slice(1),
+        manual: false,
+    };
+}
+
+// Marker interactions adapted from the standalone ComfyUI-H3-Prompt-IDE.
+function completedAngleQuery(text, position) {
+    const start = text.lastIndexOf("<", Math.max(0, position - 1));
+    if (start < 0 || start >= position) return null;
+    const end = text.indexOf(">", start + 1);
+    if (end < position || end - start > 65) return null;
+    const typed = text.slice(start, end + 1);
+    if (typed.includes("\n") || typed.slice(1).includes("<")) return null;
+    return promptTokenReplacementQuery(text, start, end + 1);
+}
+
+export function promptTokenReplacementQuery(value, requestedStart, requestedEnd) {
+    const text = String(value ?? "");
+    const start = clampedCaret(text, requestedStart);
+    const end = Math.max(start, clampedCaret(text, requestedEnd));
+    const typed = text.slice(start, end);
+    const angle = typed.match(/^<([^<>\n]{1,64})>$/);
+    if (angle) {
+        const reference = typed.match(/^<(Picture|Video|Audio|Subject)\s+\d+>$/i);
+        return {trigger:"<", start, end, typed,
+            query:reference?.[1] ?? angle[1], manual:false, replacement:true,
+            allowDelete:true};
+    }
+    if (/^\[Shot\s+\d+\]$/i.test(typed)) {
+        return {trigger:"shot", start, end, typed, query:"", manual:false,
+            replacement:true, allowDelete:true};
+    }
+    if (H3_LANGUAGE_MARKERS.some((marker) => marker.toLowerCase() === typed.toLowerCase())) {
+        return {trigger:"language", start, end, typed, query:"", manual:false,
+            replacement:true, allowDelete:true};
+    }
+    if (H3_BRACKET_DIRECTIVES.some((directive) => directive.toLowerCase() === typed.toLowerCase())) {
+        return {trigger:"directive", start, end, typed, query:"", manual:false,
+            replacement:true, allowDelete:true};
+    }
+    if (/^\(S\d+(?:,S\d+)*\)$/i.test(typed)) {
+        return {trigger:"(", start, end, typed, query:"S", manual:false,
+            replacement:true, allowDelete:true};
+    }
+    return null;
+}
+
+export function promptBracketReplacementQuery(value, caret) {
+    // Structural bracket markers stay ordinary text, like retention values.
+    // A modifier-click resolves the marker under the pointer for replacement.
+    const text = String(value ?? "");
+    const position = clampedCaret(text, caret);
+    for (const match of text.matchAll(/\[[^\]\n]{1,96}\]/g)) {
+        const start = match.index ?? 0;
+        const end = start + match[0].length;
+        if (position < start || position > end) continue;
+        const query = promptTokenReplacementQuery(text, start, end);
+        return ["shot", "language", "directive"].includes(query?.trigger) ? query : null;
+    }
+    return null;
+}
+
+function activeSectionAt(text, position) {
+    const pattern = new RegExp(`^(${H3_ALL_SECTIONS.join("|")}):`, "gim");
+    let active = null;
+    for (const match of text.slice(0, position + 1).matchAll(pattern)) {
+        active = match[1].toLowerCase();
+    }
+    return active;
+}
+
+function retentionLineContext(text, position) {
+    if (activeSectionAt(text, position) !== "retention_analysis") return null;
+    const lineStart = text.lastIndexOf("\n", Math.max(0, position - 1)) + 1;
+    const nextLine = text.indexOf("\n", position);
+    const lineEnd = nextLine < 0 ? text.length : nextLine;
+    return {lineStart, lineEnd, line:text.slice(lineStart, lineEnd)};
+}
+
+function retentionFamily(referenceKind) {
+    return String(referenceKind).toLowerCase() === "audio" ? "audio" : "visual";
+}
+
+function retentionReferenceFamily(prefix, records = []) {
+    const match = prefix.match(
+        /^\s*(?:<(Subject|Picture|Video|Audio)\s+\d+>|([@#][A-Za-z][A-Za-z0-9_-]{0,63})(?:\[[0-9]+(?:\.[0-9]+)?s?\])?)(?:\s*\([^\n)]*\))?\s*:\s*$/i,
+    );
+    if (!match) return null;
+    if (match[1]) return retentionFamily(match[1]);
+    const token = match[2];
+    const record = records.find((item) =>
+        [item.token, item.nativeToken, item.semanticToken].includes(token)
+        || (item.tag && token.slice(1) === item.tag));
+    if (!record || !["picture", "video", "audio"].includes(record.kind)) return null;
+    if (token.startsWith("#") && record.kind !== "picture") return null;
+    if (token.startsWith("@") && record.nativeToken === null) return null;
+    return retentionFamily(record.kind);
+}
+
+function promptTimestampQuery(text, position, {manual = false} = {}) {
+    if (activeSectionAt(text, position) !== "detailed_description") return null;
+    const lineStart = text.lastIndexOf("\n", Math.max(0, position - 1)) + 1;
+    const before = text.slice(lineStart, position);
+    const match = before.match(/(?:^|\s)(At)([ \t]*)$/i);
+    if (!match) return null;
+    const prefix = before.slice(0, before.length - match[1].length - match[2].length);
+    const shot = prefix.match(/\[Shot\s+(\d+)\]\s*$/i);
+    const followsShot = Number(shot?.[1]) >= 1;
+    if (!manual && !followsShot) return null;
+    return {
+        trigger:"timestamp",
+        start:position - match[1].length - match[2].length,
+        end:position,
+        typed:match[1],
+        query:"",
+        manual,
+    };
+}
+
+function promptRetentionInsertionQuery(text, position, {manual = false, records = []} = {}) {
+    const context = retentionLineContext(text, position);
+    if (!context) return null;
+    const before = text.slice(context.lineStart, position);
+    const match = before.match(/^(.*:\s*)([A-Za-z_]*)$/);
+    if (!match || (!manual && !match[2])) return null;
+    const family = retentionReferenceFamily(match[1], records);
+    if (!family) return null;
+    const markers = family === "audio"
+        ? H3_AUDIO_RETENTION_MARKERS : H3_VISUAL_RETENTION_MARKERS;
+    const completeMarker = new RegExp(`:\\s*(?:${markers.join("|")})\\b`, "i");
+    if (completeMarker.test(context.line)) return null;
+    const typed = match[2];
+    return {trigger:`retention_${family}`,
+        start:position - typed.length, end:position, typed, query:typed, manual};
+}
+
+export function promptRetentionReplacementQuery(value, caret, records = []) {
+    // Retention markers deliberately remain ordinary text in the editor. Only
+    // a modifier-click in their canonical line position activates this query.
+    const text = String(value ?? "");
+    const position = clampedCaret(text, caret);
+    const context = retentionLineContext(text, position);
+    if (!context) return null;
+    const {lineStart, line} = context;
+    const markers = [...new Set([
+        ...H3_VISUAL_RETENTION_MARKERS,
+        ...H3_AUDIO_RETENTION_MARKERS,
+    ])];
+    const pattern = new RegExp(`\\b(${markers.join("|")})\\b`, "gi");
+    for (const match of line.matchAll(pattern)) {
+        const start = lineStart + (match.index ?? 0);
+        const end = start + match[0].length;
+        if (position < start || position > end) continue;
+        const before = line.slice(0, match.index ?? 0);
+        const family = retentionReferenceFamily(before, records);
+        if (!family) return null;
+        const allowed = family === "audio"
+            ? H3_AUDIO_RETENTION_MARKERS : H3_VISUAL_RETENTION_MARKERS;
+        const canonical = allowed.find((item) => item === match[0].toLowerCase());
+        if (!canonical) return null;
+        return {trigger:`retention_${family}`, start, end, typed:match[0], query:"",
+            manual:false, replacement:true};
+    }
+    return null;
+}
+
+/**
+ * Return the incomplete H3 construct immediately before the caret.
+ *
+ * A normal word only opens completion when it starts a line and matches an
+ * H3 section prefix. Ctrl/Cmd+Space can request the complete catalog anywhere
+ * without consuming surrounding text.
+ */
+export function promptCompletionQuery(value, caret, {manual = false, tokenReplacement = true, records = []} = {}) {
+    const text = String(value ?? "");
+    const position = clampedCaret(text, caret);
+    const before = text.slice(0, position);
+    const completed = completedAngleQuery(text, position);
+    if (completed) return tokenReplacement ? completed : null;
+    const queries = [
+        ["@", /(?:^|[^A-Za-z0-9_])(@[A-Za-z0-9_-]*)$/],
+        ["#", /(?:^|[^A-Za-z0-9_])(#[A-Za-z0-9_-]*)$/],
+        ["<", /(<[^>\n]{0,64})$/],
+        ["[", /(\[[^\]\n]{0,96})$/],
+        ["(", /(\(S[0-9,]*)$/i],
+    ];
+    for (const [trigger, pattern] of queries) {
+        const result = specialQuery(before, trigger, pattern);
+        if (result) return result;
+    }
+
+    const retention = promptRetentionInsertionQuery(text, position, {manual, records});
+    if (retention) return retention;
+    const timestamp = promptTimestampQuery(text, position, {manual});
+    if (timestamp) return timestamp;
+
+    const section = before.match(/(?:^|\n)([A-Za-z_][A-Za-z_]*)$/);
+    if (section) {
+        const typed = section[1];
+        const lowered = typed.toLowerCase();
+        if (H3_PROMPT_SECTIONS.some((item) => item.toLowerCase().startsWith(lowered))) {
+            return {
+                trigger: "section",
+                start: position - typed.length,
+                end: position,
+                typed,
+                query: typed,
+                manual: false,
+            };
+        }
+    }
+
+    if (!manual) return null;
+    return {
+        trigger: "manual",
+        start: position,
+        end: position,
+        typed: "",
+        query: "",
+        manual: true,
+    };
+}
+
+function normalizedSearch(value) {
+    return String(value ?? "").toLowerCase().replace(/^[#@<\[(]/, "")
+        .replace(/\|?[>\])]$/, "").replace(/[|_+:-]+/g, " ")
+        .replace(/\s+/g, " ").trim();
+}
+
+function matchScore(item, query) {
+    const wanted = normalizedSearch(query);
+    if (!wanted) return 0;
+    const candidate = normalizedSearch(item.filterText ?? item.label);
+    if (candidate === wanted) return 0;
+    if (candidate.startsWith(wanted)) return 1;
+    const word = candidate.split(" ").findIndex((part) => part.startsWith(wanted));
+    if (word >= 0) return 3 + word;
+    const contained = candidate.indexOf(wanted);
+    return contained >= 0 ? 20 + contained : null;
+}
+
+function uniqueItems(items) {
+    const seen = new Set();
+    return items.filter((item) => {
+        const key = `${item.kind}:${item.insertText}`;
+        if (seen.has(key)) return false;
+        seen.add(key);
+        return true;
+    });
+}
+
+function referenceItems(records, referenceMode, trigger) {
+    const items = [];
+    for (const record of records ?? []) {
+        const token = String(record?.token ?? "");
+        if (trigger === "@") {
+            const nativeToken = record?.nativeToken === null
+                ? "" : String(record?.nativeToken ?? token);
+            if (!nativeToken.startsWith("@")) continue;
+            if (!record.active && referenceMode !== "tagged") continue;
+            const mapping = record.label && record.label !== nativeToken
+                ? ` → ${record.label}` : "";
+            items.push({
+                id: `alias:${nativeToken}`,
+                kind: record.kind || "reference",
+                label: nativeToken,
+                insertText: nativeToken,
+                filterText: nativeToken,
+                detail: `${record.active ? "Active" : "Insert to activate"} ${record.kind || "reference"}${mapping}`,
+                priority: record.active ? 0 : 1,
+            });
+        } else if (trigger === "#") {
+            if (referenceMode !== "tagged" || record.kind !== "picture") continue;
+            const tag = String(record?.tag ?? (
+                token.startsWith("@") ? token.slice(1)
+                    : token.startsWith("#") ? token.slice(1).split("[")[0] : ""
+            )).trim();
+            const semanticCapable = Boolean(
+                record?.supportsSemantic || record?.semanticOnly
+                || record?.semanticToken || token.startsWith("@"),
+            );
+            if (!tag || !semanticCapable) continue;
+            const anchor = `#${tag}`;
+            items.push({
+                id: `semantic:${tag}`,
+                kind: "semantic",
+                label: anchor,
+                insertText: anchor,
+                filterText: tag,
+                detail: record?.semanticOnly
+                    ? "Semantic Picture Anchor · untimed Qwen-only visual; add [time] for placement"
+                    : "Tagged Picture · untimed Qwen-only visual; add [time] for placement",
+                priority: record.active ? 0 : 1,
+            });
+        }
+    }
+    return items;
+}
+
+function nativeLabelItems(records, referenceMode) {
+    const items = [];
+    for (const record of records ?? []) {
+        if (!record?.active) continue;
+        const label = String(record.label ?? record.token ?? "");
+        if (!/^<(?:Picture|Video|Audio)\s+\d+>$/i.test(label)) continue;
+        const alias = String(record.token ?? "");
+        const compiledAlias = alias.startsWith("@")
+            ? ` · current compiled label for ${alias}; keep the alias in the prompt`
+            : "";
+        items.push({
+            id: `native:${label}`,
+            kind: record.kind || "reference",
+            label,
+            insertText: label,
+            appendSpace: true,
+            filterText: label,
+            detail: `Available ${record.kind || "reference"}${compiledAlias}`,
+            priority: referenceMode === "native" || referenceMode === "native_keyframes" ? 0 : 2,
+        });
+    }
+    for (let index = 1; index <= 8; index += 1) {
+        const label = `<Subject ${index}>`;
+        items.push({
+            id: `subject:${index}`,
+            kind: "subject",
+            label,
+            insertText: label,
+            filterText: label,
+            appendSpace: true,
+            detail: "H3 reusable subject label",
+            priority: 10 + index,
+        });
+    }
+    items.push(
+        {kind:"dialogue", label:"<d>…</d>", insertText:`${DIALOGUE_START}${DIALOGUE_END}`, filterText:"d dialogue", detail:"H3 dialogue or lyric span", caretOffset:DIALOGUE_START.length, priority:60},
+        {kind:"flow", label:"<scenetrans>", insertText:"<scenetrans>", detail:"Dialogue continues across a shot transition", priority:61},
+        {kind:"flow", label:CUTOFF_TOKEN, insertText:CUTOFF_TOKEN, filterText:"cutoff speech end", detail:"Tokenizer-native speech cutoff marker", priority:62},
+        {kind:"dialogue", label:DIALOGUE_START, insertText:DIALOGUE_START, filterText:"d open dialogue", detail:"Open an H3 dialogue span", priority:63},
+        {kind:"dialogue", label:DIALOGUE_END, insertText:DIALOGUE_END, filterText:"/d close dialogue", detail:"Close an H3 dialogue span", priority:64},
+        {kind:"lyrics", label:`${LYRICS_START}…${LYRICS_END}`,
+            insertText:`${LYRICS_START}${LYRICS_END}`,
+            filterText:"lyrics lyric song pair", detail:"Paired MiniMax lyric boundaries",
+            caretOffset:LYRICS_START.length, priority:65},
+        {kind:"lyrics", label:LYRICS_START, insertText:LYRICS_START,
+            filterText:"lyrics start", detail:"Open a MiniMax lyric boundary", priority:66},
+        {kind:"lyrics", label:LYRICS_END, insertText:LYRICS_END,
+            filterText:"lyrics end", detail:"Close a MiniMax lyric boundary", priority:67},
+        {kind:"caption", label:`${CAPTION_START}…${CAPTION_END}`,
+            insertText:`${CAPTION_START}${CAPTION_END}`,
+            filterText:"caption description pair", detail:"Paired MiniMax caption boundaries",
+            caretOffset:CAPTION_START.length, priority:68},
+        {kind:"caption", label:CAPTION_START, insertText:CAPTION_START,
+            filterText:"caption start", detail:"Open a MiniMax caption boundary", priority:69},
+        {kind:"caption", label:CAPTION_END, insertText:CAPTION_END,
+            filterText:"caption end", detail:"Close a MiniMax caption boundary", priority:70},
+    );
+    return items;
+}
+
+function speakerItems() {
+    const items = Array.from({length:8}, (_, index) => {
+        const label = `(S${index + 1})`;
+        return {
+            id:`speaker:${index + 1}`,
+            kind:"speaker",
+            label,
+            insertText:label,
+            filterText:label,
+            detail:"H3 dialogue speaker marker",
+            priority:index,
+        };
+    });
+    items.push({
+        id:"speaker:pair",
+        kind:"speaker",
+        label:"(S1,S2)",
+        insertText:"(S1,S2)",
+        filterText:"S1 S2 multiple speakers",
+        detail:"H3 simultaneous-speaker marker",
+        priority:9,
+    });
+    return items;
+}
+
+function bracketItems() {
+    return H3_BRACKET_DIRECTIVES.map((directive, index) => ({
+        id: `directive:${directive}`,
+        kind: directive.startsWith("[Shot ") ? "shot"
+            : H3_LANGUAGE_MARKERS.includes(directive)
+              ? "language" : "directive",
+        label: directive,
+        insertText: directive,
+        filterText: directive,
+        detail: directive.startsWith("[Shot ")
+            ? "H3 shot marker" : H3_LANGUAGE_MARKERS.includes(directive)
+              ? "Dialogue language marker" : "H3 summary intent",
+        priority: index,
+    }));
+}
+
+const RETENTION_DETAILS = Object.freeze({
+    fully_preserved:"Preserve the defined visual role completely",
+    partially_preserved:"Retain the reference with defined changes",
+    attribute_transfer:"Transfer referenced traits to another subject",
+    fully_copy:"Reuse the complete source audio signal",
+    partially_copy:"Reuse only part of the signal or its layers",
+    reference:"Guide audio without copying the source signal",
+    weak_reference:"Retain only broad similarity or atmosphere",
+});
+
+function retentionItems(family) {
+    const markers = family === "audio"
+        ? H3_AUDIO_RETENTION_MARKERS : H3_VISUAL_RETENTION_MARKERS;
+    return markers.map((label, index) => ({
+        kind:"retention", label, insertText:label,
+        appendText:" - ", normalizeColon:true,
+        detail:RETENTION_DETAILS[label], priority:index,
+    }));
+}
+
+function timestampItems() {
+    return [{
+        kind:"timestamp",
+        label:"At MM:SS.mmm,",
+        insertText:"At 00:00.000, ",
+        selectionStartOffset:6,
+        selectionEndOffset:12,
+        detail:"H3 millisecond timestamp; type over the selected SS.mmm value",
+        priority:0,
+    }];
+}
+
+function sectionItems(text = "", mode = "auto") {
+    const sections = h3SectionsForMode(effectiveH3Mode(text, mode));
+    return sections.map((name, index) => {
+        const section = `${name}:`;
+        return {
+            id: `section:${section}`,
+            kind: "section",
+            label: section,
+            insertText: section,
+            filterText: section,
+            detail: `Required ${effectiveH3Mode(text, mode).toUpperCase()} section`,
+            priority: index,
+        };
+    });
+}
+
+/** Return filtered, ranked completion items for a detected query. */
+export function promptCompletionItems(query, records = [], {
+    referenceMode = null,
+    text = "",
+    mode = "auto",
+    limit = 40,
+} = {}) {
+    if (!query) return [];
+    let items;
+    if (query.trigger === "@" || query.trigger === "#") {
+        items = referenceItems(records, referenceMode, query.trigger);
+    } else if (query.trigger === "<") {
+        items = nativeLabelItems(records, referenceMode);
+    } else if (query.trigger === "[") {
+        items = bracketItems();
+    } else if (["shot", "language", "directive"].includes(query.trigger)) {
+        items = bracketItems().filter((item) => item.kind === query.trigger);
+    } else if (query.trigger === "retention_visual" || query.trigger === "retention_audio") {
+        items = retentionItems(query.trigger.slice("retention_".length));
+    } else if (query.trigger === "timestamp") {
+        items = timestampItems();
+    } else if (query.trigger === "(") {
+        items = speakerItems();
+    } else if (query.trigger === "section") {
+        items = sectionItems(text, mode);
+    } else {
+        items = [
+            ...referenceItems(records, referenceMode, "@"),
+            ...nativeLabelItems(records, referenceMode),
+            ...bracketItems(),
+            ...speakerItems(),
+            ...sectionItems(text, mode),
+        ];
+        if (referenceMode === "tagged") {
+            items.push(...referenceItems(records, referenceMode, "#"));
+        }
+    }
+
+    // A replacement must not insert a paired snippet around an existing opener.
+    if (query.replacement) items = items.filter((item) => item.caretOffset == null);
+    const result = uniqueItems(items).map((item) => ({
+        item,
+        score: matchScore(item, query.query),
+    })).filter(({score}) => score != null)
+        .sort((left, right) => left.score - right.score
+            || (left.item.priority ?? 0) - (right.item.priority ?? 0)
+            || left.item.label.localeCompare(right.item.label))
+        .slice(0, Math.max(1, Number(limit) || 40))
+        .map(({item}) => item);
+    if (query.allowDelete) result.push({
+        kind:"delete", label:`Delete ${query.typed}`, insertText:"",
+        detail:"Remove this token", deleteToken:true,
+    });
+    return result;
+}
+
+/** Replace the typed completion prefix with the selected item. */
+export function applyPromptCompletion(value, query, item, {appendSpace = false} = {}) {
+    const text = String(value ?? "");
+    if (!query || !item) return {text, caret:text.length};
+    const start = Math.max(0, Math.min(text.length, Number(query.start) || 0));
+    const end = Math.max(start, Math.min(text.length, Number(query.end) || start));
+    const insertText = String(item.insertText ?? item.label ?? "");
+    let before = text.slice(0, start);
+    let after = text.slice(end);
+    if (item.normalizeColon && !query.replacement) {
+        before = before.replace(/[ \t]*:[ \t]*$/, ": ");
+    }
+    if (item.deleteToken) {
+        after = after.replace(/^[ \t]+/, (spacing) => /[ \t]$/.test(before) ? "" : " ");
+    }
+    const appendText = query.replacement ? "" : String(item.appendText ?? "");
+    const hasAppendedText = appendText && after.startsWith(appendText);
+    const addedText = appendText && !hasAppendedText ? appendText : "";
+    const existingText = hasAppendedText ? appendText.length : 0;
+    if (addedText) after = after.replace(/^[ \t]+/, "");
+    const wantsSpace = Boolean(appendSpace && !appendText && item.appendSpace && !query.replacement);
+    const addedSpace = wantsSpace && !/^\s/.test(after) ? " " : "";
+    const existingSpace = wantsSpace && /^[ \t]/.test(after) ? 1 : 0;
+    const result = before + insertText + addedText + addedSpace + after;
+    const relative = item.caretOffset == null ? insertText.length
+        : Math.max(0, Math.min(insertText.length, Number(item.caretOffset) || 0));
+    const spacingOffset = relative === insertText.length
+        ? addedText.length + existingText + addedSpace.length + existingSpace : 0;
+    const completion = {text:result, caret:before.length + relative + spacingOffset};
+    const startOffset = item.selectionStart ?? item.selectionStartOffset;
+    const endOffset = item.selectionEnd ?? item.selectionEndOffset;
+    if (startOffset != null && endOffset != null) {
+        const selectionStart = Math.max(0, Math.min(
+            insertText.length, Number(startOffset) || 0,
+        ));
+        const selectionEnd = Math.max(selectionStart, Math.min(
+            insertText.length, Number(endOffset) || 0,
+        ));
+        completion.selectionStart = before.length + selectionStart;
+        completion.selectionEnd = before.length + selectionEnd;
+        completion.caret = completion.selectionEnd;
+    }
+    return completion;
+}
+
+function completionStyles() {
+    if (document.getElementById("h3-prompt-completion-style")) return;
+    const style = document.createElement("style");
+    style.id = "h3-prompt-completion-style";
+    style.textContent = `
+      .h3pc-menu { position:fixed; z-index:100200; width:min(440px,calc(100vw - 24px));
+        max-height:min(300px,45vh); overflow:auto; padding:5px; border:1px solid #60718c;
+        border-radius:8px; background:var(--comfy-menu-bg,#171a20); color:var(--input-text,#eef2f8);
+        box-shadow:0 16px 42px rgba(0,0,0,.52); font:12px/1.35 system-ui,sans-serif; }
+      .h3pc-menu[hidden] { display:none; }
+      .h3pc-option { display:grid; grid-template-columns:auto minmax(0,1fr); gap:2px 8px;
+        align-items:center; padding:6px 7px; border-radius:5px; cursor:pointer; }
+      .h3pc-option[aria-selected="true"] { background:color-mix(in srgb,#5e8fff 24%,transparent); }
+      .h3pc-option-delete { color:var(--error-text,#da6464); }
+      .h3pc-kind { grid-row:1/3; min-width:26px; padding:2px 4px; border:1px solid #65738a;
+        border-radius:4px; color:color-mix(in srgb,var(--input-text,#eef2f8) 72%,transparent);
+        text-align:center; font-size:9px; font-weight:750; text-transform:uppercase; }
+      .h3pc-label { min-width:0; overflow:hidden; text-overflow:ellipsis; white-space:nowrap;
+        font:600 12px/1.3 ui-monospace,SFMono-Regular,Consolas,monospace; }
+      .h3pc-detail { min-width:0; overflow:hidden; text-overflow:ellipsis; white-space:nowrap;
+        color:color-mix(in srgb,var(--input-text,#eef2f8) 58%,transparent); font-size:10px; }
+      .h3pc-empty { padding:8px; color:color-mix(in srgb,var(--input-text,#eef2f8) 58%,transparent); }
+    `;
+    document.head.append(style);
+}
+
+function caretAnchor(input) {
+    if (input?.isContentEditable) {
+        const selection = globalThis.getSelection?.();
+        if (selection?.rangeCount && input.contains(selection.anchorNode)) {
+            const range = selection.getRangeAt(0).cloneRange();
+            range.collapse(true);
+            const rect = range.getBoundingClientRect();
+            if (rect && (rect.width || rect.height || rect.left || rect.top)) return rect;
+        }
+    }
+    return input?.getBoundingClientRect?.() ?? {left:12, bottom:40, top:12};
+}
+
+/**
+ * Attach the browser completion popup to either a textarea or contenteditable.
+ * The editor owns text persistence; replaceText receives the pure replacement
+ * result so both prompt editors can keep their existing Plan/undo behavior.
+ */
+export function createPromptCompletionController({
+    input,
+    getText,
+    getCaret,
+    getRecords = () => [],
+    getReferenceMode = () => null,
+    getMode = () => "auto",
+    getAutomaticSuggestions = () => true,
+    getAppendCompletionSpace = () => false,
+    getMarkerReplacement = () => true,
+    replaceText,
+    maxItems = 12,
+} = {}) {
+    if (!input || typeof replaceText !== "function") return null;
+    completionStyles();
+    const menu = document.createElement("div");
+    const menuId = `h3pc-${Math.random().toString(36).slice(2)}`;
+    menu.id = menuId;
+    menu.className = "h3pc-menu";
+    menu.setAttribute("role", "listbox");
+    menu.hidden = true;
+    menu.addEventListener("pointerdown", (event) => event.stopPropagation());
+    menu.addEventListener("click", (event) => event.stopPropagation());
+    menu.addEventListener("wheel", (event) => event.stopPropagation());
+    document.body.append(menu);
+    input.setAttribute("aria-autocomplete", "list");
+    input.setAttribute("aria-controls", menuId);
+    input.setAttribute("aria-expanded", "false");
+
+    let currentQuery = null;
+    let currentItems = [];
+    let selected = 0;
+    let composing = false;
+    const editable = () => !composing && !input.disabled && !input.readOnly
+        && input.getAttribute?.("contenteditable") !== "false";
+
+    function hide() {
+        currentQuery = null;
+        currentItems = [];
+        selected = 0;
+        menu.hidden = true;
+        input.setAttribute("aria-expanded", "false");
+        input.removeAttribute("aria-activedescendant");
+    }
+
+    function position() {
+        const anchor = caretAnchor(input);
+        const width = Math.min(440, Math.max(240, globalThis.innerWidth - 24));
+        const left = Math.max(12, Math.min(globalThis.innerWidth - width - 12, anchor.left ?? 12));
+        menu.style.left = `${left}px`;
+        const below = (anchor.bottom ?? anchor.top ?? 12) + 6;
+        const roomBelow = globalThis.innerHeight - below - 12;
+        if (roomBelow >= Math.min(180, menu.offsetHeight || 180)) {
+            menu.style.top = `${below}px`;
+        } else {
+            menu.style.top = `${Math.max(12, (anchor.top ?? below) - menu.offsetHeight - 6)}px`;
+        }
+    }
+
+    function updateActiveOption() {
+        const options = [...menu.querySelectorAll(".h3pc-option")];
+        options.forEach((option, index) => option.setAttribute(
+            "aria-selected", String(index === selected)));
+        const active = options[selected];
+        if (active) {
+            input.setAttribute("aria-activedescendant", active.id);
+            active.scrollIntoView?.({block:"nearest"});
+        } else {
+            input.removeAttribute("aria-activedescendant");
+        }
+    }
+
+    function render() {
+        menu.replaceChildren();
+        currentItems.forEach((item, index) => {
+            const option = document.createElement("div");
+            option.id = `${menuId}-option-${index}`;
+            option.className = `h3pc-option${item.kind === "delete" ? " h3pc-option-delete" : ""}`;
+            option.setAttribute("role", "option");
+            option.setAttribute("aria-selected", String(index === selected));
+            const kind = document.createElement("span");
+            kind.className = "h3pc-kind";
+            kind.textContent = String(item.kind || "H3").slice(0, 3);
+            const label = document.createElement("span");
+            label.className = "h3pc-label";
+            label.textContent = item.label;
+            const detail = document.createElement("span");
+            detail.className = "h3pc-detail";
+            detail.textContent = item.detail || "H3 prompt completion";
+            option.append(kind, label, detail);
+            option.addEventListener("pointerdown", (event) => event.preventDefault());
+            option.addEventListener("mouseenter", () => {
+                selected = index;
+                updateActiveOption();
+            });
+            option.addEventListener("click", () => accept(index));
+            menu.append(option);
+        });
+        updateActiveOption();
+        menu.hidden = false;
+        input.setAttribute("aria-expanded", "true");
+        position();
+    }
+
+    function show(nextQuery, {selectCurrent = false} = {}) {
+        if (!editable()) { hide(); return false; }
+        const text = String(getText?.() ?? "");
+        const previousIdentity = currentQuery
+            ? `${currentQuery.trigger}:${currentQuery.start}:${currentQuery.typed}` : "";
+        const nextIdentity = nextQuery
+            ? `${nextQuery.trigger}:${nextQuery.start}:${nextQuery.typed}` : "";
+        if (previousIdentity !== nextIdentity) selected = 0;
+        currentQuery = nextQuery;
+        currentItems = promptCompletionItems(currentQuery, getRecords(), {
+            referenceMode: getReferenceMode(),
+            text,
+            mode:getMode(),
+            limit: maxItems,
+        });
+        if (selectCurrent) {
+            const index = currentItems.findIndex((item) => item.insertText === nextQuery?.typed);
+            selected = Math.max(0, index);
+        }
+        selected = Math.min(selected, Math.max(0, currentItems.length - 1));
+        if (!currentQuery || !currentItems.length) hide();
+        else render();
+        return !menu.hidden;
+    }
+
+    function refresh({manual = false} = {}) {
+        if (!manual && !getAutomaticSuggestions()) { hide(); return false; }
+        return show(promptCompletionQuery(getText?.(), getCaret?.(), {
+            manual, tokenReplacement:getMarkerReplacement(), records:getRecords(),
+        }));
+    }
+
+    function open(query) {
+        if (!getMarkerReplacement()) return false;
+        return show(query, {selectCurrent:true});
+    }
+
+    function accept(index = selected) {
+        if (!editable()) { hide(); return false; }
+        const item = currentItems[index];
+        if (!item || !currentQuery) return false;
+        if (currentQuery.replacement && String(getText?.() ?? "").slice(
+            currentQuery.start, currentQuery.end) !== currentQuery.typed) {
+            hide();
+            return false;
+        }
+        const result = applyPromptCompletion(getText?.(), currentQuery, item, {
+            appendSpace:getAppendCompletionSpace(),
+        });
+        replaceText(result, item);
+        hide();
+        input.focus();
+        return true;
+    }
+
+    function move(delta) {
+        if (!currentItems.length) return;
+        selected = (selected + delta + currentItems.length) % currentItems.length;
+        updateActiveOption();
+    }
+
+    function handleKeydown(event) {
+        if (event.isComposing || !editable()) return false;
+        if ((event.ctrlKey || event.metaKey) && !event.altKey
+                && (event.code === "Space" || event.key === " ")) {
+            event.preventDefault();
+            refresh({manual:true});
+            return true;
+        }
+        if (menu.hidden) return false;
+        if (event.key === "ArrowDown") {
+            event.preventDefault(); move(1); return true;
+        }
+        if (event.key === "ArrowUp") {
+            event.preventDefault(); move(-1); return true;
+        }
+        if (event.key === "Enter" || event.key === "Tab") {
+            event.preventDefault(); return accept();
+        }
+        if (event.key === "Escape") {
+            event.preventDefault(); hide(); return true;
+        }
+        return false;
+    }
+
+    const onBlur = () => globalThis.setTimeout?.(() => {
+        if (!menu.matches(":hover")) hide();
+    }, 100);
+    // Ordinary clicks only move the caret; explicit marker interactions open
+    // replacement after this dismissal (never complete a mid-word prefix).
+    const onClick = () => hide();
+    const onKeyup = (event) => {
+        if (["ArrowLeft", "ArrowRight", "Home", "End"].includes(event.key)) refresh();
+    };
+    const onResize = () => { if (!menu.hidden) position(); };
+    const onSettingsChanged = () => hide();
+    const onCompositionStart = () => { composing = true; hide(); };
+    const onCompositionEnd = () => { composing = false; refresh(); };
+    input.addEventListener("blur", onBlur);
+    input.addEventListener("click", onClick);
+    input.addEventListener("keyup", onKeyup);
+    input.addEventListener("compositionstart", onCompositionStart);
+    input.addEventListener("compositionend", onCompositionEnd);
+    globalThis.addEventListener?.("resize", onResize);
+    globalThis.addEventListener?.("scroll", onResize, true);
+    globalThis.addEventListener?.("h3-prompt-editor-settings-changed", onSettingsChanged);
+
+    return {
+        refresh,
+        open,
+        hide,
+        accept,
+        handleKeydown,
+        get visible() { return !menu.hidden; },
+        destroy() {
+            hide();
+            input.removeEventListener("blur", onBlur);
+            input.removeEventListener("click", onClick);
+            input.removeEventListener("keyup", onKeyup);
+            input.removeEventListener("compositionstart", onCompositionStart);
+            input.removeEventListener("compositionend", onCompositionEnd);
+            globalThis.removeEventListener?.("resize", onResize);
+            globalThis.removeEventListener?.("scroll", onResize, true);
+            globalThis.removeEventListener?.("h3-prompt-editor-settings-changed", onSettingsChanged);
+            input.removeAttribute("aria-autocomplete");
+            input.removeAttribute("aria-controls");
+            input.removeAttribute("aria-expanded");
+            input.removeAttribute("aria-activedescendant");
+            menu.remove();
+        },
+    };
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_editor_settings.js b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_editor_settings.js
new file mode 100644
index 0000000000000000000000000000000000000000..97c92b39744d99bc6c6f0f6fdf01c54987dca9ba
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_editor_settings.js
@@ -0,0 +1,24 @@
+import {app} from "/scripts/app.js";
+import {
+    H3_PROMPT_EDITOR_SETTING_DEFINITIONS,
+    h3PromptEditorPreferences,
+} from "./h3_prompt_editor_settings_core.mjs?v=0.6.5";
+
+export function promptEditorPreferences() {
+    return h3PromptEditorPreferences((id, fallback) =>
+        app.ui?.settings?.getSettingValue?.(id) ?? fallback);
+}
+
+app.registerExtension({
+    name:"minimax_h3_context_loop.prompt_editor_settings",
+    init() {
+        for (const definition of H3_PROMPT_EDITOR_SETTING_DEFINITIONS) {
+            app.ui?.settings?.addSetting?.({
+                ...definition,
+                onChange() {
+                    globalThis.dispatchEvent?.(new CustomEvent("h3-prompt-editor-settings-changed"));
+                },
+            });
+        }
+    },
+});
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_editor_settings_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_editor_settings_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..172b2c18348e12f97768c5ba47cf2fda1607d2ab
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_editor_settings_core.mjs
@@ -0,0 +1,79 @@
+export const H3_PROMPT_EDITOR_SETTING_IDS = Object.freeze({
+    defaultPresentation:"MiniMaxH3ContextLoop.PromptEditor.Editor.DefaultPresentation",
+    automaticSuggestions:"MiniMaxH3ContextLoop.PromptEditor.Completion.AutomaticSuggestions",
+    appendCompletionSpace:"MiniMaxH3ContextLoop.PromptEditor.Completion.AppendSpace",
+    markerReplacement:"MiniMaxH3ContextLoop.PromptEditor.Interaction.MarkerReplacement",
+});
+
+export const H3_PROMPT_EDITOR_SETTING_DEFINITIONS = Object.freeze([
+    Object.freeze({
+        id:H3_PROMPT_EDITOR_SETTING_IDS.defaultPresentation,
+        category:["MiniMax H3 Context Loop", "Prompt editor", "Default presentation"],
+        name:"Default presentation for new nodes",
+        type:"combo",
+        defaultValue:"rich",
+        options:[
+            {text:"Rich text", value:"rich"},
+            {text:"Plain text", value:"plain"},
+        ],
+        tooltip:"Choose how MiniMax H3 Context Loop nodes without a saved per-node Rich/Plain choice are displayed.",
+    }),
+    Object.freeze({
+        id:H3_PROMPT_EDITOR_SETTING_IDS.automaticSuggestions,
+        category:["MiniMax H3 Context Loop", "Prompt editor", "Automatic suggestions"],
+        name:"Show suggestions while typing",
+        type:"boolean",
+        defaultValue:true,
+        tooltip:"Show contextual completions automatically. Ctrl/Cmd+Space continues to open completions when this is disabled.",
+    }),
+    Object.freeze({
+        id:H3_PROMPT_EDITOR_SETTING_IDS.appendCompletionSpace,
+        category:["MiniMax H3 Context Loop", "Prompt editor", "Trailing space"],
+        name:"Append a space after completed symbols",
+        type:"boolean",
+        defaultValue:false,
+        tooltip:"Insert a trailing space after completing reference labels and other sentence-level H3 symbols.",
+    }),
+    Object.freeze({
+        id:H3_PROMPT_EDITOR_SETTING_IDS.markerReplacement,
+        category:["MiniMax H3 Context Loop", "Prompt editor", "Marker replacement"],
+        name:"Enable marker replacement interactions",
+        type:"boolean",
+        defaultValue:true,
+        tooltip:"Allow new token and Ctrl/Cmd-click marker replacement menus. Existing tagged-reference controls remain available.",
+    }),
+]);
+
+function readValue(readSetting, id, fallback) {
+    const value = typeof readSetting === "function" ? readSetting(id, fallback) : undefined;
+    return value == null ? fallback : value;
+}
+
+export function h3PromptEditorPreferences(readSetting) {
+    const presentation = String(readValue(
+        readSetting, H3_PROMPT_EDITOR_SETTING_IDS.defaultPresentation, "rich",
+    )).toLowerCase();
+    return {
+        defaultRichText:presentation !== "plain",
+        automaticSuggestions:readValue(
+            readSetting, H3_PROMPT_EDITOR_SETTING_IDS.automaticSuggestions, true,
+        ) !== false,
+        appendCompletionSpace:readValue(
+            readSetting, H3_PROMPT_EDITOR_SETTING_IDS.appendCompletionSpace, false,
+        ) !== false,
+        markerReplacement:readValue(
+            readSetting, H3_PROMPT_EDITOR_SETTING_IDS.markerReplacement, true,
+        ) !== false,
+    };
+}
+
+/** Saved per-node choices win; the global setting only supplies a default. */
+export function promptEditorRichText(properties, key, preferences) {
+    return Object.hasOwn(properties ?? {}, key)
+        ? properties[key] !== false : preferences.defaultRichText;
+}
+
+export function isWorkflowSaveShortcut(event) {
+    return Boolean((event?.ctrlKey || event?.metaKey) && !event.altKey
+        && !event.shiftKey && String(event.key ?? "").toLowerCase() === "s");
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_history_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_history_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..92cefa471f1b29be302838ede24e4b1c9f6762f1
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_history_core.mjs
@@ -0,0 +1,142 @@
+function chronologicalPromptRevisions(history) {
+    return [...(history?.revisions ?? [])].sort((left, right) => {
+        const time = String(left.created_at ?? "").localeCompare(
+            String(right.created_at ?? ""),
+        );
+        return time || String(left.id ?? "").localeCompare(String(right.id ?? ""));
+    });
+}
+
+export function promptRevisionTree(history, {includeArchived = false} = {}) {
+    const revisions = chronologicalPromptRevisions(history);
+    const byId = new Map(revisions.map((revision) => [revision.id, revision]));
+    const children = new Map(revisions.map((revision) => [revision.id, []]));
+    const roots = [];
+    for (const revision of revisions) {
+        if (revision.parent_id && byId.has(revision.parent_id)) {
+            children.get(revision.parent_id).push(revision);
+        } else {
+            roots.push(revision);
+        }
+    }
+
+    const activeRevision = String(history?.active_revision ?? "");
+    const rows = [];
+    const visited = new Set();
+    const visit = (revision, depth) => {
+        if (!revision || visited.has(revision.id)) return;
+        visited.add(revision.id);
+        const isArchived = Boolean(revision.archived_at);
+        const visible = includeArchived || !isArchived;
+        const childRevisions = children.get(revision.id) ?? [];
+        if (visible) {
+            rows.push({
+                revision,
+                depth,
+                isActive: revision.id === activeRevision,
+                isExecuted: Boolean(revision.executed_at),
+                isArchived,
+                hasDescendants: childRevisions.length > 0,
+                canDelete: revision.id !== activeRevision
+                    && !revision.executed_at
+                    && childRevisions.length === 0,
+                canArchive: revision.id !== activeRevision && !isArchived,
+                canRestore: isArchived,
+            });
+        }
+        for (const child of childRevisions) {
+            visit(child, depth + (visible ? 1 : 0));
+        }
+    };
+    for (const root of roots) visit(root, 0);
+    // Corrupt/cyclic ancestry should not make history disappear from the UI.
+    for (const revision of revisions) visit(revision, 0);
+    rows.forEach((row, index) => {
+        row.position = index + 1;
+        row.displayLabel = String(row.revision.label ?? "").trim()
+            || `Revision ${row.position}`;
+    });
+    return {
+        rows,
+        revisions: rows.map((row) => row.revision),
+        archivedCount: revisions.filter((revision) => revision.archived_at).length,
+    };
+}
+
+export function orderedPromptRevisions(history, options = {}) {
+    return promptRevisionTree(history, options).revisions;
+}
+
+export function promptRevisionNavigation(history, revisionId = null) {
+    const requested = String(revisionId ?? history?.active_revision ?? "");
+    const requestedRevision = (history?.revisions ?? []).find(
+        (item) => item.id === requested,
+    );
+    const revisions = orderedPromptRevisions(history, {
+        includeArchived: Boolean(requestedRevision?.archived_at),
+    });
+    let index = revisions.findIndex((item) => item.id === requested);
+    if (index < 0 && revisions.length) index = revisions.length - 1;
+    const revision = index < 0 ? null : revisions[index];
+    const parentIndex = revision?.parent_id == null
+        ? -1 : revisions.findIndex((item) => item.id === revision.parent_id);
+    const activeRevision = String(history?.active_revision ?? "");
+    const latestExecutedRevision = String(
+        history?.latest_executed_revision
+        ?? [...revisions].filter((item) => item.executed_at).sort((left, right) =>
+            String(left.last_executed_at ?? left.executed_at ?? "").localeCompare(
+                String(right.last_executed_at ?? right.executed_at ?? ""),
+            )).at(-1)?.id
+        ?? "",
+    );
+    return {
+        revisions,
+        revision,
+        index,
+        position: index < 0 ? 0 : index + 1,
+        total: revisions.length,
+        previous: index > 0 ? revisions[index - 1] : null,
+        next: index >= 0 && index < revisions.length - 1 ? revisions[index + 1] : null,
+        parentPosition: parentIndex < 0 ? null : parentIndex + 1,
+        activeRevision,
+        latestExecutedRevision,
+        isActive: Boolean(revision && revision.id === activeRevision),
+        isExecuted: Boolean(revision?.executed_at),
+        isImmutable: Boolean(revision?.executed_at),
+        isLatestExecuted: Boolean(
+            revision && revision.id === latestExecutedRevision),
+    };
+}
+
+export function promptRevisionLabel(navigation, locale = undefined) {
+    const revision = navigation?.revision;
+    if (!revision) return "No saved versions";
+    const timestamp = revision.executed_at ?? revision.updated_at ?? revision.created_at;
+    const date = timestamp ? new Date(timestamp) : null;
+    const time = date && Number.isFinite(date.getTime())
+        ? date.toLocaleString(locale, {dateStyle: "medium", timeStyle: "short"})
+        : "Unknown time";
+    const state = navigation.isActive
+        ? (navigation.isExecuted ? "Active executed" : "Active draft")
+        : (navigation.isExecuted ? "Executed history" : "Draft history");
+    const customLabel = String(revision.label ?? "").trim();
+    const namedState = customLabel ? `${customLabel} · ${state}` : state;
+    const branch = navigation.parentPosition == null
+        ? "" : ` · branched from ${navigation.parentPosition}`;
+    const repeats = Number(revision.execution_count) > 1
+        ? ` · executed ${revision.execution_count}×` : "";
+    return `${namedState} · ${time}${branch}${repeats}`;
+}
+
+export function promptRevisionHelp(navigation) {
+    if (!navigation?.revision) return "No prompt revision exists yet.";
+    if (navigation.isActive && navigation.isImmutable) {
+        return "This executed revision is active in the Plan and immutable. Typing creates a child draft.";
+    }
+    if (navigation.isActive) {
+        return "This draft is active in the Plan. Typing updates this draft until it executes.";
+    }
+    return navigation.isImmutable
+        ? "This is immutable executed history. Activate it to restore it, or archive it to hide it."
+        : "This is an inactive draft. Activate, label, archive, or delete it if it has no descendants.";
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_marker_ui.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_marker_ui.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..536803eba82d2ce304e6dd06b83aaa1e7bbe93f1
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_marker_ui.mjs
@@ -0,0 +1,62 @@
+import {
+    promptBracketReplacementQuery,
+    promptCompletionQuery,
+    promptRetentionReplacementQuery,
+    promptTokenReplacementQuery,
+} from "./h3_prompt_completion_core.mjs?v=0.6.5";
+
+/** Attach only to the current scene's input; never touch Plan or workflow state.
+ * Existing reference chips handle their own clicks before they bubble here.
+ * Read live DOM offsets, not offsets saved when chips were last decorated.
+ */
+export function bindPromptMarkerInteractions({
+    input, completion, getText, getCaret, readFragment, restoreCaret,
+    getEnabled = () => true, getRecords = () => [], beforeOpen = () => {},
+}) {
+    function prefixOffset(node, offset, before = false) {
+        const range = document.createRange();
+        range.selectNodeContents(input);
+        if (before) range.setEndBefore(node);
+        else range.setEnd(node, offset);
+        return readFragment(range.cloneContents()).length;
+    }
+    const onClick = (event) => {
+        if (!getEnabled() || input.disabled || input.readOnly
+                || input.getAttribute("contenteditable") === "false") return;
+        const text = getText();
+        const token = event.target?.closest?.("[data-h3-prompt-marker]");
+        let query = null;
+        if (token && input.contains(token)) {
+            const start = prefixOffset(token, 0, true);
+            query = promptTokenReplacementQuery(text, start,
+                start + String(token.dataset.token ?? "").length);
+        } else if (event.ctrlKey || event.metaKey) {
+            let position = getCaret();
+            if (input.isContentEditable) {
+                const point = document.caretPositionFromPoint?.(event.clientX, event.clientY);
+                const fallback = point ? null : document.caretRangeFromPoint?.(event.clientX, event.clientY);
+                const node = point?.offsetNode ?? fallback?.startContainer;
+                const offset = point?.offset ?? fallback?.startOffset;
+                if (node && offset != null && (node === input || input.contains(node))) {
+                    position = prefixOffset(node, offset);
+                }
+            }
+            query = promptBracketReplacementQuery(text, position)
+                ?? promptRetentionReplacementQuery(text, position, getRecords());
+            if (!query) {
+                const candidate = promptCompletionQuery(text, position);
+                if (candidate?.replacement) query = candidate;
+            }
+        }
+        if (!query) return;
+        event.preventDefault();
+        beforeOpen();
+        restoreCaret(query.end);
+        completion.open(query);
+    };
+    input.addEventListener("click", onClick);
+    const cleanup = () => input.removeEventListener("click", onClick);
+    const destroy = completion.destroy;
+    completion.destroy = () => { cleanup(); destroy(); };
+    return cleanup;
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_optimizer_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_optimizer_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..c3f6f21523b7665999831abc0c2c9b308669eace
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_optimizer_core.mjs
@@ -0,0 +1,37 @@
+export const PROMPT_OPTIMIZER_BACKENDS = Object.freeze(["direct", "mcp", "disabled"]);
+export const PROMPT_OPTIMIZER_API_FORMATS = Object.freeze(["openai", "responses", "gemini"]);
+
+export function normalizePromptOptimizerBackend(value) {
+    const backend = String(value ?? "direct").trim().toLowerCase();
+    return PROMPT_OPTIMIZER_BACKENDS.includes(backend) ? backend : "direct";
+}
+
+export function normalizePromptOptimizerApiFormat(value) {
+    const format = String(value ?? "openai").trim().toLowerCase();
+    return PROMPT_OPTIMIZER_API_FORMATS.includes(format) ? format : "openai";
+}
+
+export function directOptimizerConfigurationError(config = {}) {
+    if (!String(config.api_url ?? "").trim()) return "Direct API URL is not configured.";
+    if (!String(config.model ?? "").trim()) return "Direct API model is not configured.";
+    if (normalizePromptOptimizerApiFormat(config.api_format) === "gemini"
+            && !String(config.api_key ?? "").trim()) {
+        return "Gemini Native requires an API key.";
+    }
+    return "";
+}
+
+export function makeDirectPromptOptimizeRequest({config, instruction, context, resources = []}) {
+    const error = directOptimizerConfigurationError(config);
+    if (error) throw new Error(`${error} Open ComfyUI Settings → MiniMax H3 Context Loop → Prompt optimizer.`);
+    return {
+        api_format: normalizePromptOptimizerApiFormat(config.api_format),
+        api_url: String(config.api_url ?? "").trim(),
+        api_key: String(config.api_key ?? ""),
+        model: String(config.model ?? "").trim(),
+        allow_media: config.allow_media === true,
+        resources: config.allow_media === true ? resources : [],
+        instruction: String(instruction ?? "").trim(),
+        context,
+    };
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_optimizer_settings.js b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_optimizer_settings.js
new file mode 100644
index 0000000000000000000000000000000000000000..771e3eb339e83a8a4735ae6abe378326dd2d2b92
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_optimizer_settings.js
@@ -0,0 +1,135 @@
+import {app} from "/scripts/app.js";
+import {
+    normalizePromptOptimizerApiFormat,
+    normalizePromptOptimizerBackend,
+} from "./h3_prompt_optimizer_core.mjs?v=0.6.2";
+
+export const PROMPT_OPTIMIZER_SETTING_IDS = Object.freeze({
+    backend: "MiniMaxH3ContexLoop.PromptOptimizer.Backend",
+    mcpProvider: "MiniMaxH3ContexLoop.PromptOptimizer.McpProvider",
+    apiFormat: "MiniMaxH3ContexLoop.PromptOptimizer.ApiFormat",
+    apiUrl: "MiniMaxH3ContexLoop.PromptOptimizer.ApiUrl",
+    apiKey: "MiniMaxH3ContexLoop.PromptOptimizer.ApiKey",
+    model: "MiniMaxH3ContexLoop.PromptOptimizer.Model",
+    allowMedia: "MiniMaxH3ContexLoop.PromptOptimizer.AllowMedia",
+});
+
+function settingValue(id, fallback) {
+    return app.ui?.settings?.getSettingValue?.(id) ?? fallback;
+}
+
+export function promptOptimizerBackend() {
+    return normalizePromptOptimizerBackend(
+        settingValue(PROMPT_OPTIMIZER_SETTING_IDS.backend, "direct"));
+}
+
+export function promptOptimizerMcpProvider() {
+    const value = String(settingValue(
+        PROMPT_OPTIMIZER_SETTING_IDS.mcpProvider, "codex") ?? "").trim().toLowerCase();
+    return /^[a-z][a-z0-9_-]*$/.test(value) ? value : "codex";
+}
+
+export function promptOptimizerDirectConfig() {
+    return {
+        api_format: normalizePromptOptimizerApiFormat(settingValue(
+            PROMPT_OPTIMIZER_SETTING_IDS.apiFormat, "openai")),
+        api_url: String(settingValue(PROMPT_OPTIMIZER_SETTING_IDS.apiUrl, "") ?? ""),
+        api_key: String(settingValue(PROMPT_OPTIMIZER_SETTING_IDS.apiKey, "") ?? ""),
+        model: String(settingValue(PROMPT_OPTIMIZER_SETTING_IDS.model, "") ?? ""),
+        allow_media: settingValue(PROMPT_OPTIMIZER_SETTING_IDS.allowMedia, false) === true,
+    };
+}
+
+export async function openPromptOptimizerSettings() {
+    const command = app?.extensionManager?.command;
+    if (!command || typeof command.execute !== "function") return false;
+    try {
+        await command.execute("Comfy.ShowSettingsDialog");
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+function notifyChanged() {
+    globalThis.dispatchEvent?.(new CustomEvent("h3-prompt-optimizer-settings-changed"));
+}
+
+const category = ["MiniMax H3 Context Loop", "Prompt optimizer", "Connection"];
+
+app.registerExtension({
+    name: "minimax_h3_context_loop.prompt_optimizer_settings",
+    init() {
+        const add = (definition) => app.ui?.settings?.addSetting?.({
+            category,
+            ...definition,
+            onChange(value, previous) {
+                definition.onChange?.(value, previous);
+                notifyChanged();
+            },
+        });
+        add({
+            id: PROMPT_OPTIMIZER_SETTING_IDS.backend,
+            name: "Prompt optimizer backend",
+            tooltip: "Direct API works without comfyui-mcp and is the portable default. MCP agent uses the separately installed compatible orchestrator. Disabled hides optimizer execution.",
+            type: "combo",
+            defaultValue: "direct",
+            options: [
+                {text: "Direct API (default)", value: "direct"},
+                {text: "MCP agent", value: "mcp"},
+                {text: "Disabled", value: "disabled"},
+            ],
+        });
+        add({
+            id: PROMPT_OPTIMIZER_SETTING_IDS.mcpProvider,
+            name: "MCP agent provider",
+            tooltip: "Used only when Prompt optimizer backend is MCP agent. The compatible comfyui-mcp bridge validates whether the provider is installed and authenticated.",
+            type: "combo",
+            defaultValue: "codex",
+            options: ["codex", "claude", "gemini", "hermes", "kimi", "moonshot", "glm", "minimax", "ollama", "openrouter", "lmstudio", "llamacpp", "custom"],
+            attrs: {editable: true, filter: true},
+        });
+        add({
+            id: PROMPT_OPTIMIZER_SETTING_IDS.apiFormat,
+            name: "Direct API format",
+            type: "combo",
+            defaultValue: "openai",
+            options: [
+                {text: "OpenAI-compatible Chat Completions", value: "openai"},
+                {text: "OpenAI Responses", value: "responses"},
+                {text: "Gemini Native", value: "gemini"},
+            ],
+        });
+        add({
+            id: PROMPT_OPTIMIZER_SETTING_IDS.apiUrl,
+            name: "Direct API URL",
+            tooltip: "A provider base URL or complete supported endpoint. OpenAI, Gemini, and OpenRouter are allowed by default. Server operators can add exact origins through H3_PROMPT_OPTIMIZER_ALLOWED_ORIGINS.",
+            type: "text",
+            defaultValue: "",
+            attrs: {placeholder: "https://api.example.com/v1"},
+        });
+        add({
+            id: PROMPT_OPTIMIZER_SETTING_IDS.apiKey,
+            name: "Direct API key",
+            tooltip: "Stored in ComfyUI user settings, never in workflow JSON. Local endpoints require an exact server-side origin allow-list entry; Gemini Native requires a key.",
+            type: "text",
+            defaultValue: "",
+            attrs: {type: "password", autocomplete: "off"},
+            telemetry: {trackChanges: false},
+        });
+        add({
+            id: PROMPT_OPTIMIZER_SETTING_IDS.model,
+            name: "Direct API model",
+            type: "text",
+            defaultValue: "",
+            attrs: {placeholder: "model identifier"},
+        });
+        add({
+            id: PROMPT_OPTIMIZER_SETTING_IDS.allowMedia,
+            name: "Allow Direct API to read reference media",
+            tooltip: "Off by default. Accessible reference files up to 32 MB are attached only when the selected API format supports their modality. OpenAI-compatible and Responses attach images; Gemini Native can attach image, video, and audio.",
+            type: "boolean",
+            defaultValue: false,
+        });
+    },
+});
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_schema_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_schema_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..f68e471c7d0300448eecd930d9c481270a5f4291
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_schema_core.mjs
@@ -0,0 +1,522 @@
+export const H3_BASE_SECTIONS = Object.freeze([
+    "integrated_multimodal_description",
+    "overall_soundscape",
+    "non_diegetic_music",
+]);
+
+export const H3_REFERENCE_SECTIONS = Object.freeze([
+    "subject_definitions",
+    "summary",
+    "retention_analysis",
+    "detailed_description",
+    "overall_soundscape",
+    "non_diegetic_music",
+]);
+
+export const H3_ALL_SECTIONS = Object.freeze([
+    ...new Set([...H3_BASE_SECTIONS, ...H3_REFERENCE_SECTIONS]),
+]);
+
+// Exact case-sensitive tokens registered by MiniMax-H3's tokenizer_config and
+// by ComfyUI PR #15808. Keep this order aligned with tokenizer ids 151669–151675.
+export const H3_MINIMAX_SPECIAL_TOKENS = Object.freeze([
+    "<d>",
+    "</d>",
+    "<|cutoff|>",
+    "<|lyrics_start|>",
+    "<|lyrics_end|>",
+    "<|caption_start|>",
+    "<|caption_end|>",
+]);
+
+export const H3_MODES = Object.freeze([
+    {id:"auto", label:"Auto schema"},
+    {id:"t2va", label:"T2VA"},
+    {id:"i2va", label:"I2VA"},
+    {id:"fl2va", label:"FL2VA"},
+    {id:"l2va", label:"L2VA"},
+    {id:"ref2va", label:"Ref2VA"},
+]);
+
+// Common valid summary prefixes from the H3 full-reference format. The
+// validator also accepts other non-conflicting combinations of the six
+// canonical task types, so this list is an authoring catalog rather than an
+// artificial restriction on mixed tasks.
+export const H3_TASK_DIRECTIVES = Object.freeze([
+    "[keyframe completion]",
+    "[reference generation]",
+    "[video editing]",
+    "[video continuation]",
+    "[audio reference]",
+    "[audio reuse]",
+    "[keyframe completion + reference generation]",
+    "[keyframe completion + reference generation + audio reference]",
+    "[keyframe completion + reference generation + audio reuse]",
+    "[video editing + keyframe completion]",
+    "[video editing + keyframe completion + audio reference]",
+    "[video editing + keyframe completion + audio reuse]",
+    "[video editing + reference generation]",
+    "[video editing + reference generation + audio reference]",
+    "[video editing + reference generation + audio reuse]",
+    "[video continuation + keyframe completion]",
+    "[video continuation + keyframe completion + audio reference]",
+    "[video continuation + keyframe completion + audio reuse]",
+    "[video continuation + reference generation]",
+    "[video continuation + reference generation + audio reference]",
+    "[video continuation + reference generation + audio reuse]",
+]);
+
+export const H3_VISUAL_RETENTION_MARKERS = Object.freeze([
+    "fully_preserved",
+    "partially_preserved",
+    "attribute_transfer",
+    "weak_reference",
+]);
+
+export const H3_AUDIO_RETENTION_MARKERS = Object.freeze([
+    "fully_copy",
+    "partially_copy",
+    "reference",
+    "weak_reference",
+]);
+
+const MODE_IDS = new Set(H3_MODES.map((item) => item.id));
+const ALIGNMENT_PREFIX = /^(?:For the target video, at 0\.00 seconds into the target video,|How the reference pictures align with the target video —).*$/m;
+const SECTION_PATTERN = new RegExp(
+    `^(${H3_ALL_SECTIONS.join("|")}):`,
+    "gm",
+);
+const TASK_TYPES = new Set([
+    "keyframe completion",
+    "reference generation",
+    "video editing",
+    "video continuation",
+    "audio reference",
+    "audio reuse",
+]);
+const TASK_ORDER = new Map([
+    ["video editing", 0],
+    ["video continuation", 0],
+    ["keyframe completion", 1],
+    ["reference generation", 2],
+    ["audio reference", 3],
+    ["audio reuse", 3],
+]);
+const REFERENCE_LABEL_PATTERN = /<(?:Subject|Picture|Video|Audio)\s+\d+>/g;
+
+export function normalizeH3Mode(value) {
+    const mode = String(value ?? "auto").toLowerCase();
+    return MODE_IDS.has(mode) ? mode : "auto";
+}
+
+export function h3ModeLabel(value) {
+    const mode = normalizeH3Mode(value);
+    return H3_MODES.find((item) => item.id === mode)?.label ?? "Auto schema";
+}
+
+export function detectH3Mode(value) {
+    const text = String(value ?? "").trimStart();
+    if (/^(?:subject_definitions|summary|retention_analysis|detailed_description):/m.test(text)) {
+        return "ref2va";
+    }
+    const firstLine = text.split("\n", 1)[0];
+    if (firstLine.startsWith("For the target video, at 0.00 seconds")) return "i2va";
+    if (firstLine.startsWith("How the reference pictures align") && /Picture 2/.test(firstLine)) return "fl2va";
+    if (firstLine.startsWith("How the reference pictures align")) return "l2va";
+    return "t2va";
+}
+
+export function effectiveH3Mode(value, selectedMode = "auto") {
+    const selected = normalizeH3Mode(selectedMode);
+    return selected === "auto" ? detectH3Mode(value) : selected;
+}
+
+export function h3SectionsForMode(mode) {
+    return normalizeH3Mode(mode) === "ref2va"
+        ? H3_REFERENCE_SECTIONS : H3_BASE_SECTIONS;
+}
+
+function normalizedDuration(value) {
+    const number = Number(value);
+    return Number.isFinite(number) ? Math.max(0.01, number).toFixed(2) : "6.00";
+}
+
+function normalizedShot(value) {
+    const number = Math.trunc(Number(value));
+    return Number.isFinite(number) ? Math.max(1, Math.min(99, number)) : 1;
+}
+
+export function h3AlignmentInstruction(mode, {duration = 6, finalShot = 1} = {}) {
+    const selected = normalizeH3Mode(mode);
+    const seconds = normalizedDuration(duration);
+    const shot = normalizedShot(finalShot);
+    if (selected === "i2va") {
+        return "For the target video, at 0.00 seconds into the target video, <Picture 1> (from [Shot 1]) is fully referenced.";
+    }
+    if (selected === "fl2va") {
+        return `How the reference pictures align with the target video — Picture 1 (from Shot 1) aligns with the 0.00-second mark of the target video; Picture 2 (from Shot ${shot}) aligns with the ${seconds}-second mark of the target video.`;
+    }
+    if (selected === "l2va") {
+        return `How the reference pictures align with the target video — <Picture 1> (from [Shot ${shot}]) aligns with the ${seconds}-second mark of the target video.`;
+    }
+    return "";
+}
+
+export function parseH3Sections(value) {
+    const text = String(value ?? "");
+    const records = [];
+    SECTION_PATTERN.lastIndex = 0;
+    for (const match of text.matchAll(SECTION_PATTERN)) {
+        records.push({
+            name:match[1],
+            start:match.index ?? 0,
+            headerEnd:(match.index ?? 0) + match[0].length,
+        });
+    }
+    records.forEach((record, index) => {
+        record.end = records[index + 1]?.start ?? text.length;
+        record.contentStart = record.headerEnd;
+        while (record.contentStart < record.end && /[ \t]/.test(text[record.contentStart])) record.contentStart += 1;
+        if (text.slice(record.contentStart, record.contentStart + 2) === "\r\n") record.contentStart += 2;
+        else if (text[record.contentStart] === "\n") record.contentStart += 1;
+        while (record.contentStart < record.end && /[ \t]/.test(text[record.contentStart])) record.contentStart += 1;
+    });
+    return records;
+}
+
+function malformedSectionLines(text) {
+    const known = new Set(H3_ALL_SECTIONS);
+    const result = [];
+    String(text ?? "").split("\n").forEach((line, index) => {
+        const candidate = line.match(/^([A-Za-z][A-Za-z _-]+)\s*:/);
+        if (!candidate) return;
+        const normalized = candidate[1].trim().toLowerCase().replace(/[ -]+/g, "_");
+        if (known.has(normalized) && !line.startsWith(`${normalized}:`)) {
+            result.push({line:index + 1, expected:`${normalized}:`});
+        }
+    });
+    return result;
+}
+
+export function validateH3TaskDirective(value) {
+    const text = String(value ?? "").trim();
+    const match = text.match(/^\[([^\]]+)\]/);
+    if (!match) return {valid:false, message:"summary must begin with a square-bracketed H3 task type"};
+    const parts = match[1].split("+").map((item) => item.trim()).filter(Boolean);
+    if (!parts.length || parts.some((item) => !TASK_TYPES.has(item))) {
+        return {valid:false, message:"summary contains an unknown H3 task type"};
+    }
+    if (new Set(parts).size !== parts.length) {
+        return {valid:false, message:"summary repeats an H3 task type"};
+    }
+    if (parts.includes("video editing") && parts.includes("video continuation")) {
+        return {valid:false, message:"summary cannot combine video editing and video continuation"};
+    }
+    if (parts.includes("audio reference") && parts.includes("audio reuse")) {
+        return {valid:false, message:"summary cannot combine audio reference and audio reuse"};
+    }
+    const order = parts.map((item) => TASK_ORDER.get(item));
+    if (order.some((value, index) => index && value < order[index - 1])) {
+        return {valid:false, message:"summary task types are not in canonical H3 order"};
+    }
+    return {valid:true, directive:`[${parts.join(" + ")}]`};
+}
+
+function uniqueMatches(value, pattern) {
+    pattern.lastIndex = 0;
+    return [...String(value ?? "").matchAll(pattern)]
+        .map((match) => match[0])
+        .filter((item, index, all) => all.indexOf(item) === index);
+}
+
+function analyzeShotBody(body, problems) {
+    const shots = [...String(body ?? "").matchAll(/\[Shot\s+(\d+)\]/g)];
+    if (!shots.length || Number(shots[0][1]) !== 1) {
+        problems.push({severity:"error", code:"shots", message:"The main description must begin its shot sequence with [Shot 1]"});
+        return;
+    }
+    const numbers = shots.map((match) => Number(match[1]));
+    if (numbers.some((number, index) => number !== index + 1)) {
+        problems.push({severity:"error", code:"shots", message:"Shot markers must be sequential: [Shot 1], [Shot 2], and so on"});
+    }
+    let previousTime = -1;
+    for (let index = 1; index < shots.length; index += 1) {
+        const match = shots[index];
+        const after = body.slice((match.index ?? 0) + match[0].length);
+        const timestamp = after.match(/^ At (\d{2}):(\d{2})\.(\d{3}),/);
+        if (!timestamp) {
+            problems.push({severity:"error", code:"timestamp", message:`${match[0]} must immediately use At MM:SS.mmm,`});
+            continue;
+        }
+        const seconds = Number(timestamp[1]) * 60 + Number(timestamp[2]) + Number(timestamp[3]) / 1000;
+        if (seconds <= previousTime) {
+            problems.push({severity:"error", code:"timestamp", message:`${match[0]} cut time must be strictly later than the previous cut`});
+        }
+        previousTime = seconds;
+    }
+}
+
+function analyzeDialogue(text, problems) {
+    const ranges = [];
+    for (const match of String(text ?? "").matchAll(/<d>([\s\S]*?)<\/d>/gi)) {
+        const start = match.index ?? 0;
+        ranges.push([start, start + match[0].length]);
+        const language = match[1].match(/^\s*\[([A-Za-z][^\]]*)\]\s+/);
+        if (!language || language[1].toLowerCase() === "unclear") {
+            problems.push({severity:"warning", code:"language", message:"Each <d> span should begin with a [Language] marker"});
+        }
+    }
+    for (const match of String(text ?? "").matchAll(/<(?:scenetrans|cutoff)>|<\|cutoff\|>/gi)) {
+        const position = match.index ?? 0;
+        if (!ranges.some(([start, end]) => start < position && position < end)) {
+            problems.push({severity:"error", code:"dialogue_flow", message:`${match[0]} must be inside a <d> dialogue span`});
+        }
+    }
+    if (/<cutoff>/i.test(String(text ?? ""))) {
+        problems.push({severity:"warning", code:"legacy_token",
+            message:"Use tokenizer-native <|cutoff|> instead of legacy <cutoff>"});
+    }
+}
+
+function analyzeMiniMaxSpecialTokens(text, problems) {
+    const source = String(text ?? "");
+    const pattern = /<\/?d>|<\|(?:cutoff|lyrics_start|lyrics_end|caption_start|caption_end)\|>/gi;
+    for (const match of source.matchAll(pattern)) {
+        const canonical = H3_MINIMAX_SPECIAL_TOKENS.find(
+            (token) => token.toLowerCase() === match[0].toLowerCase(),
+        );
+        if (canonical && match[0] !== canonical) {
+            problems.push({severity:"error", code:"special_token",
+                message:`Use exact case-sensitive MiniMax token ${canonical}`});
+        }
+    }
+
+    for (const pair of [
+        ["lyrics", "<|lyrics_start|>", "<|lyrics_end|>"],
+        ["caption", "<|caption_start|>", "<|caption_end|>"],
+    ]) {
+        const [kind, start, end] = pair;
+        const boundaryPattern = kind === "lyrics"
+            ? /<\|lyrics_(?:start|end)\|>/g
+            : /<\|caption_(?:start|end)\|>/g;
+        let open = false;
+        let invalid = false;
+        for (const match of source.matchAll(boundaryPattern)) {
+            if (match[0] === start) {
+                if (open) invalid = true;
+                open = true;
+            } else if (!open) invalid = true;
+            else open = false;
+        }
+        if (open || invalid) {
+            problems.push({severity:"error", code:"special_pair",
+                message:`Balance ${start} with ${end} in presentation order`});
+        }
+    }
+}
+
+export function analyzeH3Prompt(value, selectedMode = "auto", options = {}) {
+    const text = String(value ?? "");
+    const mode = effectiveH3Mode(text, selectedMode);
+    const required = h3SectionsForMode(mode);
+    const records = parseH3Sections(text);
+    const byName = new Map();
+    for (const record of records) {
+        const entries = byName.get(record.name) ?? [];
+        entries.push(record);
+        byName.set(record.name, entries);
+    }
+    const missing = required.filter((section) => !byName.has(section));
+    const duplicates = [...byName.entries()].filter(([, entries]) => entries.length > 1)
+        .map(([section]) => section);
+    const unexpected = [...byName.keys()].filter((section) => !required.includes(section));
+    const canonicalIndexes = records.filter((record) => required.includes(record.name))
+        .map((record) => required.indexOf(record.name));
+    const outOfOrder = canonicalIndexes.some((value, index) => index && value < canonicalIndexes[index - 1]);
+    const malformed = malformedSectionLines(text);
+    const problems = [];
+    for (const section of missing) problems.push({severity:"error", code:"missing", section, message:`Missing ${section}:`});
+    for (const section of duplicates) problems.push({severity:"error", code:"duplicate", section, message:`Duplicate ${section}:`});
+    for (const section of unexpected) problems.push({severity:"error", code:"unexpected", section, message:`${section}: does not belong in ${h3ModeLabel(mode)}`});
+    if (outOfOrder) problems.push({severity:"error", code:"order", message:"H3 sections are not in their required order"});
+    for (const item of malformed) problems.push({severity:"error", code:"format", message:`Line ${item.line}: use exact ${item.expected}`});
+
+    const alignment = h3AlignmentInstruction(mode, options);
+    const firstLine = text.trimStart().split("\n", 1)[0];
+    if (alignment) {
+        if (firstLine !== alignment) {
+            problems.push({severity:"error", code:"alignment", message:`${h3ModeLabel(mode)} requires its exact first-line picture alignment`});
+        }
+    } else if (ALIGNMENT_PREFIX.test(firstLine)) {
+        problems.push({severity:"error", code:"alignment", message:`${h3ModeLabel(mode)} must not begin with a keyframe-alignment instruction`});
+    }
+
+    if (mode === "ref2va" && byName.has("summary")) {
+        const summary = byName.get("summary")[0];
+        const body = text.slice(summary.contentStart, summary.end).trim();
+        const directive = validateH3TaskDirective(body);
+        if (!directive.valid) problems.push({severity:"error", code:"summary", section:"summary", message:directive.message});
+    }
+
+    for (const section of required) {
+        const record = byName.get(section)?.[0];
+        if (!record) continue;
+        const body = text.slice(record.contentStart, record.end).trim();
+        const meaningful = body
+            .replace(/^\[reference generation\]\s*$/, "")
+            .replace(/^\[Shot 1\]\s*$/, "")
+            .trim();
+        if (!body || (!meaningful && section !== "non_diegetic_music")) {
+            problems.push({severity:"warning", code:"empty", section, message:`${section}: still needs content`});
+        }
+    }
+
+    const mainSection = mode === "ref2va" ? "detailed_description" : "integrated_multimodal_description";
+    const mainRecord = byName.get(mainSection)?.[0];
+    if (mainRecord) {
+        const body = text.slice(mainRecord.contentStart, mainRecord.end).trim();
+        analyzeShotBody(body, problems);
+        if (mode === "ref2va") {
+            const firstShot = body.indexOf("[Shot 1]");
+            if (firstShot <= 0 || !body.slice(0, firstShot).trim()) {
+                problems.push({severity:"warning", code:"style", section:mainSection,
+                    message:"Ref2VA detailed_description needs 1–2 style sentences before [Shot 1]"});
+            }
+        }
+    }
+
+    const openDialogue = (text.match(/<d>/gi) ?? []).length;
+    const closeDialogue = (text.match(/<\/d>/gi) ?? []).length;
+    if (openDialogue !== closeDialogue) {
+        problems.push({severity:"error", code:"dialogue", message:"Unbalanced <d> and </d> dialogue tags"});
+    }
+    analyzeDialogue(text, problems);
+    analyzeMiniMaxSpecialTokens(text, problems);
+
+    if (mode === "ref2va") {
+        const definitions = byName.get("subject_definitions")?.[0];
+        const retention = byName.get("retention_analysis")?.[0];
+        if (definitions && retention) {
+            const definitionBody = text.slice(definitions.contentStart, definitions.end);
+            const retentionBody = text.slice(retention.contentStart, retention.end);
+            const retained = uniqueMatches(retentionBody, REFERENCE_LABEL_PATTERN);
+            const used = uniqueMatches(text.slice(definitions.end), REFERENCE_LABEL_PATTERN);
+            const definitionLines = [...definitionBody.matchAll(/^\s*(<(?:Subject|Picture|Video|Audio)\s+\d+>)/gm)]
+                .map((match) => match[1]);
+            const defined = definitionLines.filter((label, index, all) => all.indexOf(label) === index);
+            const duplicateDefinitions = definitionLines.filter((label, index, all) => all.indexOf(label) !== index)
+                .filter((label, index, all) => all.indexOf(label) === index);
+            for (const label of duplicateDefinitions) {
+                problems.push({severity:"error", code:"definition", message:`${label} is defined more than once`});
+            }
+            for (const label of used.filter((item) => !defined.includes(item))) {
+                problems.push({severity:"warning", code:"definition", message:`${label} is used but not defined in subject_definitions`});
+            }
+            for (const label of defined.filter((item) => !retained.includes(item))) {
+                problems.push({severity:"warning", code:"retention", message:`${label} has no retention_analysis entry`});
+            }
+        }
+    }
+
+    const connected = new Set();
+    for (const reference of options.connectedReferences ?? []) {
+        const candidates = typeof reference === "string"
+            ? [reference] : [reference?.token, reference?.label];
+        for (const rawToken of candidates) {
+            const match = String(rawToken ?? "").match(/^<(Picture|Video|Audio)\s+(\d+)>$/i);
+            if (match) connected.add(`<${match[1][0].toUpperCase()}${match[1].slice(1).toLowerCase()} ${Number(match[2])}>`);
+        }
+    }
+    for (const ordinal of options.connectedPictures ?? []) {
+        const value = Number(ordinal);
+        if (Number.isInteger(value)) connected.add(`<Picture ${value}>`);
+    }
+    const connectedPictures = new Set(
+        [...connected].filter((token) => token.startsWith("<Picture ")),
+    );
+    const requiredPictures = mode === "fl2va" ? 2 : ["i2va", "l2va"].includes(mode) ? 1 : 0;
+    if (requiredPictures && connectedPictures.size < requiredPictures) {
+        problems.push({severity:"warning", code:"reference",
+            message:`${h3ModeLabel(mode)} expects ${requiredPictures} connected picture reference${requiredPictures === 1 ? "" : "s"}`});
+    }
+    const usedExternalReferences = [...text.matchAll(/<(Picture|Video|Audio)\s+(\d+)>/gi)]
+        .map((match) => `<${match[1][0].toUpperCase()}${match[1].slice(1).toLowerCase()} ${Number(match[2])}>`)
+        .filter((token, index, all) => all.indexOf(token) === index);
+    for (const token of usedExternalReferences.filter((item) => !connected.has(item))) {
+        problems.push({severity:"warning", code:"reference", message:`${token} has no connected authoring reference`});
+    }
+
+    return {
+        mode,
+        required,
+        records,
+        missing,
+        duplicates,
+        unexpected,
+        outOfOrder,
+        problems,
+        valid:!problems.some((problem) => problem.severity === "error"),
+    };
+}
+
+function sectionStarter(section, mode) {
+    if (normalizeH3Mode(mode) === "ref2va") {
+        if (section === "summary") return "summary:\n[reference generation] ";
+        if (section === "detailed_description") return "detailed_description:\n";
+        if (section === "non_diegetic_music") return "non_diegetic_music:\nN/A";
+        return `${section}:\n`;
+    }
+    if (section === "integrated_multimodal_description") {
+        return "integrated_multimodal_description: [Shot 1] ";
+    }
+    if (section === "non_diegetic_music") return "non_diegetic_music: N/A";
+    return `${section}: `;
+}
+
+function cleanJoin(before, inserted, after) {
+    const left = before.replace(/[ \t]+$/g, "").replace(/\n*$/g, "");
+    const right = after.replace(/^\n*/g, "");
+    if (!left) return right ? `${inserted}\n\n${right}` : inserted;
+    if (!right) return `${left}\n\n${inserted}`;
+    return `${left}\n\n${inserted}\n\n${right}`;
+}
+
+export function insertH3Section(value, section, mode) {
+    const text = String(value ?? "");
+    const selected = normalizeH3Mode(mode) === "auto" ? detectH3Mode(text) : normalizeH3Mode(mode);
+    const required = h3SectionsForMode(selected);
+    if (!required.includes(section)) return {text, caret:text.length, added:false};
+    const records = parseH3Sections(text);
+    const existing = records.find((record) => record.name === section);
+    if (existing) return {text, caret:existing.contentStart, added:false};
+    const wanted = required.indexOf(section);
+    const next = records.find((record) => required.indexOf(record.name) > wanted);
+    const split = next?.start ?? text.length;
+    const starter = sectionStarter(section, selected);
+    const result = cleanJoin(text.slice(0, split), starter, text.slice(split));
+    const inserted = parseH3Sections(result).find((record) => record.name === section);
+    return {text:result, caret:inserted?.contentStart ?? result.length, added:true};
+}
+
+function removeKnownAlignment(value) {
+    const text = String(value ?? "").trimStart();
+    const firstLine = text.split("\n", 1)[0];
+    if (!ALIGNMENT_PREFIX.test(firstLine)) return text;
+    return text.slice(firstLine.length).replace(/^\s*/, "");
+}
+
+export function ensureH3Structure(value, mode, options = {}) {
+    const original = String(value ?? "");
+    const selected = normalizeH3Mode(mode) === "auto"
+        ? detectH3Mode(original) : normalizeH3Mode(mode);
+    let text = removeKnownAlignment(original);
+    const alignment = h3AlignmentInstruction(selected, options);
+    if (alignment) text = text ? `${alignment}\n\n${text}` : alignment;
+    const added = [];
+    for (const section of h3SectionsForMode(selected)) {
+        const result = insertH3Section(text, section, selected);
+        text = result.text;
+        if (result.added) added.push(section);
+    }
+    return {text, mode:selected, added, caret:text.length};
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_schema_ui.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_schema_ui.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..05198c89e562f677b05234b459b9d682af542ae5
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_prompt_schema_ui.mjs
@@ -0,0 +1,312 @@
+import {
+    analyzeH3Prompt,
+    effectiveH3Mode,
+    ensureH3Structure,
+    H3_MODES,
+    h3ModeLabel,
+    insertH3Section,
+} from "./h3_prompt_schema_core.mjs?v=0.6.5";
+
+function injectStyles() {
+    if (document.getElementById("h3-prompt-schema-ui-style")) return;
+    const style = document.createElement("style");
+    style.id = "h3-prompt-schema-ui-style";
+    style.textContent = `
+      .h3schema-mode { min-width:112px !important; }
+      .h3schema-toggle.h3schema-invalid { border-color:#bd6c6c !important; }
+      .h3schema-toggle.h3schema-valid { border-color:#5b9c70 !important; }
+      .h3schema-panel { display:none; max-height:300px; overflow:auto; padding:8px; gap:7px;
+        border:1px solid var(--h3sp-border,var(--h3rp-border,var(--border-color,#555)));
+        border-radius:7px; background:var(--h3sp-panel,var(--h3rp-panel,var(--comfy-input-bg,#171a21)));
+        color:var(--h3sp-text,var(--h3rp-text,var(--input-text,#edf2fa)));
+        font:12px/1.35 system-ui,sans-serif; }
+      .h3schema-panel.h3schema-open { display:flex; flex-direction:column; }
+      .h3schema-head,.h3schema-options,.h3schema-section-row {
+        display:flex; align-items:center; gap:6px; }
+      .h3schema-head { flex-wrap:wrap; }
+      .h3schema-title { min-width:180px; flex:1; }
+      .h3schema-counts,.h3schema-muted {
+        color:var(--h3sp-muted,var(--h3rp-muted,color-mix(in srgb,currentColor 58%,transparent))); }
+      .h3schema-counts { white-space:nowrap; font-variant-numeric:tabular-nums; }
+      .h3schema-options { flex-wrap:wrap; }
+      .h3schema-options label { display:flex; align-items:center; gap:4px;
+        color:var(--h3sp-muted,var(--h3rp-muted,color-mix(in srgb,currentColor 58%,transparent))); }
+      .h3schema-options input { width:76px; min-height:28px; padding:4px 6px;
+        border:1px solid var(--h3sp-border,var(--h3rp-border,var(--border-color,#555)));
+        border-radius:5px; background:var(--comfy-input-bg,#171a21); color:inherit; font:inherit; }
+      .h3schema-section-list { display:grid; gap:5px; }
+      .h3schema-section-row { min-width:0; padding:5px 7px;
+        border:1px solid var(--h3sp-border,var(--h3rp-border,var(--border-color,#555)));
+        border-radius:6px; background:color-mix(in srgb,var(--comfy-input-bg,#11141a) 88%,transparent); }
+      .h3schema-section-row.h3schema-missing { border-style:dashed; color:#e29a9a; }
+      .h3schema-mark { flex:0 0 18px; text-align:center; font-weight:800; }
+      .h3schema-name { flex:1; min-width:0; overflow:hidden; text-overflow:ellipsis;
+        white-space:nowrap; font:600 11px/1.3 ui-monospace,SFMono-Regular,Consolas,monospace; }
+      .h3schema-panel button { min-height:26px; padding:3px 7px; color:inherit; font:inherit;
+        border:1px solid var(--h3sp-border,var(--h3rp-border,var(--border-color,#555)));
+        border-radius:5px; background:var(--comfy-input-bg,#171a21); cursor:pointer; }
+      .h3schema-problems { display:grid; gap:3px;
+        color:var(--h3sp-muted,var(--h3rp-muted,color-mix(in srgb,currentColor 58%,transparent))); }
+      .h3schema-problem-error { color:#ffaaaa; }
+      .h3schema-problem-warning { color:#e9bd72; }
+    `;
+    document.head.append(style);
+}
+
+function element(tag, className = "", text) {
+    const item = document.createElement(tag);
+    if (className) item.className = className;
+    if (text !== undefined) item.textContent = text;
+    return item;
+}
+
+function button(label, title, action) {
+    const item = element("button", "", label);
+    item.type = "button";
+    item.title = title;
+    item.addEventListener("pointerdown", (event) => event.preventDefault());
+    item.addEventListener("click", action);
+    return item;
+}
+
+function finiteDuration(value, fallback = 6) {
+    const number = Number(value);
+    return Number.isFinite(number) ? Math.max(0.01, number) : fallback;
+}
+
+function finiteShot(value) {
+    const number = Math.trunc(Number(value));
+    return Number.isFinite(number) ? Math.max(1, Math.min(99, number)) : 1;
+}
+
+/**
+ * Shared strict-schema inspector used by both Motion Context prompt editors.
+ * The host retains ownership of text, undo, Plan persistence, and focus.
+ */
+export function createH3PromptSchemaController({
+    node,
+    propertyPrefix,
+    getText,
+    replaceText,
+    focusAt,
+    getRecords = () => [],
+    defaultDuration = 6,
+    defaultMode = "auto",
+    scopeKey = "",
+    markDirty = () => {},
+    onAnalysis = () => {},
+} = {}) {
+    if (!node || typeof getText !== "function" || typeof replaceText !== "function") return null;
+    injectStyles();
+    node.properties ??= {};
+    const prefix = String(propertyPrefix || "h3_prompt");
+    const property = {
+        mode:`${prefix}_schema_mode`,
+        open:`${prefix}_structure_open`,
+        alignment:`${prefix}_schema_alignment_by_scene`,
+    };
+    const selected = String(node.properties[property.mode] ?? defaultMode);
+    const alignment = node.properties[property.alignment]?.[String(scopeKey)] ?? {};
+    const state = {
+        mode:H3_MODES.some((item) => item.id === selected) ? selected : "auto",
+        open:Boolean(node.properties[property.open]),
+        duration:finiteDuration(alignment.duration, finiteDuration(defaultDuration)),
+        finalShot:finiteShot(alignment.finalShot),
+        analysis:null,
+    };
+
+    const modeSelect = element("select", "h3schema-mode");
+    modeSelect.title = "Choose the strict H3 prompt schema; Auto detects it from the prompt";
+    modeSelect.setAttribute("aria-label", "H3 prompt schema");
+    for (const mode of H3_MODES) {
+        const option = element("option", "", mode.label);
+        option.value = mode.id;
+        modeSelect.append(option);
+    }
+    modeSelect.value = state.mode;
+
+    const toggle = button("Sections", "Show strict H3 categories and validation", () => {
+        state.open = !state.open;
+        node.properties[property.open] = state.open;
+        panel.classList.toggle("h3schema-open", state.open);
+        refresh();
+        markDirty();
+    });
+    toggle.className = "h3schema-toggle";
+    toggle.setAttribute("aria-expanded", String(state.open));
+
+    const panel = element("div", "h3schema-panel");
+    panel.classList.toggle("h3schema-open", state.open);
+    const counts = element("span", "h3schema-counts");
+
+    function structureOptions() {
+        return {duration:state.duration, finalShot:state.finalShot};
+    }
+
+    function persistAlignment() {
+        const alignments = {
+            ...(node.properties[property.alignment]
+                && typeof node.properties[property.alignment] === "object"
+                ? node.properties[property.alignment] : {}),
+        };
+        alignments[String(scopeKey)] = {
+            duration:state.duration,
+            finalShot:state.finalShot,
+        };
+        node.properties[property.alignment] = alignments;
+    }
+
+    function commitResult(result, message) {
+        replaceText({
+            text:String(result.text ?? ""),
+            caret:Number.isFinite(result.caret) ? result.caret : String(result.text ?? "").length,
+        }, message);
+    }
+
+    function addSection(section) {
+        const text = String(getText() ?? "");
+        const mode = effectiveH3Mode(text, state.mode);
+        const result = insertH3Section(text, section, mode);
+        if (result.added) commitResult(result, `Added ${section}:`);
+        else focusAt?.(result.caret);
+    }
+
+    function normalizeStructure() {
+        const text = String(getText() ?? "");
+        const mode = effectiveH3Mode(text, state.mode);
+        const result = ensureH3Structure(text, mode, structureOptions());
+        const message = result.added.length
+            ? `Added ${result.added.length} missing section${result.added.length === 1 ? "" : "s"}`
+            : `Normalized ${h3ModeLabel(result.mode)} alignment`;
+        commitResult(result, message);
+    }
+
+    function optionInput(label, value, {min, max, step}, action) {
+        const host = element("label");
+        host.append(document.createTextNode(label));
+        const input = element("input");
+        input.type = "number";
+        input.min = String(min);
+        input.max = String(max);
+        input.step = String(step);
+        input.value = String(value);
+        input.addEventListener("change", () => action(input.value));
+        host.append(input);
+        return host;
+    }
+
+    function renderPanel(text, analysis) {
+        if (!state.open) return;
+        panel.replaceChildren();
+        const words = text.trim() ? text.trim().split(/\s+/).length : 0;
+        const head = element("div", "h3schema-head");
+        head.append(
+            element("strong", "h3schema-title", `${h3ModeLabel(analysis.mode)} strict section order`),
+            element("span", "h3schema-counts", `${words} words · ${text.length} chars`),
+            button(
+                analysis.missing.length ? "Add missing" : "Normalize",
+                "Add absent categories in H3 order and write the exact mode alignment line",
+                normalizeStructure,
+            ),
+        );
+        panel.append(head);
+
+        if (["i2va", "fl2va", "l2va"].includes(analysis.mode)) {
+            const options = element("div", "h3schema-options");
+            if (["fl2va", "l2va"].includes(analysis.mode)) {
+                options.append(
+                    optionInput("Duration (s)", state.duration, {min:0.01, max:999, step:0.01}, (value) => {
+                        state.duration = finiteDuration(value);
+                        persistAlignment();
+                        refresh();
+                        markDirty();
+                    }),
+                    optionInput("Final shot", state.finalShot, {min:1, max:99, step:1}, (value) => {
+                        state.finalShot = finiteShot(value);
+                        persistAlignment();
+                        refresh();
+                        markDirty();
+                    }),
+                );
+            } else {
+                options.append(element(
+                    "span", "h3schema-muted",
+                    "I2VA uses <Picture 1> at 0.00 seconds in [Shot 1].",
+                ));
+            }
+            panel.append(options);
+        }
+
+        const list = element("div", "h3schema-section-list");
+        for (const section of analysis.required) {
+            const record = analysis.records.find((item) => item.name === section);
+            const row = element("div", `h3schema-section-row${record ? "" : " h3schema-missing"}`);
+            row.append(
+                element("span", "h3schema-mark", record ? "✓" : "+"),
+                element("span", "h3schema-name", `${section}:`),
+                button(record ? "Go" : "Add", record
+                    ? `Go to ${section}:` : `Add ${section}: in H3 order`, () => {
+                    if (record) focusAt?.(record.contentStart);
+                    else addSection(section);
+                }),
+            );
+            list.append(row);
+        }
+        panel.append(list);
+
+        const problems = element("div", "h3schema-problems");
+        if (!analysis.problems.length) {
+            problems.append(element(
+                "div", "",
+                "✓ Exact section names, ordering, alignment, and dialogue balance pass.",
+            ));
+        } else {
+            for (const problem of analysis.problems) {
+                problems.append(element(
+                    "div", `h3schema-problem-${problem.severity}`,
+                    `${problem.severity === "error" ? "×" : "!"} ${problem.message}`,
+                ));
+            }
+        }
+        panel.append(problems);
+    }
+
+    function refresh() {
+        const text = String(getText() ?? "");
+        const words = text.trim() ? text.trim().split(/\s+/).length : 0;
+        counts.textContent = `${words} words · ${text.length} chars`;
+        state.analysis = analyzeH3Prompt(text, state.mode, {
+            ...structureOptions(),
+            connectedReferences:getRecords(),
+        });
+        const errors = state.analysis.problems.filter((item) => item.severity === "error").length;
+        toggle.classList.toggle("h3schema-invalid", errors > 0);
+        toggle.classList.toggle("h3schema-valid", errors === 0);
+        toggle.title = errors
+            ? `Show strict H3 categories and validation · ${errors} structure error${errors === 1 ? "" : "s"}`
+            : "Show strict H3 categories and validation · structure valid";
+        toggle.setAttribute("aria-expanded", String(state.open));
+        renderPanel(text, state.analysis);
+        onAnalysis(state.analysis);
+        return state.analysis;
+    }
+
+    modeSelect.addEventListener("change", () => {
+        state.mode = modeSelect.value;
+        node.properties[property.mode] = state.mode;
+        refresh();
+        markDirty();
+    });
+
+    refresh();
+    return {
+        modeSelect,
+        toggle,
+        panel,
+        counts,
+        refresh,
+        getMode:() => state.mode,
+        get analysis() { return state.analysis; },
+        destroy() {},
+    };
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_reference_autoconnect.js b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_reference_autoconnect.js
new file mode 100644
index 0000000000000000000000000000000000000000..6734b1f8d7d2186a53c0473b6358a4090bcc3eaa
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_reference_autoconnect.js
@@ -0,0 +1,31 @@
+import {app} from "/scripts/app.js";
+import {
+    SCHEDULED_REF2VA_TYPE,
+    VIDEO_REF_TYPE,
+    migrateLegacyVideoScheduleWidgets,
+    migrateReferenceComplianceWidget,
+} from "./h3_reference_autoconnect_core.mjs?v=0.6.2";
+
+const EXTENSION = "minimax_h3_context_loop.reference_autoconnect";
+
+app.registerExtension({
+    name: EXTENSION,
+    async beforeRegisterNodeDef(nodeType, nodeData) {
+        if (nodeData.name === VIDEO_REF_TYPE) {
+            const originalConfigure = nodeType.prototype.onConfigure;
+            nodeType.prototype.onConfigure = function (info) {
+                const result = originalConfigure?.apply(this, arguments);
+                migrateLegacyVideoScheduleWidgets(this, info);
+                return result;
+            };
+        }
+        if (nodeData.name === SCHEDULED_REF2VA_TYPE) {
+            const originalConfigure = nodeType.prototype.onConfigure;
+            nodeType.prototype.onConfigure = function () {
+                const result = originalConfigure?.apply(this, arguments);
+                migrateReferenceComplianceWidget(this);
+                return result;
+            };
+        }
+    },
+});
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_reference_autoconnect_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_reference_autoconnect_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..24857e16852de54a44c3c99f471cdfa47c548fb3
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_reference_autoconnect_core.mjs
@@ -0,0 +1,41 @@
+export const SCHEDULED_REF2VA_TYPE = "MiniMaxH3ScheduledReferenceToVideo";
+export const VIDEO_REF_TYPE = "MiniMaxH3ScheduledVideoReference";
+
+export function nodeType(node) {
+    return node?.comfyClass ?? node?.type ?? null;
+}
+
+function widget(node, name) {
+    return node?.widgets?.find((item) => item.name === name) ?? null;
+}
+
+function setWidget(node, name, value) {
+    const target = widget(node, name);
+    if (!target) return false;
+    target.value = value;
+    target.callback?.(target.value);
+    return true;
+}
+
+export function migrateLegacyVideoScheduleWidgets(node, info) {
+    const values = info?.widgets_values;
+    if (nodeType(node) !== VIDEO_REF_TYPE || !Array.isArray(values)
+            || values.length < 5) return false;
+    // v0.3.10 stored [tag, scenes, declaration, audio_tag,
+    // audio_declaration]. The current scheduler stores
+    // [tag, scenes, audio_tag, timeline_mode], so only the five-value legacy
+    // shape may be migrated here.
+    const audioMigrated = setWidget(node, "audio_tag", values[3] ?? "");
+    const timelineReset = setWidget(
+        node, "timeline_mode", "restart_each_scene");
+    return audioMigrated || timelineReset;
+}
+
+export function migrateReferenceComplianceWidget(node) {
+    if (nodeType(node) !== SCHEDULED_REF2VA_TYPE) return false;
+    const target = widget(node, "prompt_compliance");
+    if (!target || typeof target.value !== "boolean") return false;
+    target.value = target.value ? "strict" : "soft";
+    target.callback?.(target.value);
+    return true;
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_reference_preview_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_reference_preview_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..0714aafdebbf8e571539bf9cd30c159523eac2e3
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_reference_preview_core.mjs
@@ -0,0 +1,1017 @@
+export const SCHEDULED_REF2VA_TYPE = "MiniMaxH3ScheduledReferenceToVideo";
+export const TAGGED_REF2VA_TYPE = "MiniMaxH3TaggedReferenceToVideo";
+export const CURRENT_TAGGED_REF2VA_TYPE =
+    "MiniMaxH3CurrentTaggedReferenceScene";
+export const CORE_REF2VA_TYPE = "MiniMaxH3ReferenceToVideo";
+export const IMAGE_TO_VIDEO_TYPE = "MiniMaxH3ImageToVideo";
+export const FIRST_SCENE_IMAGE_TYPE = "MiniMaxH3ChainFirstSceneImage";
+export const FRAME_INDEX_SWITCH_TYPE = "MiniMaxH3ChainFrameIndexSwitch";
+export const PICTURE_REF_TYPE = "MiniMaxH3ScheduledPictureReference";
+export const VIDEO_REF_TYPE = "MiniMaxH3ScheduledVideoReference";
+export const AUDIO_REF_TYPE = "MiniMaxH3ScheduledAudioReference";
+export const TAGGED_PICTURE_REF_TYPE = "MiniMaxH3TaggedPictureReference";
+export const TAGGED_VIDEO_REF_TYPE = "MiniMaxH3TaggedVideoReference";
+export const TAGGED_MOTION_REF_TYPE = "MiniMaxH3TaggedMotionReference";
+export const TAGGED_MOTION_PATH_REF_TYPE =
+    "MiniMaxH3TaggedMotionReferencePath";
+export const TAGGED_MOTION_TIMELINE_REF_TYPE =
+    "MiniMaxH3TaggedMotionReferenceTimeline";
+export const TAGGED_AUDIO_REF_TYPE = "MiniMaxH3TaggedAudioReference";
+export const SEMANTIC_ANCHOR_BUNDLE_TYPE = "MiniMaxH3SemanticAnchorBundle";
+export const SEMANTIC_PICTURE_ANCHOR_TYPE = "MiniMaxH3SemanticPictureAnchor";
+export const PROJECT_ASSET_MANAGER_TYPE = "MiniMaxH3ProjectAssetManager";
+
+const SCHEDULE_TYPES = new Set([
+    PICTURE_REF_TYPE,
+    VIDEO_REF_TYPE,
+    AUDIO_REF_TYPE,
+]);
+const TAGGED_TYPES = new Set([
+    TAGGED_PICTURE_REF_TYPE,
+    TAGGED_VIDEO_REF_TYPE,
+    TAGGED_MOTION_REF_TYPE,
+    TAGGED_MOTION_PATH_REF_TYPE,
+    TAGGED_MOTION_TIMELINE_REF_TYPE,
+    TAGGED_AUDIO_REF_TYPE,
+]);
+const TAGGED_REF2VA_TYPES = new Set([
+    TAGGED_REF2VA_TYPE,
+    CURRENT_TAGGED_REF2VA_TYPE,
+]);
+
+export function nodeType(node) {
+    return node?.comfyClass ?? node?.type ?? null;
+}
+
+function widgetValue(node, name, fallback = "") {
+    const connected = connectedInputValue(node, name);
+    if (connected !== undefined) return connected;
+    return node?.widgets?.find((item) => item.name === name)?.value ?? fallback;
+}
+
+export function referenceTag(value) {
+    return String(value ?? "").trim().replace(/^@+/, "");
+}
+
+function escapedPattern(value) {
+    return String(value ?? "").replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export function taggedPictureReferenceToken(tag, mode = "native", timestamp = null) {
+    const cleanTag = referenceTag(tag);
+    if (!cleanTag) return "";
+    if (mode !== "semantic") return `@${cleanTag}`;
+    if (timestamp === null || timestamp === undefined
+            || String(timestamp).trim() === "") return `#${cleanTag}`;
+    const seconds = Number(timestamp);
+    if (!Number.isFinite(seconds)) return `#${cleanTag}`;
+    const safeSeconds = Math.max(0, seconds);
+    return `#${cleanTag}[${safeSeconds.toFixed(2)}s]`;
+}
+
+export function taggedPictureReferenceMode(prompt, tag) {
+    const cleanTag = referenceTag(tag);
+    if (!cleanTag) return "unused";
+    const escaped = escapedPattern(cleanTag);
+    const native = new RegExp(
+        `(^|[^A-Za-z0-9_])@${escaped}(?![A-Za-z0-9_-])`,
+    ).test(String(prompt ?? ""));
+    const semantic = new RegExp(
+        `(^|[^A-Za-z0-9_])#${escaped}(?:\\[[0-9]+(?:\\.[0-9]+)?s?\\]|(?!\\[))(?![A-Za-z0-9_-])`,
+    ).test(String(prompt ?? ""));
+    if (native && semantic) return "mixed";
+    if (semantic) return "semantic";
+    if (native) return "native";
+    return "unused";
+}
+
+export function convertTaggedPictureReference(
+        prompt, tag, mode = "native", timestamp = null) {
+    const source = String(prompt ?? "");
+    const cleanTag = referenceTag(tag);
+    if (!cleanTag || !["native", "semantic"].includes(mode)) return source;
+    const escaped = escapedPattern(cleanTag);
+    if (mode === "semantic") {
+        const replacement = taggedPictureReferenceToken(
+            cleanTag, "semantic", timestamp,
+        );
+        return source.replace(
+            new RegExp(
+                `(^|[^A-Za-z0-9_])@${escaped}(?![A-Za-z0-9_-])`, "g",
+            ),
+            (_match, prefix) => `${prefix}${replacement}`,
+        );
+    }
+    const replacement = taggedPictureReferenceToken(cleanTag, "native");
+    return source.replace(
+        new RegExp(
+            `(^|[^A-Za-z0-9_])#${escaped}(?:\\[[0-9]+(?:\\.[0-9]+)?s?\\]|(?!\\[))(?![A-Za-z0-9_-])`,
+            "g",
+        ),
+        (_match, prefix) => `${prefix}${replacement}`,
+    );
+}
+
+export function referenceReplacementToken(
+        record, mode = "native", timestamp = null) {
+    if (!record || !["native", "semantic"].includes(mode)) return "";
+    if (mode === "semantic") {
+        if (record.kind !== "picture" || !record.tag) return "";
+        return taggedPictureReferenceToken(record.tag, "semantic", timestamp);
+    }
+    if (record.nativeToken === null) return "";
+    return String(record.nativeToken ?? record.token ?? "");
+}
+
+export function replacePromptReferenceOccurrence(
+        prompt, start, end, record, mode = "native", timestamp = null) {
+    const source = String(prompt ?? "");
+    const first = Number(start);
+    const last = Number(end);
+    if (!Number.isInteger(first) || !Number.isInteger(last)
+            || first < 0 || last < first || last > source.length) {
+        return source;
+    }
+    const replacement = referenceReplacementToken(record, mode, timestamp);
+    if (!replacement) return source;
+    return `${source.slice(0, first)}${replacement}${source.slice(last)}`;
+}
+
+const TRANSPARENT_REROUTE_TYPES = new Set([
+    "Reroute",
+    "Reroute (rgthree)",
+]);
+const SUBGRAPH_INPUT_ID = "-10";
+const SUBGRAPH_OUTPUT_ID = "-20";
+
+function graphLink(graph, linkId) {
+    if (linkId == null) return null;
+    return graph?.links?.get?.(linkId) ?? graph?.links?.[linkId] ?? null;
+}
+
+function graphLinks(graph) {
+    if (graph?.links?.values) return [...graph.links.values()];
+    return Object.values(graph?.links ?? {});
+}
+
+function isGraphIoNode(id, expected) {
+    return String(id) === expected;
+}
+
+function subgraphHostNode(graph) {
+    if (!graph) return null;
+    const root = rootGraph(graph);
+    if (!root || graph === root) return null;
+    const graphs = [root, ...graphDescendants(root)];
+    for (const candidate of graphs) {
+        const host = candidate?._nodes?.find((node) => node?.subgraph === graph);
+        if (host) return host;
+    }
+    return null;
+}
+
+function connectionFromLink(graph, link) {
+    if (!graph || !link) return null;
+    if (isGraphIoNode(link.origin_id, SUBGRAPH_INPUT_ID)) {
+        const host = subgraphHostNode(graph);
+        const input = host?.inputs?.[Number(link.origin_slot ?? 0)];
+        const parentLink = graphLink(host?.graph, input?.link);
+        return connectionFromLink(host?.graph, parentLink);
+    }
+    const source = graph.getNodeById?.(link.origin_id) ?? null;
+    return source
+        ? {source, originSlot: Number(link.origin_slot ?? 0)}
+        : null;
+}
+
+function subgraphOutputConnection(node, originSlot) {
+    const graph = node?.subgraph;
+    if (!graph) return null;
+    const slotIndex = Number(originSlot ?? 0);
+    const slot = graph.outputs?.[slotIndex]
+        ?? graph.outputNode?.slots?.[slotIndex];
+    const linked = (slot?.linkIds ?? [])
+        .map((linkId) => graphLink(graph, linkId))
+        .filter(Boolean);
+    const candidates = linked.length ? linked : graphLinks(graph).filter(
+        (link) => isGraphIoNode(link?.target_id, SUBGRAPH_OUTPUT_ID)
+            && Number(link?.target_slot ?? -1) === slotIndex,
+    );
+    const link = candidates.find(
+        (item) => isGraphIoNode(item?.target_id, SUBGRAPH_OUTPUT_ID)
+            && Number(item?.target_slot ?? -1) === slotIndex,
+    ) ?? candidates[0];
+    return connectionFromLink(graph, link);
+}
+
+function directInputConnection(node, name = null) {
+    const input = name === null
+        ? node?.inputs?.find((item) => item.link != null)
+        : node?.inputs?.find((item) => item.name === name);
+    const link = graphLink(node?.graph, input?.link);
+    return connectionFromLink(node?.graph, link);
+}
+
+function rootGraph(graph) {
+    return graph?.rootGraph ?? graph ?? null;
+}
+
+function graphAncestors(graph) {
+    if (!graph) return [];
+    const root = rootGraph(graph);
+    if (!root || graph === root) return root ? [root] : [];
+
+    const result = [graph];
+    const seen = new Set(result);
+    let current = graph;
+    while (current !== root) {
+        let parent = null;
+        const candidates = [root];
+        const subgraphs = root?._subgraphs ?? root?.subgraphs;
+        if (subgraphs?.values) candidates.push(...subgraphs.values());
+        for (const candidate of candidates) {
+            if (!candidate?._nodes || candidate === current) continue;
+            if (candidate._nodes.some((node) => node.subgraph === current)) {
+                parent = candidate;
+                break;
+            }
+        }
+        if (!parent || seen.has(parent)) {
+            if (!seen.has(root)) result.push(root);
+            break;
+        }
+        result.push(parent);
+        seen.add(parent);
+        current = parent;
+    }
+    return result;
+}
+
+function graphDescendants(graph, seen = new Set()) {
+    if (!graph?._nodes || seen.has(graph)) return [];
+    seen.add(graph);
+    const result = [];
+    for (const node of graph._nodes) {
+        if (!node?.subgraph || seen.has(node.subgraph)) continue;
+        result.push(node.subgraph);
+        result.push(...graphDescendants(node.subgraph, seen));
+    }
+    return result;
+}
+
+function setGetName(node) {
+    return String(node?.widgets?.[0]?.value ?? "");
+}
+
+function setNodeFor(getNode) {
+    const name = setGetName(getNode);
+    if (!name) return null;
+    for (const graph of graphAncestors(getNode?.graph)) {
+        const setter = graph?._nodes?.find(
+            (node) => nodeType(node) === "SetNode" && setGetName(node) === name,
+        );
+        if (setter) return setter;
+    }
+    return null;
+}
+
+function getNodesFor(setNode) {
+    const name = setGetName(setNode);
+    if (!name || !setNode?.graph) return [];
+    const graphs = [setNode.graph, ...graphDescendants(setNode.graph)];
+    return graphs.flatMap((graph) => (graph?._nodes ?? []).filter(
+        (node) => nodeType(node) === "GetNode" && setGetName(node) === name,
+    ));
+}
+
+function transparentInputConnection(node, originSlot = 0) {
+    if (node?.subgraph) {
+        return subgraphOutputConnection(node, originSlot);
+    }
+    const type = nodeType(node);
+    if (type === "GetNode") {
+        const setter = setNodeFor(node);
+        return setter ? directInputConnection(setter) : null;
+    }
+    if (type === "SetNode" || TRANSPARENT_REROUTE_TYPES.has(type)) {
+        return directInputConnection(node);
+    }
+    return null;
+}
+
+function resolveInputConnection(connection) {
+    let current = connection;
+    const seen = new Set();
+    while (current?.source && !seen.has(current.source)) {
+        seen.add(current.source);
+        const next = transparentInputConnection(
+            current.source, current.originSlot,
+        );
+        if (!next) break;
+        current = next;
+    }
+    return current;
+}
+
+function inputConnection(node, name) {
+    return resolveInputConnection(directInputConnection(node, name));
+}
+
+function connectedInputValue(node, name) {
+    const connection = inputConnection(node, name);
+    if (!connection?.source) return undefined;
+    const {source, originSlot} = connection;
+    const output = source.outputs?.[originSlot];
+    if (output?.value !== undefined) return output.value;
+    if (source.output_values?.[originSlot] !== undefined) {
+        return source.output_values[originSlot];
+    }
+
+    const widgets = source.widgets ?? [];
+    const outputName = String(output?.name ?? "").trim().toLowerCase();
+    const matching = outputName
+        ? widgets.find((widget) => String(
+            widget?.name ?? "",
+        ).trim().toLowerCase() === outputName)
+        : null;
+    if (matching?.value !== undefined) return matching.value;
+
+    for (const candidate of ["value", "string", "text", "tag"]) {
+        const widget = widgets.find((item) => String(
+            item?.name ?? "",
+        ).trim().toLowerCase() === candidate);
+        if (widget?.value !== undefined) return widget.value;
+    }
+    if (widgets.length === 1 && widgets[0]?.value !== undefined) {
+        return widgets[0].value;
+    }
+    return undefined;
+}
+
+function inputSource(node, name) {
+    return inputConnection(node, name)?.source ?? null;
+}
+
+function outputTargets(node) {
+    const targets = [];
+    for (const output of node?.outputs ?? []) {
+        for (const linkId of output.links ?? []) {
+            const link = graphLink(node?.graph, linkId);
+            const target = link ? node.graph?.getNodeById?.(link.target_id) : null;
+            if (target) targets.push(target);
+        }
+    }
+    if (nodeType(node) === "SetNode") targets.push(...getNodesFor(node));
+    return targets;
+}
+
+function findDownstreamTypes(start, wantedTypes) {
+    const queue = [start];
+    const seen = new Set();
+    while (queue.length) {
+        const node = queue.shift();
+        if (!node || seen.has(node)) continue;
+        seen.add(node);
+        if (node !== start && wantedTypes.has(nodeType(node))) return node;
+        queue.push(...outputTargets(node));
+    }
+    return null;
+}
+
+function findDownstreamType(start, wantedType) {
+    return findDownstreamTypes(start, new Set([wantedType]));
+}
+
+function findUpstreamType(start, wantedType) {
+    const queue = [start];
+    const seen = new Set();
+    while (queue.length) {
+        const node = queue.shift();
+        if (!node || seen.has(node)) continue;
+        seen.add(node);
+        if (node !== start && nodeType(node) === wantedType) return node;
+        for (const input of node.inputs ?? []) {
+            const parent = inputConnection(node, input.name)?.source ?? null;
+            if (parent) queue.push(parent);
+        }
+    }
+    return null;
+}
+
+export function findScheduledRef2VA(start) {
+    return findDownstreamType(start, SCHEDULED_REF2VA_TYPE);
+}
+
+export function findTaggedRef2VA(start) {
+    return findDownstreamTypes(start, TAGGED_REF2VA_TYPES);
+}
+
+export function findCoreRef2VA(start) {
+    return findDownstreamType(start, CORE_REF2VA_TYPE);
+}
+
+export function findImageToVideo(start) {
+    return findDownstreamType(start, IMAGE_TO_VIDEO_TYPE);
+}
+
+export function findProjectAssetManager(start) {
+    return findUpstreamType(start, PROJECT_ASSET_MANAGER_TYPE);
+}
+
+export function collectScheduleNodes(wrapper) {
+    const result = [];
+    const seen = new Set();
+    let current = inputSource(wrapper, "reference_schedule");
+    while (current && SCHEDULE_TYPES.has(nodeType(current)) && !seen.has(current)) {
+        seen.add(current);
+        result.unshift(current);
+        current = inputSource(current, "previous");
+    }
+    return result;
+}
+
+export function collectTaggedNodes(wrapper) {
+    const result = [];
+    const seen = new Set();
+    let current = inputSource(wrapper, "references");
+    if (nodeType(current) === SEMANTIC_ANCHOR_BUNDLE_TYPE) {
+        current = inputSource(current, "references");
+    }
+    while (current && TAGGED_TYPES.has(nodeType(current)) && !seen.has(current)) {
+        seen.add(current);
+        result.unshift(current);
+        current = inputSource(current, "previous");
+    }
+    return result;
+}
+
+export function collectSemanticAnchorNodes(wrapper) {
+    const candidates = [
+        inputSource(wrapper, "references"),
+        inputSource(wrapper, "tagged_references"),
+    ];
+    const bundle = candidates.find(
+        (node) => nodeType(node) === SEMANTIC_ANCHOR_BUNDLE_TYPE,
+    );
+    if (nodeType(bundle) !== SEMANTIC_ANCHOR_BUNDLE_TYPE) {
+        return {bundle: null, nodes: []};
+    }
+    const nodes = [];
+    const seen = new Set();
+    let current = inputSource(bundle, "anchors");
+    while (current && nodeType(current) === SEMANTIC_PICTURE_ANCHOR_TYPE
+            && !seen.has(current)) {
+        seen.add(current);
+        nodes.unshift(current);
+        current = inputSource(current, "previous");
+    }
+    return {bundle, nodes};
+}
+
+export function referenceIsActive(selector, scene) {
+    const text = String(selector ?? "").trim().toLowerCase();
+    if (!text || text === "all" || text === "*") return true;
+    const target = Number(scene);
+    if (!Number.isInteger(target) || target < 1) return false;
+    return text.split(",").some((piece) => {
+        const match = piece.trim().match(/^(\d+)(?::(\d+))?$/);
+        if (!match) return false;
+        const first = Number(match[1]);
+        const last = Number(match[2] ?? match[1]);
+        return first <= target && target <= last;
+    });
+}
+
+function baseRecord(node, kind, scene, inputName, tagName = "tag") {
+    const selector = String(widgetValue(node, "scenes", ""));
+    return {
+        node,
+        kind,
+        tag: referenceTag(widgetValue(node, tagName, "")),
+        selector: selector.trim() || "all",
+        active: referenceIsActive(selector, scene),
+        source: inputSource(node, inputName),
+        label: null,
+    };
+}
+
+export function scheduledReferenceRecords(editorNode, scene) {
+    const wrapper = findScheduledRef2VA(editorNode);
+    if (!wrapper) return {wrapper: null, records: []};
+    const nodes = collectScheduleNodes(wrapper);
+    const pictures = [];
+    const videos = [];
+    const pairedAudios = [];
+    const audios = [];
+
+    for (const node of nodes) {
+        const type = nodeType(node);
+        if (type === PICTURE_REF_TYPE) {
+            pictures.push(baseRecord(node, "picture", scene, "image"));
+        } else if (type === VIDEO_REF_TYPE) {
+            const video = baseRecord(node, "video", scene, "video");
+            videos.push(video);
+            const audioSource = inputSource(node, "audio");
+            if (audioSource) {
+                const explicit = referenceTag(widgetValue(node, "audio_tag", ""));
+                pairedAudios.push({
+                    node,
+                    kind: "audio",
+                    tag: explicit || `${video.tag}_audio`,
+                    selector: video.selector,
+                    active: video.active,
+                    source: audioSource,
+                    label: null,
+                    pairedWith: video,
+                });
+            }
+        } else if (type === AUDIO_REF_TYPE) {
+            audios.push(baseRecord(node, "audio", scene, "audio"));
+        }
+    }
+
+    let ordinal = 0;
+    for (const item of pictures) {
+        if (item.active) item.label = `<Picture ${++ordinal}>`;
+    }
+    ordinal = 0;
+    for (const item of videos) {
+        if (item.active) item.label = `<Video ${++ordinal}>`;
+    }
+    ordinal = 0;
+    // Core Ref2VA numbers paired video soundtracks before standalone audio.
+    for (const item of pairedAudios) {
+        if (item.active) item.label = `<Audio ${++ordinal}>`;
+    }
+    for (const item of audios) {
+        if (item.active) item.label = `<Audio ${++ordinal}>`;
+    }
+
+    return {
+        wrapper,
+        mode: "scheduled",
+        records: [...pictures, ...videos, ...pairedAudios, ...audios]
+            .filter((item) => item.tag)
+            .map((item) => ({...item, token: `@${item.tag}`})),
+    };
+}
+
+function promptTagSet(prompt) {
+    return new Set([...String(prompt ?? "").matchAll(
+        /(?<![A-Za-z0-9_])@([A-Za-z][A-Za-z0-9_-]{0,63})/g,
+    )].map((match) => match[1]));
+}
+
+function semanticPromptTagState(prompt) {
+    const result = new Map();
+    for (const match of String(prompt ?? "").matchAll(
+        /(?<![A-Za-z0-9_])#([A-Za-z][A-Za-z0-9_-]{0,63})(?:\[([0-9]+(?:\.[0-9]+)?)s?\]|(?!\[))(?![A-Za-z0-9_-])/gi,
+    )) {
+        const tag = match[1];
+        const current = result.get(tag) ?? {untimed:false, timed:false};
+        if (match[2] === undefined) current.untimed = true;
+        else current.timed = true;
+        result.set(tag, current);
+    }
+    return result;
+}
+
+function projectCatalog(node) {
+    if (nodeType(node) !== PROJECT_ASSET_MANAGER_TYPE) return null;
+    try {
+        const value = JSON.parse(String(widgetValue(node, "catalog_json", "")));
+        return value && Array.isArray(value.assets) ? value : null;
+    } catch (_error) {
+        return null;
+    }
+}
+
+function projectPreviewUrl(catalog, asset, variant = "poster") {
+    const query = new URLSearchParams({
+        project: String(catalog?.project ?? ""),
+        asset: String(asset?.id ?? ""),
+        variant,
+    });
+    return `/minimax_h3_context_loop/project-assets/media?${query}`;
+}
+
+export function projectAssetReferenceRecords(manager, prompt = "") {
+    const catalog = projectCatalog(manager);
+    if (!catalog) return [];
+    const used = promptTagSet(prompt);
+    const semanticState = semanticPromptTagState(prompt);
+    const semanticUsed = new Set(semanticState.keys());
+    const pictures = [];
+    const semanticPictures = [];
+    const videos = [];
+    const pairedAudios = [];
+    const audios = [];
+    for (const asset of catalog.assets) {
+        if (!asset?.enabled || asset.role === "source_track") continue;
+        const tag = referenceTag(asset.tag);
+        if (!tag) continue;
+        const common = {
+            node: manager,
+            tag,
+            selector: asset.role === "semantic_anchor"
+                ? "semantic prompt tag" : "prompt tag",
+            source: manager,
+            assetId: String(asset.id ?? ""),
+            asset,
+        };
+        if (asset.role === "picture") {
+            pictures.push({
+                ...common, kind: "picture",
+                nativeActive: used.has(tag),
+                semanticActive: semanticUsed.has(tag),
+                active: used.has(tag) || semanticUsed.has(tag),
+                previewUrl: projectPreviewUrl(catalog, asset, "poster"),
+            });
+        } else if (asset.role === "semantic_anchor") {
+            semanticPictures.push({
+                ...common, kind: "picture", semanticOnly: true,
+                nativeActive: false, semanticActive: semanticUsed.has(tag),
+                active: semanticUsed.has(tag),
+                previewUrl: projectPreviewUrl(catalog, asset, "poster"),
+            });
+        } else if (["video", "motion"].includes(asset.role)) {
+            const options = asset.options ?? {};
+            const hasAudio = Boolean(
+                options.use_embedded_audio ?? asset.metadata?.has_audio);
+            const audioTag = referenceTag(options.audio_tag) || `${tag}_audio`;
+            const video = {
+                ...common, kind: "video",
+                semanticRole: asset.role === "motion" ? "motion" : "video",
+                tagActive: used.has(tag),
+                active: used.has(tag) || (hasAudio && used.has(audioTag)),
+                previewUrl: projectPreviewUrl(catalog, asset, "preview"),
+            };
+            videos.push(video);
+            if (hasAudio) pairedAudios.push({
+                ...common, kind: "audio", tag: audioTag,
+                active: video.active, pairedWith: video,
+                previewUrl: projectPreviewUrl(catalog, asset, "original"),
+            });
+        } else if (asset.role === "audio_reference") {
+            audios.push({
+                ...common, kind: "audio", active: used.has(tag),
+                previewUrl: projectPreviewUrl(catalog, asset, "original"),
+            });
+        }
+    }
+    let ordinal = 0;
+    for (const item of pictures) {
+        if (item.nativeActive) item.label = `<Picture ${++ordinal}>`;
+    }
+    ordinal = 0;
+    for (const item of videos) {
+        if (item.active) {
+            item.sourceLabel = `<Video ${++ordinal}>`;
+            item.label = item.sourceLabel;
+        }
+    }
+    const usedSubjects = [...String(prompt ?? "").matchAll(
+        /<Subject\s+(\d+)>/gi,
+    )].map((match) => Number(match[1]));
+    let subjectOrdinal = Math.max(0, ...usedSubjects) + 1;
+    for (const item of videos) {
+        if (item.active && item.semanticRole === "motion" && item.tagActive) {
+            item.label = `<Subject ${subjectOrdinal++}>`;
+        }
+    }
+    ordinal = 0;
+    for (const item of pairedAudios) {
+        if (item.active) item.label = `<Audio ${++ordinal}>`;
+    }
+    for (const item of audios) {
+        if (item.active) item.label = `<Audio ${++ordinal}>`;
+    }
+    const anchorMode = String(widgetValue(
+        manager, "semantic_anchor_mode", "timestamped_video"));
+    let pictureOrdinal = pictures.filter((item) => item.nativeActive).length;
+    let videoOrdinal = videos.filter((item) => item.active).length;
+    for (const item of [...pictures, ...semanticPictures]) {
+        if (!item.semanticActive) continue;
+        const timed = Boolean(semanticState.get(item.tag)?.timed);
+        item.semanticLabel = anchorMode === "timestamped_video" && timed
+            ? `<Video ${++videoOrdinal}>` : `<Picture ${++pictureOrdinal}>`;
+        if (!item.nativeActive) item.label = item.semanticLabel;
+    }
+    return [...pictures, ...semanticPictures, ...videos, ...pairedAudios, ...audios]
+        .map((item) => ({
+            ...item,
+            token: item.semanticOnly
+                ? taggedPictureReferenceToken(item.tag, "semantic")
+                : `@${item.tag}`,
+            nativeToken: item.semanticOnly ? null : `@${item.tag}`,
+            semanticToken: item.kind === "picture"
+                ? taggedPictureReferenceToken(item.tag, "semantic") : null,
+            supportsSemantic: item.kind === "picture" && !item.semanticOnly,
+        }));
+}
+
+export function taggedReferenceRecords(editorNode, prompt = "") {
+    const wrapper = findTaggedRef2VA(editorNode);
+    if (!wrapper) {
+        // Studio workflows can keep the render engine inside a subgraph while
+        // the Asset Carousel feeds Plan/Plan Studio upstream of this editor.
+        // The connected Carousel catalog remains authoritative even when no
+        // downstream Ref2VA wrapper is traversable from the editor.
+        const manager = findProjectAssetManager(editorNode);
+        return manager ? {
+            wrapper: manager,
+            mode: "tagged",
+            records: projectAssetReferenceRecords(manager, prompt),
+        } : {wrapper: null, mode: null, records: []};
+    }
+    const referenceSource = inputSource(wrapper, "references");
+    if (nodeType(referenceSource) === PROJECT_ASSET_MANAGER_TYPE) {
+        return {
+            wrapper,
+            mode: "tagged",
+            records: projectAssetReferenceRecords(referenceSource, prompt),
+        };
+    }
+    const nodes = collectTaggedNodes(wrapper);
+    const dedicated = collectSemanticAnchorNodes(wrapper);
+    const used = promptTagSet(prompt);
+    const semanticState = semanticPromptTagState(prompt);
+    const semanticUsed = new Set(semanticState.keys());
+    const pictures = [];
+    const videos = [];
+    const pairedAudios = [];
+    const audios = [];
+    const semanticPictures = [];
+
+    for (const node of nodes) {
+        const type = nodeType(node);
+        if (type === TAGGED_PICTURE_REF_TYPE) {
+            const record = baseRecord(node, "picture", 1, "image");
+            record.selector = "prompt tag";
+            record.nativeActive = used.has(record.tag);
+            record.semanticActive = semanticUsed.has(record.tag);
+            record.active = record.nativeActive || record.semanticActive;
+            pictures.push(record);
+        } else if (type === TAGGED_VIDEO_REF_TYPE ||
+                type === TAGGED_MOTION_REF_TYPE ||
+                type === TAGGED_MOTION_PATH_REF_TYPE ||
+                type === TAGGED_MOTION_TIMELINE_REF_TYPE) {
+            const pathBacked = type === TAGGED_MOTION_PATH_REF_TYPE;
+            const timelineBacked =
+                type === TAGGED_MOTION_TIMELINE_REF_TYPE;
+            const video = baseRecord(
+                node, "video", 1,
+                timelineBacked ? "source_timeline"
+                    : pathBacked ? "video_path" : "video");
+            const nativeVideoSource = pathBacked
+                ? inputSource(node, "source_video") : null;
+            const timelineSource = timelineBacked
+                ? inputSource(node, "source_timeline") : null;
+            if (pathBacked) video.source = nativeVideoSource || node;
+            if (timelineBacked) video.source = timelineSource || node;
+            video.selector = "prompt tag";
+            video.semanticRole = (
+                type === TAGGED_MOTION_REF_TYPE || pathBacked || timelineBacked)
+                ? "motion" : "video";
+            video.tagActive = used.has(video.tag);
+            const audioSource = inputSource(node, "audio");
+            const embeddedAudio = (
+                pathBacked && Boolean(
+                    widgetValue(node, "use_embedded_audio", true))) || (
+                timelineBacked && String(
+                    widgetValue(node, "paired_audio", "off")) === "embedded");
+            const explicit = referenceTag(widgetValue(node, "audio_tag", ""));
+            const audioTag = explicit || `${video.tag}_audio`;
+            video.active = video.tagActive || Boolean(
+                (audioSource || embeddedAudio) && used.has(audioTag));
+            videos.push(video);
+            if (audioSource || embeddedAudio) {
+                pairedAudios.push({
+                    node,
+                    kind: "audio",
+                    tag: audioTag,
+                    selector: "prompt tag",
+                    active: video.active,
+                    source: audioSource || nativeVideoSource
+                        || timelineSource || node,
+                    label: null,
+                    pairedWith: video,
+                });
+            }
+        } else if (type === TAGGED_AUDIO_REF_TYPE) {
+            const record = baseRecord(node, "audio", 1, "audio");
+            record.selector = "prompt tag";
+            record.active = used.has(record.tag);
+            audios.push(record);
+        }
+    }
+
+    for (const node of dedicated.nodes) {
+        const record = baseRecord(node, "picture", 1, "image");
+        record.selector = "semantic prompt tag";
+        record.nativeActive = false;
+        record.semanticActive = semanticUsed.has(record.tag);
+        record.active = record.semanticActive;
+        record.semanticOnly = true;
+        semanticPictures.push(record);
+    }
+
+    let ordinal = 0;
+    for (const item of pictures) {
+        if (item.nativeActive) item.label = `<Picture ${++ordinal}>`;
+    }
+    ordinal = 0;
+    const activeMotionRecords = [];
+    for (const item of videos) {
+        if (!item.active) continue;
+        item.sourceLabel = `<Video ${++ordinal}>`;
+        item.label = item.sourceLabel;
+        if (item.semanticRole === "motion" && item.tagActive) {
+            activeMotionRecords.push(item);
+        }
+    }
+    const usedSubjectNumbers = [...String(prompt ?? "").matchAll(
+        /<Subject\s+(\d+)>/gi,
+    )].map((match) => Number(match[1]));
+    let subjectOrdinal = Math.max(0, ...usedSubjectNumbers) + 1;
+    for (const item of activeMotionRecords) {
+        item.label = `<Subject ${subjectOrdinal++}>`;
+    }
+    ordinal = 0;
+    for (const item of pairedAudios) {
+        if (item.active) item.label = `<Audio ${++ordinal}>`;
+    }
+    for (const item of audios) {
+        if (item.active) item.label = `<Audio ${++ordinal}>`;
+    }
+    const anchorMode = String(widgetValue(
+        dedicated.bundle, "semantic_anchor_mode", "timestamped_video"));
+    let pictureOrdinal = pictures.filter((item) => item.nativeActive).length;
+    let videoOrdinal = videos.filter((item) => item.active).length;
+    for (const item of [...pictures, ...semanticPictures]) {
+        if (!item.semanticActive) continue;
+        const timed = Boolean(semanticState.get(item.tag)?.timed);
+        item.semanticLabel = anchorMode === "timestamped_video" && timed
+            ? `<Video ${++videoOrdinal}>` : `<Picture ${++pictureOrdinal}>`;
+        if (!item.nativeActive) item.label = item.semanticLabel;
+    }
+    return {
+        wrapper,
+        mode: "tagged",
+        records: [
+            ...pictures, ...semanticPictures, ...videos, ...pairedAudios, ...audios,
+        ]
+            .filter((item) => item.tag)
+            .map((item) => ({
+                ...item,
+                token: item.semanticOnly
+                    ? taggedPictureReferenceToken(item.tag, "semantic")
+                    : `@${item.tag}`,
+                nativeToken: item.semanticOnly ? null : `@${item.tag}`,
+                semanticToken: item.kind === "picture"
+                    ? taggedPictureReferenceToken(item.tag, "semantic") : null,
+                supportsSemantic: item.kind === "picture" && !item.semanticOnly,
+            })),
+    };
+}
+
+function numberedInputRecords(wrapper, pattern, kind, labelKind) {
+    const records = [];
+    for (const input of wrapper?.inputs ?? []) {
+        const match = String(input.name ?? "").match(pattern);
+        if (!match || input.link == null) continue;
+        const index = Number(match[1]);
+        const label = `<${labelKind} ${index + 1}>`;
+        records.push({
+            node: wrapper,
+            kind,
+            tag: "",
+            token: label,
+            selector: "all",
+            active: true,
+            source: inputSource(wrapper, input.name),
+            label,
+            index,
+            mode: "native",
+        });
+    }
+    records.sort((left, right) => left.index - right.index);
+    return records;
+}
+
+export function coreReferenceRecords(editorNode) {
+    const wrapper = findCoreRef2VA(editorNode);
+    if (!wrapper) return {wrapper: null, mode: null, records: []};
+    const pictures = numberedInputRecords(
+        wrapper, /^ref_images\.ref_image_(\d+)$/, "picture", "Picture");
+    const videos = numberedInputRecords(
+        wrapper, /^ref_videos\.ref_video_(\d+)$/, "video", "Video");
+    const pairedAudios = numberedInputRecords(
+        wrapper, /^ref_video_audios\.ref_video_audio_(\d+)$/, "audio", "Audio");
+    const audios = numberedInputRecords(
+        wrapper, /^ref_audios\.ref_audio_(\d+)$/, "audio", "Audio");
+    // Audio labels are shared across video-paired and standalone references.
+    [...pairedAudios, ...audios].forEach((item, index) => {
+        item.label = `<Audio ${index + 1}>`;
+        item.token = item.label;
+    });
+    return {
+        wrapper,
+        mode: "native",
+        records: [...pictures, ...videos, ...pairedAudios, ...audios],
+    };
+}
+
+function selectedFrameSource(source, scene) {
+    if (nodeType(source) !== FRAME_INDEX_SWITCH_TYPE) return source;
+    const frames = [];
+    for (let index = 1; index <= 8; index += 1) {
+        const frame = inputSource(source, `frame_${index}`);
+        if (frame) frames.push(frame);
+    }
+    if (!frames.length) return source;
+    const requested = Math.max(1, Number.isFinite(Number(scene))
+        ? Math.trunc(Number(scene)) : 1);
+    return frames[(requested - 1) % frames.length];
+}
+
+function keyframePreviewSource(connection, role, scene) {
+    let source = connection?.source ?? null;
+    if (!source) return null;
+
+    // The frame gate exposes both first_frame and last_frame from the same
+    // node. Starting a generic upstream search at that node always encounters
+    // its opening `image` first, which made Picture 2 preview Picture 1. Follow
+    // the input that corresponds to the I2V socket instead.
+    if (nodeType(source) === FIRST_SCENE_IMAGE_TYPE) {
+        source = inputSource(source, role === "first" ? "image" : "last_frame")
+            ?? source;
+    }
+    return selectedFrameSource(source, scene);
+}
+
+export function imageToVideoReferenceRecords(editorNode, scene = 1) {
+    const wrapper = findImageToVideo(editorNode);
+    if (!wrapper) return {wrapper: null, mode: null, records: []};
+    const firstConnection = inputConnection(wrapper, "first_frame");
+    const lastConnection = inputConnection(wrapper, "last_frame");
+    const firstFrame = firstConnection?.source ?? null;
+    const lastFrame = lastConnection?.source ?? null;
+    const records = [];
+    let firstActive = false;
+    if (firstFrame) {
+        const firstSceneOnly = nodeType(firstFrame) === FIRST_SCENE_IMAGE_TYPE;
+        const active = !firstSceneOnly || Number(scene) === 1;
+        firstActive = active;
+        records.push({
+            node: wrapper,
+            kind: "picture",
+            tag: "",
+            token: "<Picture 1>",
+            selector: firstSceneOnly ? "1" : "all",
+            active,
+            source: keyframePreviewSource(firstConnection, "first", scene),
+            label: "<Picture 1>",
+            mode: "native",
+            role: "first frame",
+        });
+    }
+    if (lastFrame) {
+        const ordinal = firstActive ? 2 : 1;
+        records.push({
+            node: wrapper,
+            kind: "picture",
+            tag: "",
+            token: `<Picture ${ordinal}>`,
+            selector: "all",
+            active: true,
+            source: keyframePreviewSource(lastConnection, "last", scene),
+            label: `<Picture ${ordinal}>`,
+            mode: "native",
+            role: "last frame",
+        });
+    }
+    return {wrapper, mode: "native_keyframes", records};
+}
+
+export function referencePreviewRecords(editorNode, scene, {prompt = ""} = {}) {
+    const tagged = taggedReferenceRecords(editorNode, prompt);
+    if (tagged.wrapper) return tagged;
+    const scheduled = scheduledReferenceRecords(editorNode, scene);
+    if (scheduled.wrapper) return scheduled;
+    const core = coreReferenceRecords(editorNode);
+    if (core.wrapper) return core;
+    return imageToVideoReferenceRecords(editorNode, scene);
+}
+
+export function availableReferenceRecords(
+    editorNode, scene, {includeInactive = false, prompt = ""} = {},
+) {
+    const result = referencePreviewRecords(editorNode, scene, {prompt});
+    return {
+        ...result,
+        records: result.records.filter(
+            (record) => record.source && (includeInactive || record.active),
+        ),
+    };
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_rich_prompt_editor_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_rich_prompt_editor_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..011393c0d0c0715b4a4c8ced36a544f3f5108e60
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_rich_prompt_editor_core.mjs
@@ -0,0 +1,227 @@
+import {H3_ALL_SECTIONS} from "./h3_prompt_schema_core.mjs?v=0.6.5";
+
+export const RICH_PROMPT_GUIDES = Object.freeze([
+    {id: "auto", label: "Auto · H3 mode"},
+    {id: "general", label: "H3 General"},
+    {id: "continuity", label: "Chain continuity"},
+    {id: "music_video", label: "Music video"},
+    {id: "dialogue", label: "Dialogue + voice"},
+    {id: "brand_promo", label: "Brand / product"},
+    {id: "animation", label: "3D animation"},
+    {id: "handdrawn", label: "Hand-drawn + live"},
+    {id: "paper", label: "Paper / stop motion"},
+]);
+
+const GUIDE_RULES = Object.freeze({
+    auto: "Choose the most appropriate H3 treatment from the prompt and connected conditioning mode.",
+    general: "Prioritize concrete composition, action, camera, performance, lighting, synchronized sound, and an executable ending state.",
+    continuity: "Prioritize a physically continuous opening from the previous scene and a visible unfinished handoff into the next scene. Do not add a cut unless requested.",
+    music_video: "Prioritize beat-aware performance, exact lyric/dialogue timing, camera rhythm, readable performer identity, and explicit diegetic versus non-diegetic audio.",
+    dialogue: "Prioritize speaker identity, vocal-reference mapping, exact <d> dialogue, language, delivery, mouth timing, ambience, and separation from soundtrack references.",
+    brand_promo: "Prioritize verified product appearance, a clear visual selling point, restrained readable text, precise beat structure, and no invented brand claims.",
+    animation: "Prioritize character silhouettes, readable staging, expressive poses, material/style continuity, motivated camera movement, and clean action beats.",
+    handdrawn: "Prioritize physical contact between live action and drawn elements, one continuous transformation, tactile line behavior, and camera reaction lag.",
+    paper: "Prioritize tactile paper materials, layered depth, handmade shadows, stop-motion cadence, practical transitions, and restrained paper sound effects.",
+});
+
+export function normalizeRichGuide(value) {
+    const id = String(value ?? "auto");
+    return RICH_PROMPT_GUIDES.some((item) => item.id === id) ? id : "auto";
+}
+
+export function richGenerationMode(referenceMode) {
+    if (["tagged", "scheduled", "native"].includes(referenceMode)) return "Ref2VA";
+    if (referenceMode === "native_keyframes") return "I2VA/FL2VA";
+    return "H3 chain scene";
+}
+
+export function richGuideInstruction(guide, generationMode) {
+    const selected = normalizeRichGuide(guide);
+    const mode = String(generationMode || "H3 chain scene");
+    const schema = mode === "Ref2VA"
+        ? "If the source already uses the Ref2VA six-section format, preserve its order: subject_definitions, summary, retention_analysis, detailed_description, overall_soundscape, non_diegetic_music. Introduce that complete format only when the user explicitly asks for a full H3 rewrite. Keep every reference label, @alias, bare #picture semantic visual, and #picture[timestamp] semantic anchor stable."
+        : "If the source already uses the base H3 format, preserve integrated_multimodal_description, overall_soundscape, and non_diegetic_music. Introduce the complete format or keyframe-alignment sentence only when the user explicitly asks for a full H3 rewrite; do not force headings onto a compact prompt.";
+    return [
+        `Return a complete replacement string for the current MiniMax H3 ${mode} scene, but change only what the request requires.`,
+        schema,
+        GUIDE_RULES[selected],
+        "Preserve exact dialogue and lyrics inside <d> tags, their language, explicit timing, subject identity, wardrobe, camera continuity, and all valid media references unless the source explicitly asks to change them.",
+        "Connected references prove only that an asset and its media type are available. Do not invent image content, motion, lyrics, voice, timbre, or an audio copy/reference role. Use only facts stated in the prompt or shared/adjacent context, or media actually attached by the configured backend and directly observable to its model; otherwise preserve the reference token without elaboration.",
+        "Keep all described events and cut times inside the supplied scene duration.",
+        "Return a complete replacement rather than commentary, a patch, or an ellipsis.",
+    ].join(" ");
+}
+
+function recordTokens(record) {
+    const tokens = [record?.token, record?.label];
+    const explicitTag = String(record?.tag ?? "")
+        .trim().replace(/^[@#]+/, "");
+    const tokenTag = /^@([A-Za-z][A-Za-z0-9_-]{0,63})$/
+        .exec(String(record?.nativeToken ?? record?.token ?? "").trim())?.[1];
+    const canonicalTag = explicitTag || tokenTag;
+    if (canonicalTag) tokens.push(`#${canonicalTag}`);
+    return tokens
+        .map((value) => String(value ?? "").trim())
+        .filter(Boolean);
+}
+
+export function referenceRecordMap(records) {
+    const map = new Map();
+    for (const record of Array.isArray(records) ? records : []) {
+        for (const token of recordTokens(record)) map.set(token, record);
+    }
+    return map;
+}
+
+// Keep this alias grammar aligned with chain_nodes.py's reference compiler.
+// In particular, sentence punctuation such as the period in "Use @hero."
+// belongs to the surrounding prompt, not to the decorated reference token.
+const RICH_SECTION_ALTERNATION = H3_ALL_SECTIONS.join("|");
+const RICH_TOKEN_PATTERN = new RegExp(
+    `^(${RICH_SECTION_ALTERNATION}):|`
+    + "((?<![A-Za-z0-9_])#[A-Za-z][A-Za-z0-9_-]{0,63}(?:\\[[0-9]+(?:\\.[0-9]+)?s?\\]|(?!\\[))(?![A-Za-z0-9_-])"
+    + "|(?<![A-Za-z0-9_])@[A-Za-z][A-Za-z0-9_-]{0,63}(?![A-Za-z0-9_-])"
+    + "|<(?:Picture|Video|Audio|Subject)\\s+\\d+>|<\\/?d>|<scenetrans>|<cutoff>|<\\|(?:cutoff|lyrics_start|lyrics_end|caption_start|caption_end)\\|>"
+    + "|(?<![A-Za-z0-9_])\\(S\\d+(?:,S\\d+)*\\))",
+    "gim",
+);
+
+export function tokenizeRichPrompt(text, records = []) {
+    const source = String(text ?? "");
+    const recordMap = referenceRecordMap(records);
+    const parts = [];
+    let offset = 0;
+    for (const match of source.matchAll(RICH_TOKEN_PATTERN)) {
+        const index = match.index ?? 0;
+        if (index > offset) parts.push({type: "text", text: source.slice(offset, index)});
+        const token = match[0];
+        const lower = token.toLowerCase();
+        const section = lower.endsWith(":")
+            ? H3_ALL_SECTIONS.find((item) => `${item}:` === lower) : null;
+        const semanticMatch = /^#([a-z][a-z0-9_-]{0,63})(?:\[([0-9]+(?:\.[0-9]+)?)s?\])?$/i.exec(token);
+        // A semantic-only asset has no native @tag token. Resolve bare #tag
+        // and #tag[time] through the timestamp-independent registered key.
+        const recordKey = semanticMatch ? `#${semanticMatch[1]}` : token;
+        const record = recordMap.get(recordKey) ?? null;
+        if (section) {
+            parts.push({type:"section", kind:"section", text:token, section, unresolved:false});
+        } else if (record || lower.startsWith("@") || semanticMatch || /^<(?:picture|video|audio)\s/i.test(lower)) {
+            const namedKind = lower.startsWith("<picture") ? "picture"
+                : lower.startsWith("<video") ? "video"
+                    : lower.startsWith("<audio") ? "audio" : null;
+            const semanticValid = !semanticMatch || record?.kind === "picture";
+            parts.push({
+                type: "reference",
+                text: token,
+                kind: record?.kind ?? namedKind ?? "unknown",
+                record,
+                unresolved: !record || !semanticValid,
+                semantic: Boolean(semanticMatch),
+                timestamp: semanticMatch?.[2] !== undefined
+                    ? Number(semanticMatch[2]) : null,
+            });
+        } else if (lower.startsWith("<subject")) {
+            parts.push({type: "subject", text: token});
+        } else if (lower === "<scenetrans>" || lower === "<cutoff>" || lower === "<|cutoff|>") {
+            parts.push({type:"flow", kind:"flow", text:token, unresolved:false});
+        } else if (/^<\|(?:lyrics|caption)_/.test(lower)) {
+            parts.push({type:"dialogue", text:token});
+        } else if (lower.startsWith("(s")) {
+            parts.push({type:"speaker", kind:"speaker", text:token, unresolved:false});
+        } else {
+            parts.push({type: "dialogue", text: token});
+        }
+        offset = index + token.length;
+    }
+    if (offset < source.length) parts.push({type: "text", text: source.slice(offset)});
+    return parts;
+}
+
+export function optimizerSource(currentPrompt, previous = null) {
+    const current = String(currentPrompt ?? "");
+    if (previous && current === String(previous.result ?? "")) {
+        return String(previous.source ?? current);
+    }
+    return current;
+}
+
+function undoInputGroup(inputType) {
+    const type = String(inputType ?? "");
+    if (type === "insertText") return "typing";
+    if (type === "deleteContentBackward") return "backspace";
+    if (type === "deleteContentForward") return "delete";
+    return "";
+}
+
+export function promptUndoDirection(event) {
+    if (!event || event.altKey || !(event.ctrlKey || event.metaKey)) return null;
+    const key = String(event.key ?? "").toLowerCase();
+    if (key === "z") return event.shiftKey ? "redo" : "undo";
+    if (key === "y" && !event.shiftKey) return "redo";
+    return null;
+}
+
+/** Text-level undo survives contenteditable token decoration, which replaces
+ * DOM children and therefore discards the browser's native undo manager. */
+export class PromptUndoHistory {
+    constructor(initialText = "", {limit = 100, coalesceMs = 750} = {}) {
+        this.limit = Math.max(1, Math.trunc(Number(limit) || 100));
+        this.coalesceMs = Math.max(0, Number(coalesceMs) || 0);
+        this.reset(initialText);
+    }
+
+    reset(text = "") {
+        this.current = String(text ?? "");
+        this.undoStack = [];
+        this.redoStack = [];
+        this.lastGroup = "";
+        this.lastTime = 0;
+        return this.current;
+    }
+
+    align(text = "") {
+        const value = String(text ?? "");
+        if (value === this.current) return false;
+        this.reset(value);
+        return true;
+    }
+
+    record(text, {inputType = "", now = Date.now()} = {}) {
+        const value = String(text ?? "");
+        if (value === this.current) return false;
+        const group = undoInputGroup(inputType);
+        const timestamp = Number(now) || 0;
+        const coalesced = Boolean(
+            group && group === this.lastGroup
+            && timestamp - this.lastTime >= 0
+            && timestamp - this.lastTime <= this.coalesceMs
+        );
+        if (!coalesced) {
+            this.undoStack.push(this.current);
+            if (this.undoStack.length > this.limit) this.undoStack.shift();
+        }
+        this.current = value;
+        this.redoStack = [];
+        this.lastGroup = group;
+        this.lastTime = timestamp;
+        return true;
+    }
+
+    undo() {
+        if (!this.undoStack.length) return null;
+        this.redoStack.push(this.current);
+        this.current = this.undoStack.pop();
+        this.lastGroup = "";
+        this.lastTime = 0;
+        return this.current;
+    }
+
+    redo() {
+        if (!this.redoStack.length) return null;
+        this.undoStack.push(this.current);
+        this.current = this.redoStack.pop();
+        this.lastGroup = "";
+        this.lastTime = 0;
+        return this.current;
+    }
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_run_assets_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_run_assets_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..dd1dfe6a0a2e43ccc90f545675ef26d7147d301e
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_run_assets_core.mjs
@@ -0,0 +1,216 @@
+export const MAX_ASSET_BINDINGS = 12;
+export const ASSET_ROLES = Object.freeze([
+    ["picture", "Picture"],
+    ["video", "Video"],
+    ["audio_reference", "Audio reference"],
+    ["source_track", "Source track"],
+]);
+export const SEMANTIC_ANCHOR_BUNDLE_NODE = "MiniMaxH3SemanticAnchorBundle";
+export const SEMANTIC_PICTURE_ANCHOR_NODE = "MiniMaxH3SemanticPictureAnchor";
+
+const MEDIA_WIDGET_NAMES = ["image", "audio", "file", "video", "path", "filename"];
+const MEDIA_EXTENSION = /\.(?:png|jpe?g|webp|gif|bmp|tiff?|wav|mp3|flac|ogg|m4a|aac|mp4|mov|mkv|webm|avi)(?:\s+\[(?:input|output|temp)\])?$/i;
+
+export function assetInputNumber(input) {
+    const match = /^asset_(\d+)$/.exec(String(input?.name ?? ""));
+    return match ? Number(match[1]) : null;
+}
+
+export function nodeType(node) {
+    return node?.comfyClass ?? node?.type ?? "";
+}
+
+export function mediaWidget(node, preferred = "") {
+    const widgets = node?.widgets ?? [];
+    if (preferred) {
+        const exact = widgets.find((widget) => widget.name === preferred);
+        if (exact) return exact;
+    }
+    for (const name of MEDIA_WIDGET_NAMES) {
+        const widget = widgets.find((item) => item.name === name
+            && typeof item.value === "string");
+        if (widget) return widget;
+    }
+    return widgets.find((widget) => typeof widget.value === "string"
+        && MEDIA_EXTENSION.test(widget.value.trim())) ?? null;
+}
+
+export function inferAssetRole(outputType, sourceType = "") {
+    const type = String(outputType ?? "").toUpperCase();
+    if (type === "VIDEO" || /video/i.test(sourceType)) return "video";
+    if (type === "AUDIO" || /audio/i.test(sourceType)) return "audio_reference";
+    return "picture";
+}
+
+function randomBindingId() {
+    if (typeof globalThis.crypto?.randomUUID === "function") {
+        return globalThis.crypto.randomUUID();
+    }
+    const random = Math.random().toString(16).slice(2);
+    return `asset-${Date.now().toString(16)}-${random}`;
+}
+
+function sourceForInput(manager, input) {
+    const link = input?.link == null ? null : manager?.graph?.links?.[input.link];
+    const source = link ? manager.graph?.getNodeById?.(link.origin_id) : null;
+    return source ? {source, link} : null;
+}
+
+function inputByName(node, name) {
+    return node?.inputs?.find((input) => input.name === name) ?? null;
+}
+
+function linkedNode(node, inputName) {
+    const input = inputByName(node, inputName);
+    const link = input?.link == null ? null : node?.graph?.links?.[input.link];
+    const source = link ? node.graph?.getNodeById?.(link.origin_id) : null;
+    return source ? {source, link, input} : null;
+}
+
+function sourceBinding(manager, source, link, createId, {
+    input = null, roleOverride = "", labelPrefix = "",
+} = {}) {
+    source.properties ??= {};
+    const outputSlot = Number(link.origin_slot) || 0;
+    source.properties.h3_asset_binding_ids ??= {};
+    source.properties.h3_asset_binding_ids[outputSlot] ||= (
+        (outputSlot === 0 && source.properties.h3_asset_binding_id)
+        || createId()
+    );
+    const bindingId = source.properties.h3_asset_binding_ids[outputSlot];
+    const output = source.outputs?.[outputSlot] ?? {};
+    const widget = mediaWidget(source);
+    const inferred = roleOverride || inferAssetRole(output.type, nodeType(source));
+    const role = manager.properties.h3_asset_roles[bindingId] ?? inferred;
+    manager.properties.h3_asset_roles[bindingId] = role;
+    const title = String(source.title || nodeType(source) || `Node ${source.id}`);
+    if (input) input.label = `${assetInputNumber(input)}: ${title}`;
+    return {
+        binding_id: bindingId,
+        label: labelPrefix ? `${labelPrefix} · ${title}` : title,
+        role,
+        node_id: String(source.id ?? ""),
+        node_type: nodeType(source),
+        node_title: String(source.title ?? ""),
+        output_slot: outputSlot,
+        output_type: String(output.type ?? ""),
+        widget_name: String(widget?.name ?? ""),
+        original_value: typeof widget?.value === "string" ? widget.value : "",
+    };
+}
+
+export function collectSemanticAnchorBindings(manager, createId = randomBindingId) {
+    manager.properties ??= {};
+    manager.properties.h3_asset_roles ??= {};
+    const bundleLink = linkedNode(manager, "tagged_references");
+    if (!bundleLink || nodeType(bundleLink.source) !== SEMANTIC_ANCHOR_BUNDLE_NODE) {
+        return [];
+    }
+    const bindings = [];
+    const seenNodes = new Set();
+    let linked = linkedNode(bundleLink.source, "anchors");
+    while (linked && nodeType(linked.source) === SEMANTIC_PICTURE_ANCHOR_NODE
+            && !seenNodes.has(linked.source)) {
+        const anchor = linked.source;
+        seenNodes.add(anchor);
+        const tag = String(anchor.widgets?.find((item) => item.name === "tag")?.value
+            ?? "semantic").trim();
+        const image = linkedNode(anchor, "image");
+        if (image) {
+            bindings.push(sourceBinding(manager, image.source, image.link, createId, {
+                roleOverride: "picture",
+                labelPrefix: `#${tag || "semantic"}`,
+            }));
+        }
+        linked = linkedNode(anchor, "previous");
+    }
+    return bindings.reverse();
+}
+
+export function collectAssetBindings(manager, createId = randomBindingId) {
+    manager.properties ??= {};
+    manager.properties.h3_asset_roles ??= {};
+    const bindings = [];
+    for (const input of manager.inputs ?? []) {
+        const number = assetInputNumber(input);
+        if (number == null || input.link == null) continue;
+        const linked = sourceForInput(manager, input);
+        if (!linked) continue;
+        const {source, link} = linked;
+        bindings.push(sourceBinding(
+            manager, source, link, createId, {input}));
+    }
+    const seen = new Set(bindings.map((binding) => binding.binding_id));
+    for (const binding of collectSemanticAnchorBindings(manager, createId)) {
+        if (seen.has(binding.binding_id)) continue;
+        seen.add(binding.binding_id);
+        bindings.push(binding);
+    }
+    return bindings;
+}
+
+function graphNodes(graph) {
+    return graph?._nodes ?? graph?.nodes ?? [];
+}
+
+function compatibleLoader(node, binding) {
+    const widget = mediaWidget(node, binding.widget_name);
+    if (!widget) return false;
+    const output = node.outputs?.[Number(binding.output_slot)]
+        ?? node.outputs?.find((item) => item.type === binding.output_type);
+    return !binding.output_type || output?.type === binding.output_type;
+}
+
+export function findAssetTarget(graph, binding) {
+    const nodes = graphNodes(graph);
+    const persistent = nodes.filter((node) =>
+        (node?.properties?.h3_asset_binding_ids?.[Number(binding.output_slot)]
+            === binding.binding_id
+        || node?.properties?.h3_asset_binding_id === binding.binding_id)
+        && compatibleLoader(node, binding));
+    if (persistent.length === 1) return {node: persistent[0], match: "binding"};
+
+    const byId = graph?.getNodeById?.(binding.node_id)
+        ?? graph?.getNodeById?.(Number(binding.node_id));
+    if (byId && nodeType(byId) === binding.node_type
+            && compatibleLoader(byId, binding)) {
+        return {node: byId, match: "node_id"};
+    }
+
+    const sameType = nodes.filter((node) => nodeType(node) === binding.node_type
+        && compatibleLoader(node, binding));
+    if (sameType.length === 1) return {node: sameType[0], match: "compatible_type"};
+
+    const compatible = nodes.filter((node) => compatibleLoader(node, binding));
+    if (compatible.length === 1) return {node: compatible[0], match: "compatible_loader"};
+    return {
+        node: null,
+        match: compatible.length || sameType.length || persistent.length
+            ? "ambiguous" : "missing",
+    };
+}
+
+export function applyAssetBinding(graph, binding) {
+    if (!binding?.restore_value) {
+        return {applied: false, reason: "media_missing", binding};
+    }
+    const target = findAssetTarget(graph, binding);
+    if (!target.node) return {applied: false, reason: target.match, binding};
+    const widget = mediaWidget(target.node, binding.widget_name);
+    if (!widget) return {applied: false, reason: "widget_missing", binding};
+    const previous = widget.value;
+    const options = widget.options?.values;
+    if (Array.isArray(options) && !options.includes(binding.restore_value)) {
+        options.push(binding.restore_value);
+        options.sort((left, right) => String(left).localeCompare(String(right)));
+    }
+    widget.value = binding.restore_value;
+    widget.callback?.(binding.restore_value);
+    target.node.onWidgetChanged?.(
+        widget.name, binding.restore_value, previous, widget);
+    target.node.properties ??= {};
+    target.node.properties.h3_asset_binding_ids ??= {};
+    target.node.properties.h3_asset_binding_ids[Number(binding.output_slot) || 0]
+        = binding.binding_id;
+    return {applied: true, match: target.match, node: target.node, binding};
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_run_manager_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_run_manager_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..ab8c92948561924930e4a9f077e504a55d9bf873
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_run_manager_core.mjs
@@ -0,0 +1,30 @@
+export function normalizeRunName(value) {
+    return String(value ?? "").trim();
+}
+
+export function runManagerIdentity(activeRunName, selectedRun) {
+    const active = normalizeRunName(activeRunName);
+    const selected = normalizeRunName(selectedRun?.run_name);
+    const same = Boolean(active && selected && active === selected);
+    return {
+        active,
+        selected,
+        same,
+        activeLabel: active ? `Active Plan: ${active}` : "Active Plan: not named",
+        selectedLabel: selected
+            ? `Selected archive: ${selected}${same ? " (active)" : " (not loaded)"}`
+            : "Selected archive: none",
+        loadLabel: same ? "Reload selected archive" : "Load selected archive into Plan",
+        saveLabel: active ? `Save assets to active Plan “${active}”` : "Save assets to active Plan",
+    };
+}
+
+export function runArchiveOptionLabel(run, activeRunName) {
+    const name = normalizeRunName(run?.run_name);
+    const scene = run?.scene_count == null
+        ? (run?.restorable ? "" : " · assets only")
+        : ` · ${run.scene_count} scenes`;
+    const active = name && name === normalizeRunName(activeRunName)
+        ? " · ACTIVE PLAN" : "";
+    return `${name}${scene}${active}`;
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_scene_data_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_scene_data_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..89e799d17cdc7a6f9f5b6dae59173080937acf1e
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_scene_data_core.mjs
@@ -0,0 +1,33 @@
+export const SCENE_DATA_FIELDS = Object.freeze({
+    "RefMod sources": Object.freeze({name: "refmod_sources", type: "H3_REF_LIST"}),
+    "Compiled prompt": Object.freeze({name: "compiled_prompt", type: "STRING"}),
+    "Active references": Object.freeze({name: "active_references", type: "STRING"}),
+    "Reference fingerprint": Object.freeze({name: "reference_fingerprint", type: "STRING"}),
+    "Scene prompt": Object.freeze({name: "prompt", type: "STRING"}),
+    "Scene number": Object.freeze({name: "clip_index", type: "INT"}),
+    "Scene count": Object.freeze({name: "clip_count", type: "INT"}),
+    "Shot ID": Object.freeze({name: "shot_id", type: "STRING"}),
+    "Noise seed": Object.freeze({name: "noise_seed", type: "INT"}),
+    "Raw length": Object.freeze({name: "length", type: "INT"}),
+    "Steps": Object.freeze({name: "steps", type: "INT"}),
+    "Width": Object.freeze({name: "width", type: "INT"}),
+    "Height": Object.freeze({name: "height", type: "INT"}),
+    "Audio start": Object.freeze({name: "audio_start", type: "FLOAT"}),
+    "Audio duration": Object.freeze({name: "audio_duration", type: "FLOAT"}),
+    "Source audio slice": Object.freeze({name: "source_audio_slice", type: "AUDIO"}),
+    "Status": Object.freeze({name: "status", type: "STRING"}),
+    "Reference image size": Object.freeze({name: "ref_image_size", type: "STRING"}),
+    "Reference policy": Object.freeze({name: "reference_policy", type: "STRING"}),
+    "Semantic anchor size": Object.freeze({name: "semantic_anchor_size", type: "STRING"}),
+    "Semantic anchor mode": Object.freeze({name: "semantic_anchor_mode", type: "STRING"}),
+    "Cache for upscale": Object.freeze({name: "cache_for_upscale", type: "BOOLEAN"}),
+    "Conditioning backend": Object.freeze({name: "conditioning_backend", type: "STRING"}),
+    "Align audio reference": Object.freeze({name: "align_audio_reference", type: "BOOLEAN"}),
+});
+
+const FALLBACK_FIELD = "RefMod sources";
+
+export function sceneDataFieldPresentation(field) {
+    const label = String(field ?? "");
+    return SCENE_DATA_FIELDS[label] ?? SCENE_DATA_FIELDS[FALLBACK_FIELD];
+}
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_scene_data_extract.js b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_scene_data_extract.js
new file mode 100644
index 0000000000000000000000000000000000000000..42653872ef95e2805f9875d1ae6458d9f119a5c4
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_scene_data_extract.js
@@ -0,0 +1,55 @@
+import {app} from "../../scripts/app.js";
+import {sceneDataFieldPresentation} from "./h3_scene_data_core.mjs?v=0.6.2";
+
+const NODE_NAME = "MiniMaxH3SceneDataExtract";
+
+function fieldWidget(node) {
+    return node.widgets?.find((widget) => widget.name === "field") ?? null;
+}
+
+function refreshOutput(node) {
+    const output = node.outputs?.[0];
+    if (!output) return;
+    const presentation = sceneDataFieldPresentation(fieldWidget(node)?.value);
+    output.name = presentation.name;
+    output.label = presentation.name;
+    output.type = presentation.type;
+    node.setDirtyCanvas?.(true, true);
+}
+
+function install(node) {
+    const widget = fieldWidget(node);
+    if (!widget || widget._h3SceneDataWrapped) {
+        refreshOutput(node);
+        return;
+    }
+    widget._h3SceneDataWrapped = true;
+    const original = widget.callback;
+    widget.callback = function () {
+        const result = original?.apply(this, arguments);
+        refreshOutput(node);
+        return result;
+    };
+    refreshOutput(node);
+}
+
+app.registerExtension({
+    name: "minimax.h3.sceneDataExtract",
+    async beforeRegisterNodeDef(nodeType, nodeData) {
+        if (nodeData.name !== NODE_NAME) return;
+
+        const created = nodeType.prototype.onNodeCreated;
+        nodeType.prototype.onNodeCreated = function () {
+            const result = created?.apply(this, arguments);
+            install(this);
+            return result;
+        };
+
+        const configured = nodeType.prototype.onConfigure;
+        nodeType.prototype.onConfigure = function () {
+            const result = configured?.apply(this, arguments);
+            install(this);
+            return result;
+        };
+    },
+});
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_socket_presentation.js b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_socket_presentation.js
new file mode 100644
index 0000000000000000000000000000000000000000..4e2207133e51c2e4465c8dbf8c842d26f2dbc581
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_socket_presentation.js
@@ -0,0 +1,177 @@
+import {app} from "/scripts/app.js";
+import {
+    ADVANCED_POLICY_NODE,
+    CHAIN_POLICY_NODE,
+    LEGACY_POLICY_NODE,
+    MODERN_PLAN_NODE,
+    PLAN_NODE,
+    PROFILE_POLICY_NODE,
+    applySocketPresentation,
+    hasAdvancedPresentation,
+    nodeType,
+    policyPlanConsumers,
+    presentationForNode,
+} from "./h3_socket_presentation_core.mjs?v=0.6.6";
+
+const EXTENSION = "minimax_h3_context_loop.socket_presentation";
+const WATCHED_POLICY_NODES = new Set([
+    PROFILE_POLICY_NODE, CHAIN_POLICY_NODE, ADVANCED_POLICY_NODE,
+    LEGACY_POLICY_NODE, PLAN_NODE, MODERN_PLAN_NODE,
+]);
+const WIDGET_LABELS = Object.freeze({
+    [PROFILE_POLICY_NODE]: Object.freeze({
+        scene_continuity:"Scene continuity",
+        audio_profile:"Audio profile",
+    }),
+});
+
+function collapseWidget(widget) {
+    if (!widget || widget.h3PresentationHidden) return;
+    widget.h3PresentationHidden = true;
+    widget.h3PresentationOriginal = {
+        type: widget.type,
+        hidden: widget.hidden,
+        computeSize: widget.computeSize,
+        draw: widget.draw,
+    };
+    widget.hidden = true;
+    widget.type = "hidden";
+    widget.computeSize = () => [0, -4];
+    widget.draw = () => {};
+    for (const item of new Set([widget.inputEl, widget.element])) {
+        if (!item?.style) continue;
+        item.style.setProperty("display", "none", "important");
+        item.style.setProperty("pointer-events", "none", "important");
+        item.setAttribute?.("aria-hidden", "true");
+    }
+}
+
+function restoreWidget(widget) {
+    if (!widget?.h3PresentationHidden) return;
+    const original = widget.h3PresentationOriginal ?? {};
+    widget.type = original.type;
+    widget.hidden = original.hidden;
+    widget.computeSize = original.computeSize;
+    widget.draw = original.draw;
+    widget.h3PresentationHidden = false;
+    for (const item of new Set([widget.inputEl, widget.element])) {
+        if (!item?.style) continue;
+        item.style.removeProperty("display");
+        item.style.removeProperty("pointer-events");
+        item.removeAttribute?.("aria-hidden");
+    }
+}
+
+function refreshNode(node) {
+    if (!node) return;
+    node.properties ??= {};
+    const labels = WIDGET_LABELS[nodeType(node)] ?? {};
+    for (const widget of node.widgets ?? []) {
+        if (labels[widget.name]) widget.label = labels[widget.name];
+    }
+    const advanced = Boolean(node.properties.h3_show_advanced_sockets);
+    const presentation = presentationForNode(node, advanced);
+    applySocketPresentation(node, advanced);
+    for (const widget of node.widgets ?? []) {
+        if (presentation.hiddenWidgets.has(widget.name)) collapseWidget(widget);
+        else restoreWidget(widget);
+    }
+    node.graph?.setDirtyCanvas?.(true, true);
+}
+
+function refreshGraph(graph) {
+    for (const node of graph?._nodes ?? app.graph?._nodes ?? []) refreshNode(node);
+}
+
+function scheduleGraphRefresh(node) {
+    if (node._h3PresentationRefreshPending) return;
+    node._h3PresentationRefreshPending = true;
+    queueMicrotask(() => {
+        node._h3PresentationRefreshPending = false;
+        refreshGraph(node.graph ?? app.graph);
+        refreshPolicyConsumers(node);
+    });
+}
+
+function refreshPolicyConsumers(node) {
+    const plans = new Set(policyPlanConsumers(node));
+    if (!plans.size) return;
+    for (const plan of plans) {
+        plan._h3ChainEditorConnectionRefresh?.();
+        plan.graph?.setDirtyCanvas?.(true, true);
+    }
+    // Companion editors cache the resolved timing policy separately from the
+    // Plan JSON. A policy widget edit is not a LiteGraph connection event, so
+    // explicitly invalidate companions bound to one of the affected Plans.
+    for (const candidate of node.graph?._nodes ?? []) {
+        if (candidate._h3PlanStudioState?.planNode
+                && !plans.has(candidate._h3PlanStudioState.planNode)) continue;
+        candidate._h3PlanStudioRefresh?.();
+        candidate._h3ScenePromptEditorRefresh?.();
+        candidate._h3RichPromptRefresh?.();
+    }
+}
+
+function watchWidgets(node) {
+    for (const widget of node.widgets ?? []) {
+        if (widget.h3PresentationCallbackWrapped) continue;
+        widget.h3PresentationCallbackWrapped = true;
+        const original = widget.callback;
+        widget.callback = function () {
+            const result = original?.apply(this, arguments);
+            scheduleGraphRefresh(node);
+            return result;
+        };
+    }
+}
+
+app.registerExtension({
+    name: EXTENSION,
+    async beforeRegisterNodeDef(nodeClass, nodeData) {
+        const relevant = String(nodeData.name ?? "").startsWith("MiniMaxH3")
+            || WATCHED_POLICY_NODES.has(nodeData.name);
+        if (!relevant) return;
+
+        const originalCreated = nodeClass.prototype.onNodeCreated;
+        nodeClass.prototype.onNodeCreated = function () {
+            const result = originalCreated?.apply(this, arguments);
+            watchWidgets(this);
+            refreshNode(this);
+            return result;
+        };
+
+        const originalConfigure = nodeClass.prototype.onConfigure;
+        nodeClass.prototype.onConfigure = function () {
+            const result = originalConfigure?.apply(this, arguments);
+            watchWidgets(this);
+            refreshNode(this);
+            scheduleGraphRefresh(this);
+            return result;
+        };
+
+        const originalConnectionsChange = nodeClass.prototype.onConnectionsChange;
+        nodeClass.prototype.onConnectionsChange = function () {
+            const result = originalConnectionsChange?.apply(this, arguments);
+            scheduleGraphRefresh(this);
+            return result;
+        };
+
+        const originalMenu = nodeClass.prototype.getExtraMenuOptions;
+        nodeClass.prototype.getExtraMenuOptions = function (_, options) {
+            const result = originalMenu?.apply(this, arguments);
+            if (!hasAdvancedPresentation(this)) return result;
+            const advanced = Boolean(this.properties?.h3_show_advanced_sockets);
+            options.push({
+                content: advanced
+                    ? "Hide advanced H3 controls"
+                    : "Show advanced H3 controls",
+                callback: () => {
+                    this.properties ??= {};
+                    this.properties.h3_show_advanced_sockets = !advanced;
+                    refreshNode(this);
+                },
+            });
+            return result;
+        };
+    },
+});
diff --git a/ComfyUI-MiniMaxH3-Context-Loop/web/h3_socket_presentation_core.mjs b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_socket_presentation_core.mjs
new file mode 100644
index 0000000000000000000000000000000000000000..bac83cf9f9fcf8adb39f20ac4c708dc2016a243c
--- /dev/null
+++ b/ComfyUI-MiniMaxH3-Context-Loop/web/h3_socket_presentation_core.mjs
@@ -0,0 +1,456 @@
+import {
+    GENERATION_AUDIO_PROFILES,
+    GENERATION_SCENE_PROFILES,
+    LEGACY_AUDIO_POLICIES,
+    TRANSITION_PRESETS,
+    transitionPreset,
+    transitionPresetName,
+} from "./h3_policy_core.mjs?v=0.6.6";
+
+export const CHAIN_POLICY_NODE = "MiniMaxH3ChainPolicy";
+export const PROFILE_POLICY_NODE = "MiniMaxH3GenerationProfile";
+export const ADVANCED_POLICY_NODE = "MiniMaxH3AdvancedPolicy";
+export const LEGACY_POLICY_NODE = "MiniMaxH3Legacy04PolicyAdapter";
+export const PLAN_NODE = "MiniMaxH3ChainPlan";
+export const MODERN_PLAN_NODE = "MiniMaxH3ChainPlanModern";
+export const PLAN_NODES = new Set([PLAN_NODE, MODERN_PLAN_NODE]);
+
+const CONDITIONAL_SOURCE_AUDIO_NODES = new Set([
+    "MiniMaxH3ChainLoopStart",
+    "MiniMaxH3ChainPlanStudio",
+    "MiniMaxH3ChainPreflight",
+    "MiniMaxH3ChainManifestLoad",
+]);
+
+const CURRENT_NODE = "MiniMaxH3ChainCurrent";
+const REVIEW_NODE = "MiniMaxH3ChainReview";
+const ASSEMBLE_NODE = "MiniMaxH3ChainAssemble";
+
+const ADVANCED_OUTPUTS = Object.freeze({
+    MiniMaxH3ChainPolicy: ["status"],
+    MiniMaxH3ChainPlan: ["summary", "clip_count", "video_blend_frames"],
+    MiniMaxH3ChainPlanModern: ["summary", "clip_count", "video_blend_frames"],
+    MiniMaxH3ChainPlanStudio: [
+        "status", "report_json", "plan_summary", "clip_count",
+        "video_blend_frames",
+    ],
+    MiniMaxH3ChainPreflight: ["status", "report_json"],
+    MiniMaxH3LazyMotionAVLoader: ["source_audio", "skip_first_frames", "status"],
+    MiniMaxH3ChainCurrent: [
+        "clip_count", "shot_id", "steps", "audio_start", "audio_duration",
+        "status",
+    ],
+    MiniMaxH3ChainLoopEnd: [
+        "manifest_json", "last_context_frames", "last_context_latent",
+    ],
+    MiniMaxH3ChainManifestLoad: ["manifest_json", "status"],
+});
+
+const ALWAYS_ADVANCED_WIDGETS = Object.freeze({
+    MiniMaxH3ChainPlanStudio: [
+        "verify_resume_history",
+        // Backing values for the Studio's dedicated Plan settings tab. Keep
+        // them serialized and recoverable through Show advanced without
+        // duplicating the normal Studio interface above its timeline.
+        "plan_json", "run_name", "generation_fingerprint", "width", "height",
+        "context_length", "encode_mode", "anchor_mode", "crop", "audio_mode",
+        "audio_context_length", "default_duration_seconds", "default_steps",
+        "base_seed", "segment_crf", "video_blend_frames", "continuation_mode",
+    ],
+    MiniMaxH3ChainPreflight: ["verify_resume_history"],
+    MiniMaxH3ChainUpscaleAdapter: ["recipe_json"],
+});
+
+export function nodeType(node) {
+    return node?.comfyClass ?? node?.type ?? null;
+}
+
+export function isPlanNode(node) {
+    return PLAN_NODES.has(typeof node === "string" ? node : nodeType(node));
+}
+
+export function widgetByName(node, name) {
+    return node?.widgets?.find((widget) => widget.name === name) ?? null;
+}
+
+export function inputByName(node, name) {
+    return node?.inputs?.find((input) => input.name === name) ?? null;
+}
+
+export function outputByName(node, name) {
+    return node?.outputs?.find((output) => output.name === name) ?? null;
+}
+
+function graphLink(graph, id) {
+    if (id == null) return null;
+    return graph?.links?.[id] ?? graph?.links?.get?.(id) ?? null;
+}
+
+function linkedOrigin(node, input) {
+    const link = graphLink(node?.graph, input?.link);
+    return link ? node.graph?.getNodeById?.(link.origin_id) ?? null : null;
+}
+
+export function policyPlanConsumers(policyNode) {
+    const type = nodeType(policyNode);
+    const inputNames = (type === PROFILE_POLICY_NODE
+            || type === CHAIN_POLICY_NODE
+            || type === ADVANCED_POLICY_NODE
+            || type === LEGACY_POLICY_NODE)
+        ? ["chain_policy"] : [];
+    if (!inputNames.length) return [];
+    const graph = policyNode?.graph;
+    return (graph?._nodes ?? []).filter((candidate) =>
+        isPlanNode(candidate)
+        && inputNames.some((name) => {
+            const origin = linkedOrigin(candidate, inputByName(candidate, name));
+            return upstreamNodes(origin).includes(policyNode);
+        }),
+    );
+}
+
+function linked(slot, output = false) {
+    if (!slot) return false;
+    if (!output) return slot.link != null;
+    return Array.isArray(slot.links) ? slot.links.length > 0 : slot.links != null;
+}
+
+export function upstreamNodes(start) {
+    const result = [];
+    const queue = [start];
+    const seen = new Set();
+    while (queue.length) {
+        const node = queue.shift();
+        if (!node || seen.has(node)) continue;
+        seen.add(node);
+        result.push(node);
+        for (const input of node.inputs ?? []) {
+            const parent = linkedOrigin(node, input);
+            if (parent) queue.push(parent);
+        }
+    }
+    return result;
+}
+
+function audioPolicyFromWidgets(node) {
+    if (nodeType(node) === LEGACY_POLICY_NODE) {
+        if (linkedOrigin(node, inputByName(node, "chain_policy"))) return null;
+        const mode = String(widgetByName(node, "audio_mode")?.value ?? "");
+        const mapped = LEGACY_AUDIO_POLICIES[mode];
+        if (!mapped) return null;
+        return {
+            known: true,
+            finalAudio: mapped[0],
+            sourceReference: mapped[1],
+            generatedContinuity: mapped[2],
+            source: "legacy_adapter",
+        };
+    }
+    const type = nodeType(node);
+    if (type === PROFILE_POLICY_NODE) {
+        const selected = String(
+            widgetByName(node, "audio_profile")?.value ?? "");
+        const mapped = GENERATION_AUDIO_PROFILES[selected];
+        if (!mapped) return null;
+        const policy = {
+            known: true,
+            finalAudio: mapped.finalAudio,
+            sourceReference: mapped.sourceReference,
+            generatedContinuity: mapped.generatedContinuity,
+            source: "profile",
+        };
+        if (mapped.sourceAudioTarget === "locked") {
+            policy.sourceAudioTarget = "locked";
+        }
+        return policy;
+    }
+    if (type !== CHAIN_POLICY_NODE) return null;
+    const finalAudio = widgetByName(node, "final_audio")?.value;
+    const sourceReference = widgetByName(node, "source_reference")?.value;
+    const generatedContinuity = widgetByName(node, "generated_continuity")?.value;
+    const sourceAudioTargetLocked = Boolean(
+        widgetByName(node, "lock_source_audio")?.value);
+    if (finalAudio == null || sourceReference == null
+            || generatedContinuity == null) return null;
+    const policy = {
+        known: true,
+        finalAudio: String(finalAudio),
+        sourceReference: sourceAudioTargetLocked
+            ? "off" : String(sourceReference),
+        generatedContinuity: sourceAudioTargetLocked
+            ? "off" : String(generatedContinuity),
+        source: "compact",
+    };
+    if (sourceAudioTargetLocked) policy.sourceAudioTarget = "locked";
+    return policy;
+}
+
+function legacyAudioPolicy(plan) {
+    const mode = widgetByName(plan, "audio_mode")?.value;
+    if (mode == null) return null;
+    const mapped = LEGACY_AUDIO_POLICIES[String(mode)];
+    if (!mapped) return null;
+    return {
+        known: true,
+        finalAudio: mapped[0],
+        sourceReference: mapped[1],
+        generatedContinuity: mapped[2],
+        source: "legacy",
+    };
+}
+
+export function resolveAudioPolicy(start) {
+    let planFallback = null;
+    for (const node of upstreamNodes(start)) {
+        const direct = audioPolicyFromWidgets(node);
+        if (direct) return direct;
+        if (!isPlanNode(node)) continue;
+        if (!linkedOrigin(node, inputByName(node, "chain_policy"))) {
+            planFallback ??= legacyAudioPolicy(node);
+        }
+    }
+    if (planFallback) return planFallback;
+    return {
+        known: false,
+        finalAudio: null,
+        sourceReference: null,
+        generatedContinuity: null,
+        source: "unknown",
+    };
+}
+
+function directAudioContextLength(node) {
+    const type = nodeType(node);
+    if (type === PROFILE_POLICY_NODE) {
+        const selected = String(
+            widgetByName(node, "scene_continuity")?.value ?? "");
+        const preset = transitionPreset(GENERATION_SCENE_PROFILES[selected]);
+        return preset?.contextLength ?? null;
+    }
+    if (type === CHAIN_POLICY_NODE || type === ADVANCED_POLICY_NODE) {
+        const preset = transitionPreset(String(
+            widgetByName(node, "incoming_transition")?.value ?? ""));
+        return preset?.contextLength ?? null;
+    }
+    if (type === LEGACY_POLICY_NODE) {
+        const value = Number(widgetByName(node, "audio_context_length")?.value);
+        return Number.isInteger(value) ? value : null;
+    }
+    return null;
+}
+
+export function resolveAudioContextLength(start) {
+    let planFallback = null;
+    for (const node of upstreamNodes(start)) {
+        const direct = directAudioContextLength(node);
+        if (direct != null) return direct;
+        if (!isPlanNode(node)) continue;
+        if (!linkedOrigin(node, inputByName(node, "chain_policy"))) {
+            const legacy = Number(
+                widgetByName(node, "audio_context_length")?.value);
+            if (Number.isInteger(legacy)) planFallback ??= legacy;
+        }
+    }
+    return planFallback ?? 22;
+}
+
+function transitionPolicyFromWidgets(node) {
+    const type = nodeType(node);
+    if (type === LEGACY_POLICY_NODE) {
+        const continuationMode = String(
+            widgetByName(node, "continuation_mode")?.value ?? "");
+        const contextLength = Number(
+            widgetByName(node, "context_length")?.value);
+        if (!Number.isInteger(contextLength) || !continuationMode) return null;
+        const preset = transitionPresetName(continuationMode, contextLength);
+        return {
+            known: true, preset, continuationMode, contextLength,
+            expertOverride: preset === "custom", source: "legacy_adapter",
+        };
+    }
+    if (type === PROFILE_POLICY_NODE) {
+        const selected = String(
+            widgetByName(node, "scene_continuity")?.value ?? "");
+        const preset = GENERATION_SCENE_PROFILES[selected];
+        const pair = transitionPreset(preset);
+        if (!pair) return null;
+        return {
+            known: true, preset,
+            continuationMode: pair.continuationMode,
+            contextLength: pair.contextLength,
+            expertOverride: false,
+            source: "profile",
+        };
+    }
+    if (type === CHAIN_POLICY_NODE || type === ADVANCED_POLICY_NODE) {
+        const preset = String(
+            widgetByName(node, "incoming_transition")?.value ?? "");
+        const pair = transitionPreset(preset);
+        if (!pair) return null;
+        return {
+            known: true, preset,
+            continuationMode: pair.continuationMode,
+            contextLength: pair.contextLength,
+            expertOverride: false,
+            source: type === ADVANCED_POLICY_NODE ? "advanced" : "compact",
+        };
+    }
+    return null;
+}
+
+function legacyTransitionPolicy(plan) {
+    const continuationMode = widgetByName(plan, "continuation_mode")?.value;
+    const contextLength = Number(widgetByName(plan, "context_length")?.value);
+    if (continuationMode == null || !Number.isInteger(contextLength)) return null;
+    const preset = transitionPresetName(continuationMode, contextLength);
+    return {
+        known: true,
+        preset,
+        continuationMode: String(continuationMode),
+        contextLength,
+        expertOverride: preset === "custom",
+        source: "legacy",
+    };
+}
+
+export function resolveTransitionPolicy(start) {
+    let planFallback = null;
+    for (const node of upstreamNodes(start)) {
+        const direct = transitionPolicyFromWidgets(node);
+        if (direct) return direct;
+        if (!isPlanNode(node)) continue;
+        if (!linkedOrigin(node, inputByName(node, "chain_policy"))) {
+            planFallback ??= legacyTransitionPolicy(node);
+        }
+    }
+    if (planFallback) return planFallback;
+    return {
+        known: false,
+        preset: null,
+        continuationMode: null,
+        contextLength: null,
+        expertOverride: false,
+        source: "unknown",
+    };
+}
+
+export function hasSourceTimeline(start) {
+    return upstreamNodes(start).some((node) =>
+        linked(inputByName(node, "source_timeline")));
+}
+
+function sourceAudioInputNeeded(node, policy) {
+    const type = nodeType(node);
+    if (hasSourceTimeline(node)) return false;
+    if (type === CURRENT_NODE) {
+        return !policy.known || policy.sourceReference === "on"
+            || policy.sourceAudioTarget === "locked";
+    }
+    if (type === REVIEW_NODE) {
+        return String(widgetByName(node, "partial_audio_source")?.value)
+            === "source";
+    }
+    if (type === ASSEMBLE_NODE) {
+        const selection = String(widgetByName(node, "audio_source")?.value ?? "plan");
+        if (selection === "source") return true;
+        if (selection !== "plan") return false;
+        return !policy.known || policy.finalAudio === "source";
+    }
+    if (CONDITIONAL_SOURCE_AUDIO_NODES.has(type)) {
+        return !policy.known || policy.finalAudio === "source"
+            || policy.sourceReference === "on"
+            || policy.sourceAudioTarget === "locked";
+    }
+    return true;
+}
+
+function advancedOutputNames(node) {
+    const configured = ADVANCED_OUTPUTS[nodeType(node)] ?? [];
+    const names = new Set(configured);
+    // Status is a human diagnostic for every node in this pack. Keeping this
+    // generic means new 0.5 nodes inherit the same presentation rule without
+    // changing their backend result tuple.
+    if (outputByName(node, "status")) names.add("status");
+    return names;
+}
+
+function advancedWidgetNames(node, policy) {
+    const names = new Set(ALWAYS_ADVANCED_WIDGETS[nodeType(node)] ?? []);
+    if (nodeType(node) === PLAN_NODE) {
+        names.add("audio_mode");
+        names.add("continuation_mode");
+        names.add("context_length");
+        names.add("audio_context_length");
+        names.add("encode_mode");
+        names.add("anchor_mode");
+        names.add("crop");
+        names.add("video_blend_frames");
+    }
+    if (nodeType(node) === CURRENT_NODE
+            && policy.known && policy.sourceReference !== "on") {
+        names.add("align_audio_reference");
+    }
+    return names;
+}
+
+export function presentationForNode(node, showAdvanced = false) {
+    const policy = resolveAudioPolicy(node);
+    const hiddenInputs = new Set();
+    const hiddenOutputs = new Set();
+    const hiddenWidgets = new Set();
+    if (!showAdvanced) {
+        for (const name of advancedOutputNames(node)) hiddenOutputs.add(name);
+        for (const name of advancedWidgetNames(node, policy)) hiddenWidgets.add(name);
+        const sourceAudio = inputByName(node, "source_audio");
+        if (sourceAudio && !sourceAudioInputNeeded(node, policy)) {
+            hiddenInputs.add("source_audio");
+        }
+        if (nodeType(node) === CURRENT_NODE && policy.known
+                && policy.sourceReference !== "on") {
+            hiddenOutputs.add("source_audio_slice");
+        }
+        // Converted widgets retain their backend input names. Apply the same
+        // presentation decision without removing their slot from the array.
+        for (const name of hiddenWidgets) {
+            if (inputByName(node, name)) hiddenInputs.add(name);
+        }
+    }
+    // A chained Legacy Adapter is a raw boundary layer. Its 0.4 audio_mode is
+    // deliberately ignored by the backend because the upstream modern policy
+    // owns audio intent, so do not present an inert control in either view.
+    if (nodeType(node) === LEGACY_POLICY_NODE
+            && linkedOrigin(node, inputByName(node, "chain_policy"))) {
+        hiddenWidgets.add("audio_mode");
+        if (inputByName(node, "audio_mode")) hiddenInputs.add("audio_mode");
+    }
+    return {hiddenInputs, hiddenOutputs, hiddenWidgets, policy};
+}
+
+function setSlotPresentation(slot, hide, output = false) {
+    if (!slot) return;
+    const effective = Boolean(hide) && !linked(slot, output);
+    slot.hidden = effective;
+    slot.h3Advanced = Boolean(hide);
+    slot.h3PresentationHidden = effective;
+}
+
+export function applySocketPresentation(node, showAdvanced = undefined) {
+    const advanced = showAdvanced ?? Boolean(
+        node?.properties?.h3_show_advanced_sockets);
+    const presentation = presentationForNode(node, advanced);
+    for (const slot of node?.inputs ?? []) {
+        setSlotPresentation(
+            slot, presentation.hiddenInputs.has(slot.name), false);
+    }
+    for (const slot of node?.outputs ?? []) {
+        setSlotPresentation(
+            slot, presentation.hiddenOutputs.has(slot.name), true);
+    }
+    return presentation;
+}
+
+export function hasAdvancedPresentation(node) {
+    const compact = presentationForNode(node, false);
+    return compact.hiddenInputs.size > 0 || compact.hiddenOutputs.size > 0
+        || compact.hiddenWidgets.size > 0;
+}