From 70cd0152190ac4d4c772f560fb9ccf4e4ef8af7d Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Sun, 26 Jul 2026 20:11:38 +0300
Subject: [PATCH 01/29] Easy Gen: prompt $name variables panel
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Ports the Editor Composer's $variables to Easy Gen: a "$ Variables" toggle in
the header opens a collapsible name/value editor docked above the prompt bar.

Same project.variables field the Editor writes, so nothing backend-side is new —
movie_editor/server.py already forwards it on every generate and Studio resolves
it dead-last inside refine_v2 (after shortcut expansion AND after the scene
split), which is what makes a $var work inside a shortcut's replacement while a
value containing a comma or trigger word can never move a scene cut.

- easy_store: projectVariables/setProjectVariables (leading $ stripped on store)
- easy_variables.js: rows + Add/Remove, count badge, live hint for undeclared
  names and self-referencing loops (cycle detection mirrors resolve_variables)
- rows rebuild only on add/remove/project-change, so typing never loses focus

Co-Authored-By: Claude <noreply@anthropic.com>
---
 easy_gen/frontend/easy.css          |  23 ++++
 easy_gen/frontend/easy_store.js     |  15 +++
 easy_gen/frontend/easy_variables.js | 166 ++++++++++++++++++++++++++++
 easy_gen/frontend/index.html        |   5 +
 4 files changed, 209 insertions(+)
 create mode 100644 easy_gen/frontend/easy_variables.js

diff --git a/easy_gen/frontend/easy.css b/easy_gen/frontend/easy.css
index da5908a1..1c0c410f 100644
--- a/easy_gen/frontend/easy.css
+++ b/easy_gen/frontend/easy.css
@@ -75,6 +75,29 @@ a.brand:hover .brand-sub { color: var(--amber-2); }
 .easy-generate-btn { padding: 10px 26px; font-size: 14px; }
 .easy-advanced-btn { align-self: center; }
 
+/* Prompt $name variables — collapsible strip docked above the prompt bar. */
+.easy-vars {
+  flex: none; max-height: 38vh; overflow: auto;
+  padding: 12px 16px; border-top: 1px solid var(--line); background: var(--ink-1);
+}
+.easy-vars[hidden] { display: none; }
+.easy-vars-hint { color: var(--muted); font-size: 12px; line-height: 1.5; margin-bottom: 8px; }
+.easy-vars-hint.easy-var-warn { color: var(--amber); }
+.easy-vars-empty { color: var(--faint); font-size: 12px; }
+.easy-var-list { display: flex; flex-direction: column; gap: 6px; align-items: flex-start; }
+.easy-var-row { display: flex; gap: 6px; align-items: center; width: 100%; }
+.easy-var-dollar { color: var(--amber); font-family: var(--font-mono); opacity: .8; }
+.easy-var-eq { color: var(--muted); }
+.easy-var-in {
+  background: var(--ink-2); border: 1px solid var(--line); border-radius: var(--radius);
+  color: var(--text); font: 13px/1.4 var(--font-ui); padding: 6px 9px; min-width: 0;
+}
+.easy-var-in:focus { outline: none; border-color: var(--amber); }
+.easy-var-name { flex: 0 0 22%; font-family: var(--font-mono); }
+.easy-var-val { flex: 1; }
+.easy-var-row .btn { flex: 0 0 auto; }
+#easy-vars-btn.easy-vars-warn { color: var(--amber); border-color: var(--amber); }
+
 .es-io-controls { display: flex; align-items: center; gap: 8px; }
 .es-io-mode { background: var(--ink-2); border: 1px solid var(--line); color: var(--text);
   border-radius: 6px; font-size: 12px; padding: 4px 6px; }
diff --git a/easy_gen/frontend/easy_store.js b/easy_gen/frontend/easy_store.js
index c1deaafa..31ba2277 100644
--- a/easy_gen/frontend/easy_store.js
+++ b/easy_gen/frontend/easy_store.js
@@ -292,6 +292,20 @@
     _scheduleEngineSave(600);
   }
 
+  // ── prompt variables ($name) ───────────────────────────────────────────────
+  // Project-scoped find/replace, stored in the same project.variables field the Editor
+  // uses; the generate endpoint already forwards it to the builder, and Studio resolves
+  // it dead-last (after shortcut expansion + the scene split) inside refine_v2.
+  function projectVariables() { return (state.project && state.project.variables) || []; }
+  function setProjectVariables(list) {
+    if (!state.project) return;
+    // A leading $ is stripped so "$vid" and "vid" declare the same variable.
+    patchProjectQuiet({ variables: (Array.isArray(list) ? list : []).map((v) => ({
+      name: String((v && v.name) || "").replace(/^\$+/, "").trim(),
+      value: String((v && v.value != null) ? v.value : ""),
+    })) });
+  }
+
   function setConditioningSlot(slotId) { patchProject({ conditioning_slot: slotId || "funpack" }); }
   function setSamplerSlot(slotId) { patchProject({ sampler_slot: slotId || "funpack" }); }
   function setSamplerInput(name, value) {
@@ -359,6 +373,7 @@
     applyGlobalPrompt, scheduleGlobalPromptApply,
     setSceneMedia, save,
     patchProject, patchProjectQuiet,
+    projectVariables, setProjectVariables,
     setConditioningSlot, setSamplerSlot,
     setSamplerInput, setSamplerInputNow, unsetSamplerInput,
     setStudioInput, setStudioInputNow,
diff --git a/easy_gen/frontend/easy_variables.js b/easy_gen/frontend/easy_variables.js
new file mode 100644
index 00000000..21a61263
--- /dev/null
+++ b/easy_gen/frontend/easy_variables.js
@@ -0,0 +1,166 @@
+// Easy Gen's prompt `$name` variables panel — quick replacements for full phrases,
+// e.g. $vid = "High quality, high fidelity realistic video, motion blur, cinematic fog".
+//
+// Storage is project.variables ([{name, value}]) — the SAME project field the Editor
+// writes and the same one movie_editor/server.py already hands to the builder on every
+// generate ("variables": list(target.variables or [])), so nothing backend-side is new:
+// templates.resolve_variables substitutes them inside refine_v2 DEAD LAST, after shortcut
+// expansion and after the transition split. That order is what makes them work INSIDE
+// shortcuts (a shortcut whose replacement contains $vid still resolves) while a value
+// containing a comma or a trigger word can never move a scene cut.
+//
+// Undefined names stay literal ($foo passes through as text) and a self-referencing chain
+// is left literal rather than looping — the hint line below warns about both before you burn
+// a generation on it.
+(function () {
+  const { el } = window.dom;
+  const S = window.Store;
+
+  const panel = document.getElementById("easy-vars");
+  const toggleBtn = document.getElementById("easy-vars-btn");
+  const promptEl = document.getElementById("easy-prompt");
+  if (!panel || !toggleBtn) return;
+
+  let open = false;
+  let hintEl = null;
+  let renderedProjectId = null;
+
+  function vars() {
+    return (S.projectVariables() || []).map((v) => ({
+      name: String((v && v.name) || ""),
+      value: String((v && v.value != null) ? v.value : ""),
+    }));
+  }
+
+  // Cycle detection over the declared variables — mirrors the safe-degrade guard in
+  // templates.resolve_variables, but reports the loop instead of silently leaving it literal.
+  function detectCycles() {
+    const map = {};
+    (S.projectVariables() || []).forEach((v) => {
+      const k = String((v && v.name) || "").replace(/^\$+/, "").trim();
+      if (k) map[k] = String((v && v.value) || "");
+    });
+    const refs = (n) => (String(map[n] || "").match(/\$([A-Za-z_][A-Za-z0-9_]*)/g) || [])
+      .map((m) => m.slice(1)).filter((r) => r in map);
+    const color = {}, path = [], cycles = [];
+    const dfs = (n) => {
+      color[n] = 1; path.push(n);
+      for (const r of refs(n)) {
+        if (color[r] === 1) cycles.push(path.slice(path.indexOf(r)).concat(r));
+        else if (!color[r]) dfs(r);
+      }
+      path.pop(); color[n] = 2;
+    };
+    Object.keys(map).forEach((n) => { if (!color[n]) dfs(n); });
+    return cycles;
+  }
+
+  // Live hint: a cycle wins over the undeclared list. Only the visible prompt is scanned —
+  // a $var used solely inside a shortcut's replacement text is legitimate and stays silent.
+  function warning() {
+    const cycles = detectCycles();
+    if (cycles.length) {
+      return {
+        bad: true,
+        msg: "⚠ Variable loop: " + cycles[0].map((n) => "$" + n).join(" → ")
+          + " — references itself. Rework it; it won't expand.",
+      };
+    }
+    const declared = new Set((S.projectVariables() || [])
+      .map((v) => String((v && v.name) || "").replace(/^\$+/, "").trim()).filter(Boolean));
+    const txt = promptEl ? promptEl.value : "";
+    const used = new Set((txt.match(/\$([A-Za-z_][A-Za-z0-9_]*)/g) || []).map((m) => m.slice(1)));
+    const undeclared = [...used].filter((n) => !declared.has(n));
+    if (undeclared.length) {
+      return {
+        bad: false,
+        msg: "Referencing " + undeclared.map((n) => "$" + n).join(", ")
+          + " — never declared, passed through as plain text.",
+      };
+    }
+    return { bad: false, msg: "" };
+  }
+
+  function updateChrome() {
+    const st = S.get();
+    toggleBtn.disabled = !st.project;
+    const n = (S.projectVariables() || []).filter((v) => String((v && v.name) || "").trim()).length;
+    toggleBtn.textContent = (open ? "▾ " : "▸ ") + "$ Variables" + (n ? ` (${n})` : "");
+    const w = warning();
+    toggleBtn.classList.toggle("easy-vars-warn", !!w.bad);
+    if (hintEl) {
+      hintEl.textContent = w.msg;
+      hintEl.classList.toggle("easy-var-warn", !!w.bad);
+      hintEl.style.display = w.msg ? "" : "none";
+    }
+  }
+
+  function render() {
+    panel.textContent = "";
+    panel.hidden = !open;
+    if (!open) { updateChrome(); return; }
+
+    panel.append(el("div", "easy-vars-hint",
+      "Shorthand for full phrases. Type $name in the prompt (or inside a shortcut's replacement) "
+      + "and it's swapped for the text below at generation — after shortcuts expand and after the "
+      + "prompt splits into scenes, so a value can never move a scene cut."));
+
+    hintEl = el("div", "easy-vars-hint easy-var-hint");
+    panel.append(hintEl);
+
+    const list = el("div", "easy-var-list");
+    // Local working copy: every keystroke commits it to the project (debounced save), and
+    // only add/remove re-renders — so an input never loses focus mid-word.
+    const rows = vars();
+    const commit = () => { S.setProjectVariables(rows); updateChrome(); };
+
+    rows.forEach((v, i) => {
+      const row = el("div", "easy-var-row");
+      row.append(el("span", "easy-var-dollar", "$"));
+      const nm = el("input", "easy-var-in easy-var-name");
+      nm.value = v.name; nm.placeholder = "name";
+      nm.oninput = () => { v.name = nm.value.replace(/^\$+/, ""); commit(); };
+      row.append(nm);
+      row.append(el("span", "easy-var-eq", "="));
+      const vv = el("input", "easy-var-in easy-var-val");
+      vv.value = v.value; vv.placeholder = "value (may reference $other)";
+      vv.oninput = () => { v.value = vv.value; commit(); };
+      row.append(vv);
+      const rm = el("button", "btn ghost tiny", "✕");
+      rm.type = "button";
+      rm.title = "Remove variable";
+      rm.onclick = () => { rows.splice(i, 1); S.setProjectVariables(rows); render(); };
+      row.append(rm);
+      list.append(row);
+    });
+    if (!rows.length) list.append(el("div", "easy-vars-empty", "No variables yet."));
+
+    const add = el("button", "btn ghost tiny easy-var-add", "＋ Add variable");
+    add.type = "button";
+    add.onclick = () => { rows.push({ name: "", value: "" }); S.setProjectVariables(rows); render(); };
+    list.append(add);
+
+    panel.append(list);
+    updateChrome();
+  }
+
+  toggleBtn.onclick = () => {
+    if (!S.get().project) return;
+    open = !open;
+    render();
+  };
+
+  // Rebuild only when the project actually changes (a fresh set of rows); every other
+  // notify just refreshes the count/warning so in-progress typing is never interrupted.
+  S.subscribe((st) => {
+    const pid = st.project ? st.project.id : null;
+    if (pid !== renderedProjectId) {
+      renderedProjectId = pid;
+      if (open) { render(); return; }
+    }
+    updateChrome();
+  });
+  if (promptEl) promptEl.addEventListener("input", updateChrome);
+
+  updateChrome();
+})();
diff --git a/easy_gen/frontend/index.html b/easy_gen/frontend/index.html
index 095ad4a7..2e8b33f0 100644
--- a/easy_gen/frontend/index.html
+++ b/easy_gen/frontend/index.html
@@ -55,6 +55,8 @@
       <div class="easy-project-name" id="easy-project-name">No project</div>
       <span class="health-chip" id="easy-health-chip"></span>
       <div class="menubar-right">
+        <button class="btn ghost tiny" id="easy-vars-btn" type="button"
+          title="Prompt $name variables — shorthand for full phrases, substituted at generation">▸ $ Variables</button>
         <button class="btn ghost tiny" id="easy-save-btn" type="button">Save</button>
         <button class="btn ghost tiny" id="easy-export-btn" type="button"
           title="Download this project as a .funpack_project.json file — e.g. to move it off a rental machine">Export…</button>
@@ -64,6 +66,8 @@
 
     <main class="easy-preview" id="easy-preview"></main>
 
+    <section class="easy-vars" id="easy-vars" hidden></section>
+
     <footer class="easy-bar">
       <button class="btn ghost easy-upload-btn" id="easy-upload-btn" type="button"
         title="Upload an image or video to guide generation">⬆ Upload</button>
@@ -98,6 +102,7 @@
   <script src="autocomplete.js"></script>
   <script src="project_menu.js"></script>
   <script src="easy_gallery.js"></script>
+  <script src="easy_variables.js"></script>
   <script src="log.js"></script>
   <script src="preview.js"></script>
   <script src="app.js"></script>

From 8e9c0479a8c9cd70166f5ff1360dbf3516501a90 Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Sun, 26 Jul 2026 20:18:15 +0300
Subject: [PATCH 02/29] Variables: own window in Easy Gen, auto-growing value
 fields in both UIs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Follow-up to the previous commit, per review:
- the panel is no longer docked into Easy Gen's main screen — the "$ Variables"
  button now sits in the prompt bar (next to Upload/Gallery, not pinned to the
  header) and opens a modal window, same shell as the Gallery picker
- value fields are auto-growing textareas instead of one-line inputs, in the
  Cutting Room's Composer as well: a long phrase was impossible to edit in a
  single-line field. Height is measured from scrollHeight with the border-box
  borders added back, re-fit once after layout (scrollHeight reads 0 before it)
- fully-empty rows are dropped on persist, so an accidental "Add variable" click
  never sticks to the project (the row stays on screen until it's filled in —
  the open window keeps its own working copy for exactly this reason)

Co-Authored-By: Claude <noreply@anthropic.com>
---
 CHANGELOG.md                        |  15 +++
 easy_gen/frontend/easy.css          |  15 +--
 easy_gen/frontend/easy_store.js     |   6 +-
 easy_gen/frontend/easy_variables.js | 183 ++++++++++++++++++----------
 easy_gen/frontend/index.html        |   6 +-
 movie_editor/frontend/composer.js   |  27 +++-
 movie_editor/frontend/styles.css    |   7 +-
 7 files changed, 178 insertions(+), 81 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3a143102..7950fa07 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,21 @@
 
 ## [Unreleased]
 
+### Added
+- **Prompt `$name` variables in Easy Gen** — the shorthand-for-a-full-phrase layer the
+  Cutting Room's Composer already had (`$vid = "High quality, high fidelity realistic video,
+  motion blur, cinematic fog"`). A **$ Variables** button in the prompt bar opens its own
+  window with editable name/value rows, a count badge, and a live warning for names used but
+  never declared or for a variable that references itself. Same `project.variables` field as
+  the Cutting Room, so a project carries its variables between the two UIs; substitution
+  still happens inside Studio dead-last — after shortcut expansion and after the scene split
+  — which is what makes a `$var` work *inside* a shortcut's replacement while a value
+  containing a comma or a trigger word can never move a scene cut.
+
+### Changed
+- **Variable values are now auto-growing text boxes** (both UIs) instead of one-line inputs —
+  a long phrase was effectively uneditable in a single-line field.
+
 ## [3.4.0] - 2026-07-24
 
 ### Added
diff --git a/easy_gen/frontend/easy.css b/easy_gen/frontend/easy.css
index 1c0c410f..3a6bf735 100644
--- a/easy_gen/frontend/easy.css
+++ b/easy_gen/frontend/easy.css
@@ -64,7 +64,7 @@ a.brand:hover .brand-sub { color: var(--amber-2); }
   flex: none; display: flex; align-items: flex-end; gap: 12px;
   padding: 14px 16px; border-top: 1px solid var(--line); background: var(--ink-1);
 }
-.easy-upload-btn, .easy-gallery-btn { flex: none; align-self: stretch; padding: 0 16px; }
+.easy-upload-btn, .easy-gallery-btn, .easy-vars-btn { flex: none; align-self: stretch; padding: 0 16px; }
 .easy-prompt {
   flex: 1; resize: none; background: var(--ink-2); border: 1px solid var(--line);
   border-radius: var(--radius); color: var(--text); font: 14px/1.4 var(--font-ui);
@@ -75,17 +75,13 @@ a.brand:hover .brand-sub { color: var(--amber-2); }
 .easy-generate-btn { padding: 10px 26px; font-size: 14px; }
 .easy-advanced-btn { align-self: center; }
 
-/* Prompt $name variables — collapsible strip docked above the prompt bar. */
-.easy-vars {
-  flex: none; max-height: 38vh; overflow: auto;
-  padding: 12px 16px; border-top: 1px solid var(--line); background: var(--ink-1);
-}
-.easy-vars[hidden] { display: none; }
+/* Prompt $name variables — own modal window, opened from the header button. */
 .easy-vars-hint { color: var(--muted); font-size: 12px; line-height: 1.5; margin-bottom: 8px; }
 .easy-vars-hint.easy-var-warn { color: var(--amber); }
 .easy-vars-empty { color: var(--faint); font-size: 12px; }
 .easy-var-list { display: flex; flex-direction: column; gap: 6px; align-items: flex-start; }
-.easy-var-row { display: flex; gap: 6px; align-items: center; width: 100%; }
+.easy-var-row { display: flex; gap: 6px; align-items: flex-start; width: 100%; }
+.easy-var-row > .easy-var-dollar, .easy-var-row > .easy-var-eq, .easy-var-row > .btn { margin-top: 6px; }
 .easy-var-dollar { color: var(--amber); font-family: var(--font-mono); opacity: .8; }
 .easy-var-eq { color: var(--muted); }
 .easy-var-in {
@@ -94,7 +90,8 @@ a.brand:hover .brand-sub { color: var(--amber-2); }
 }
 .easy-var-in:focus { outline: none; border-color: var(--amber); }
 .easy-var-name { flex: 0 0 22%; font-family: var(--font-mono); }
-.easy-var-val { flex: 1; }
+/* Value is an auto-growing textarea (JS sets the height) — no manual resize handle, no scrollbar. */
+.easy-var-val { flex: 1; resize: none; overflow: hidden; }
 .easy-var-row .btn { flex: 0 0 auto; }
 #easy-vars-btn.easy-vars-warn { color: var(--amber); border-color: var(--amber); }
 
diff --git a/easy_gen/frontend/easy_store.js b/easy_gen/frontend/easy_store.js
index 31ba2277..a4a3e6cf 100644
--- a/easy_gen/frontend/easy_store.js
+++ b/easy_gen/frontend/easy_store.js
@@ -299,11 +299,13 @@
   function projectVariables() { return (state.project && state.project.variables) || []; }
   function setProjectVariables(list) {
     if (!state.project) return;
-    // A leading $ is stripped so "$vid" and "vid" declare the same variable.
+    // A leading $ is stripped so "$vid" and "vid" declare the same variable. Fully-empty
+    // rows are dropped on persist (the UI keeps showing them while they're being filled in),
+    // so an accidental "Add variable" click never sticks to the project.
     patchProjectQuiet({ variables: (Array.isArray(list) ? list : []).map((v) => ({
       name: String((v && v.name) || "").replace(/^\$+/, "").trim(),
       value: String((v && v.value != null) ? v.value : ""),
-    })) });
+    })).filter((v) => v.name || v.value) });
   }
 
   function setConditioningSlot(slotId) { patchProject({ conditioning_slot: slotId || "funpack" }); }
diff --git a/easy_gen/frontend/easy_variables.js b/easy_gen/frontend/easy_variables.js
index 21a61263..5f8d9d75 100644
--- a/easy_gen/frontend/easy_variables.js
+++ b/easy_gen/frontend/easy_variables.js
@@ -1,29 +1,32 @@
-// Easy Gen's prompt `$name` variables panel — quick replacements for full phrases,
+// Easy Gen's prompt `$name` variables — quick replacements for full phrases,
 // e.g. $vid = "High quality, high fidelity realistic video, motion blur, cinematic fog".
 //
-// Storage is project.variables ([{name, value}]) — the SAME project field the Editor
-// writes and the same one movie_editor/server.py already hands to the builder on every
-// generate ("variables": list(target.variables or [])), so nothing backend-side is new:
-// templates.resolve_variables substitutes them inside refine_v2 DEAD LAST, after shortcut
-// expansion and after the transition split. That order is what makes them work INSIDE
-// shortcuts (a shortcut whose replacement contains $vid still resolves) while a value
-// containing a comma or a trigger word can never move a scene cut.
+// Opens as its own modal off the header's "$ Variables" button (same modal-overlay/.modal
+// shell as easy_gallery.js / project_menu.js) — deliberately NOT docked into the main
+// screen, which stays prompt + preview only.
+//
+// Storage is project.variables ([{name, value}]) — the SAME project field the Editor's
+// Composer writes and the same one movie_editor/server.py already hands to the builder on
+// every generate ("variables": list(target.variables or [])), so nothing backend-side is
+// new: templates.resolve_variables substitutes them inside refine_v2 DEAD LAST, after
+// shortcut expansion and after the transition split. That order is what makes them work
+// INSIDE shortcuts (a shortcut whose replacement contains $vid still resolves) while a
+// value containing a comma or a trigger word can never move a scene cut.
 //
 // Undefined names stay literal ($foo passes through as text) and a self-referencing chain
-// is left literal rather than looping — the hint line below warns about both before you burn
-// a generation on it.
+// is left literal rather than looping — the hint line warns about both before you burn a
+// generation on it.
 (function () {
-  const { el } = window.dom;
+  const { el, clear } = window.dom;
   const S = window.Store;
 
-  const panel = document.getElementById("easy-vars");
   const toggleBtn = document.getElementById("easy-vars-btn");
   const promptEl = document.getElementById("easy-prompt");
-  if (!panel || !toggleBtn) return;
+  if (!toggleBtn) return;
 
-  let open = false;
+  let overlay = null;
+  let listEl = null;
   let hintEl = null;
-  let renderedProjectId = null;
 
   function vars() {
     return (S.projectVariables() || []).map((v) => ({
@@ -55,8 +58,8 @@
     return cycles;
   }
 
-  // Live hint: a cycle wins over the undeclared list. Only the visible prompt is scanned —
-  // a $var used solely inside a shortcut's replacement text is legitimate and stays silent.
+  // A cycle wins over the undeclared list. Only the visible prompt is scanned — a $var used
+  // solely inside a shortcut's replacement text is legitimate and stays silent.
   function warning() {
     const cycles = detectCycles();
     if (cycles.length) {
@@ -81,38 +84,53 @@
     return { bad: false, msg: "" };
   }
 
-  function updateChrome() {
+  // Header button: enabled only with a project, carries the count, and goes amber on a loop
+  // so a broken variable is visible without opening the window.
+  function updateButton() {
     const st = S.get();
     toggleBtn.disabled = !st.project;
     const n = (S.projectVariables() || []).filter((v) => String((v && v.name) || "").trim()).length;
-    toggleBtn.textContent = (open ? "▾ " : "▸ ") + "$ Variables" + (n ? ` (${n})` : "");
-    const w = warning();
-    toggleBtn.classList.toggle("easy-vars-warn", !!w.bad);
-    if (hintEl) {
-      hintEl.textContent = w.msg;
-      hintEl.classList.toggle("easy-var-warn", !!w.bad);
-      hintEl.style.display = w.msg ? "" : "none";
-    }
+    toggleBtn.textContent = "$ Variables" + (n ? ` (${n})` : "");
+    toggleBtn.classList.toggle("easy-vars-warn", !!warning().bad);
   }
 
-  function render() {
-    panel.textContent = "";
-    panel.hidden = !open;
-    if (!open) { updateChrome(); return; }
+  function updateHint() {
+    if (!hintEl) return;
+    const w = warning();
+    hintEl.textContent = w.msg;
+    hintEl.classList.toggle("easy-var-warn", !!w.bad);
+    hintEl.style.display = w.msg ? "" : "none";
+    updateButton();
+  }
 
-    panel.append(el("div", "easy-vars-hint",
-      "Shorthand for full phrases. Type $name in the prompt (or inside a shortcut's replacement) "
-      + "and it's swapped for the text below at generation — after shortcuts expand and after the "
-      + "prompt splits into scenes, so a value can never move a scene cut."));
+  // Grow a value textarea to fit its text (measured after a reset to "auto", or it can only
+  // ever get taller). Deferred once on mount because scrollHeight reads 0 before layout.
+  function autoGrow(ta) {
+    const fit = () => {
+      ta.style.height = "auto";
+      // scrollHeight covers content + padding; under border-box the borders must be added
+      // back or every line is clipped by ~2px and the textarea scrolls anyway.
+      const cs = getComputedStyle(ta);
+      const border = cs.boxSizing === "border-box"
+        ? parseFloat(cs.borderTopWidth) + parseFloat(cs.borderBottomWidth)
+        : -(parseFloat(cs.paddingTop) + parseFloat(cs.paddingBottom));
+      ta.style.height = (ta.scrollHeight + (border || 0)) + "px";
+    };
+    fit();
+    if (!ta.dataset.grown) { ta.dataset.grown = "1"; setTimeout(fit, 0); }
+  }
 
-    hintEl = el("div", "easy-vars-hint easy-var-hint");
-    panel.append(hintEl);
+  // Working copy for the open window. It is the source of truth for what's on screen —
+  // a half-typed row (blank name AND value) is dropped by the store on persist, so
+  // re-reading the project after every edit would delete the row being filled in.
+  let rows = [];
 
-    const list = el("div", "easy-var-list");
-    // Local working copy: every keystroke commits it to the project (debounced save), and
-    // only add/remove re-renders — so an input never loses focus mid-word.
-    const rows = vars();
-    const commit = () => { S.setProjectVariables(rows); updateChrome(); };
+  function renderList() {
+    if (!listEl) return;
+    clear(listEl);
+    // Every keystroke commits to the project (debounced save); only add/remove re-renders,
+    // so an input never loses focus mid-word.
+    const commit = () => { S.setProjectVariables(rows); updateHint(); };
 
     rows.forEach((v, i) => {
       const row = el("div", "easy-var-row");
@@ -122,45 +140,86 @@
       nm.oninput = () => { v.name = nm.value.replace(/^\$+/, ""); commit(); };
       row.append(nm);
       row.append(el("span", "easy-var-eq", "="));
-      const vv = el("input", "easy-var-in easy-var-val");
+      // Values are usually long phrases, so this is a textarea that grows with its content —
+      // a one-line input makes editing "High quality, high fidelity realistic video, …" a
+      // horizontal-scrolling guessing game.
+      const vv = el("textarea", "easy-var-in easy-var-val");
+      vv.rows = 1;
       vv.value = v.value; vv.placeholder = "value (may reference $other)";
-      vv.oninput = () => { v.value = vv.value; commit(); };
+      vv.oninput = () => { v.value = vv.value; autoGrow(vv); commit(); };
       row.append(vv);
+      autoGrow(vv);
       const rm = el("button", "btn ghost tiny", "✕");
       rm.type = "button";
       rm.title = "Remove variable";
-      rm.onclick = () => { rows.splice(i, 1); S.setProjectVariables(rows); render(); };
+      rm.onclick = () => { rows.splice(i, 1); S.setProjectVariables(rows); renderList(); updateHint(); };
       row.append(rm);
-      list.append(row);
+      listEl.append(row);
     });
-    if (!rows.length) list.append(el("div", "easy-vars-empty", "No variables yet."));
+    if (!rows.length) listEl.append(el("div", "easy-vars-empty", "No variables yet."));
 
     const add = el("button", "btn ghost tiny easy-var-add", "＋ Add variable");
     add.type = "button";
-    add.onclick = () => { rows.push({ name: "", value: "" }); S.setProjectVariables(rows); render(); };
-    list.append(add);
-
-    panel.append(list);
-    updateChrome();
+    add.onclick = () => { rows.push({ name: "", value: "" }); S.setProjectVariables(rows); renderList(); updateHint(); };
+    listEl.append(add);
   }
 
-  toggleBtn.onclick = () => {
-    if (!S.get().project) return;
-    open = !open;
-    render();
-  };
+  function close() {
+    if (overlay) { overlay.remove(); overlay = null; }
+    listEl = null; hintEl = null;
+    updateButton();
+  }
 
-  // Rebuild only when the project actually changes (a fresh set of rows); every other
-  // notify just refreshes the count/warning so in-progress typing is never interrupted.
+  function open() {
+    if (!S.get().project) return;
+    close();
+    overlay = el("div", "modal-overlay");
+    const box = el("div", "modal modal-wide");
+
+    const head = el("div", "modal-head");
+    head.append(el("div", "modal-title", "Variables"));
+    const x = el("button", "btn ghost tiny", "✕");
+    x.onclick = close;
+    head.append(el("div", "modal-head-right"), x);
+    box.append(head);
+
+    const content = el("div", "modal-content easy-vars");
+    content.append(el("div", "easy-vars-hint",
+      "Shorthand for full phrases. Type $name in the prompt (or inside a shortcut's replacement) "
+      + "and it's swapped for the text below at generation — after shortcuts expand and after the "
+      + "prompt splits into scenes, so a value can never move a scene cut."));
+    hintEl = el("div", "easy-vars-hint easy-var-hint");
+    content.append(hintEl);
+    listEl = el("div", "easy-var-list");
+    content.append(listEl);
+    box.append(content);
+
+    overlay.append(box);
+    overlay.addEventListener("click", (e) => { if (e.target === overlay) close(); });
+    document.addEventListener("keydown", function onKey(e) {
+      if (e.key === "Escape") { close(); document.removeEventListener("keydown", onKey); }
+    });
+    document.body.append(overlay);
+
+    rows = vars();
+    renderList();
+    updateHint();
+  }
+
+  toggleBtn.onclick = () => (overlay ? close() : open());
+
+  // A project switch replaces the whole variable set — rebuild the open window's rows.
+  let renderedProjectId = null;
   S.subscribe((st) => {
     const pid = st.project ? st.project.id : null;
     if (pid !== renderedProjectId) {
       renderedProjectId = pid;
-      if (open) { render(); return; }
+      if (overlay) { rows = vars(); renderList(); updateHint(); return; }
     }
-    updateChrome();
+    updateButton();
   });
-  if (promptEl) promptEl.addEventListener("input", updateChrome);
+  if (promptEl) promptEl.addEventListener("input", () => { if (overlay) updateHint(); else updateButton(); });
 
-  updateChrome();
+  updateButton();
+  window.EasyVariables = { open, close };
 })();
diff --git a/easy_gen/frontend/index.html b/easy_gen/frontend/index.html
index 2e8b33f0..1a13a2e0 100644
--- a/easy_gen/frontend/index.html
+++ b/easy_gen/frontend/index.html
@@ -55,8 +55,6 @@
       <div class="easy-project-name" id="easy-project-name">No project</div>
       <span class="health-chip" id="easy-health-chip"></span>
       <div class="menubar-right">
-        <button class="btn ghost tiny" id="easy-vars-btn" type="button"
-          title="Prompt $name variables — shorthand for full phrases, substituted at generation">▸ $ Variables</button>
         <button class="btn ghost tiny" id="easy-save-btn" type="button">Save</button>
         <button class="btn ghost tiny" id="easy-export-btn" type="button"
           title="Download this project as a .funpack_project.json file — e.g. to move it off a rental machine">Export…</button>
@@ -66,13 +64,13 @@
 
     <main class="easy-preview" id="easy-preview"></main>
 
-    <section class="easy-vars" id="easy-vars" hidden></section>
-
     <footer class="easy-bar">
       <button class="btn ghost easy-upload-btn" id="easy-upload-btn" type="button"
         title="Upload an image or video to guide generation">⬆ Upload</button>
       <button class="btn ghost easy-gallery-btn" id="easy-gallery-btn" type="button"
         title="Choose from previously uploaded media">🖼 Gallery</button>
+      <button class="btn ghost easy-vars-btn" id="easy-vars-btn" type="button"
+        title="Prompt $name variables — shorthand for full phrases, substituted at generation">$ Variables</button>
       <textarea class="easy-prompt" id="easy-prompt" rows="2"
         placeholder="Describe what you want to generate…"></textarea>
       <div class="easy-actions">
diff --git a/movie_editor/frontend/composer.js b/movie_editor/frontend/composer.js
index ec48cc59..10be2ab9 100644
--- a/movie_editor/frontend/composer.js
+++ b/movie_editor/frontend/composer.js
@@ -284,6 +284,24 @@
   // ── variables panel (below the global prompt) ───────────────────────────────────
   // The list IS the editor: editable name/value rows + Add/Remove. Resolution happens at
   // generation, after shortcuts + split (Studio), so nothing here touches the timeline.
+
+  // Grow a value textarea to fit its text (measured after a reset to "auto", or it can only
+  // ever get taller). Deferred once on mount because scrollHeight reads 0 before layout.
+  function autoGrowVar(ta) {
+    const fit = () => {
+      ta.style.height = "auto";
+      // scrollHeight covers content + padding; under border-box the borders must be added
+      // back or every line is clipped by ~2px and the textarea scrolls anyway.
+      const cs = getComputedStyle(ta);
+      const border = cs.boxSizing === "border-box"
+        ? parseFloat(cs.borderTopWidth) + parseFloat(cs.borderBottomWidth)
+        : -(parseFloat(cs.paddingTop) + parseFloat(cs.paddingBottom));
+      ta.style.height = (ta.scrollHeight + (border || 0)) + "px";
+    };
+    fit();
+    if (!ta.dataset.grown) { ta.dataset.grown = "1"; setTimeout(fit, 0); }
+  }
+
   function composeVariables() {
     const box = el("div", "compose-vars");
     const toggle = el("button", "btn ghost tiny composer-var-toggle",
@@ -310,10 +328,15 @@
         nm.oninput = () => { v.name = nm.value.replace(/^\$+/, ""); commit(); updateVarHint(); };
         row.append(nm);
         row.append(el("span", "compose-var-eq", "="));
-        const vv = el("input", "lib-in compose-var-val");
+        // Values are usually long phrases, so this grows with its content — a one-line input
+        // makes editing "High quality, high fidelity realistic video, …" a horizontal-
+        // scrolling guessing game.
+        const vv = el("textarea", "lib-in compose-var-val");
+        vv.rows = 1;
         vv.value = v.value; vv.placeholder = "value (may reference $other)";
-        vv.oninput = () => { v.value = vv.value; commit(); updateVarHint(); };
+        vv.oninput = () => { v.value = vv.value; autoGrowVar(vv); commit(); updateVarHint(); };
         row.append(vv);
+        autoGrowVar(vv);
         const rm = el("button", "btn ghost tiny", "✕");
         rm.title = "Remove variable";
         rm.onclick = () => { vars.splice(i, 1); commit(); render(); };
diff --git a/movie_editor/frontend/styles.css b/movie_editor/frontend/styles.css
index 2caaa071..e0a778a3 100644
--- a/movie_editor/frontend/styles.css
+++ b/movie_editor/frontend/styles.css
@@ -1194,11 +1194,14 @@ body.tl-spacing { cursor: grabbing; user-select: none; }
 .compose-var-hint { margin-top: 4px; }
 .compose-var-hint.compose-var-warn { color: var(--amber); }
 .compose-var-list { margin-top: 6px; display: flex; flex-direction: column; gap: 6px; }
-.compose-var-row { display: flex; gap: 6px; align-items: center; }
+.compose-var-row { display: flex; gap: 6px; align-items: flex-start; }
+.compose-var-row > .compose-var-dollar, .compose-var-row > .compose-var-eq,
+.compose-var-row > .btn { margin-top: 5px; }
 .compose-var-dollar { color: var(--amber); font-family: var(--font-mono); opacity: 0.8; }
 .compose-var-eq { color: var(--muted); }
 .compose-var-row .compose-var-name { flex: 0 0 30%; min-width: 0; }
-.compose-var-row .compose-var-val { flex: 1; min-width: 0; }
+/* Value is an auto-growing textarea (JS sets the height) — no resize handle, no scrollbar. */
+.compose-var-row .compose-var-val { flex: 1; min-width: 0; resize: none; overflow: hidden; }
 .compose-var-row .btn { flex: 0 0 auto; }
 
 /* config validation banner */

From 3222fbcb3103baec5dc0863bae271985d06b3a11 Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Sun, 26 Jul 2026 20:22:48 +0300
Subject: [PATCH 03/29] Easy Gen: Interrupt button on the progress panel
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Easy Gen had no way to stop a run — the only exit was the ComfyUI queue. Adds
the same "■ Interrupt" control the Cutting Room's player readout uses (shared
.gen-interrupt styling), living inside the progress panel so it exists only
while there is something to stop.

ComfyUI records an interrupted prompt in history as status_str "error" with no
media, which the status endpoint cannot tell apart from a real crash — so watch()
remembers that the stop was asked for and reports "Generation stopped." instead
of "Generation failed.", while still showing any partial media the run wrote.
A failed interrupt call re-enables the button and says so rather than leaving a
dead control over a run that is still going.

Co-Authored-By: Claude <noreply@anthropic.com>
---
 CHANGELOG.md                 |  6 ++++++
 easy_gen/frontend/easy.css   |  5 ++++-
 easy_gen/frontend/preview.js | 41 ++++++++++++++++++++++++++++++++----
 3 files changed, 47 insertions(+), 5 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7950fa07..c2f63b07 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -12,6 +12,12 @@
   still happens inside Studio dead-last — after shortcut expansion and after the scene split
   — which is what makes a `$var` work *inside* a shortcut's replacement while a value
   containing a comma or a trigger word can never move a scene cut.
+- **An Interrupt button in Easy Gen.** The progress panel now carries the same
+  **■ Interrupt** control the Cutting Room's player has — Easy Gen previously had no way to
+  stop a run short of the ComfyUI queue. A stopped run reports "Generation stopped." instead
+  of a failure (an interrupted job is recorded as an error with no media, which is
+  indistinguishable from a real crash at the API level), and any partial media it did write
+  is still shown.
 
 ### Changed
 - **Variable values are now auto-growing text boxes** (both UIs) instead of one-line inputs —
diff --git a/easy_gen/frontend/easy.css b/easy_gen/frontend/easy.css
index 3a6bf735..b3adc30b 100644
--- a/easy_gen/frontend/easy.css
+++ b/easy_gen/frontend/easy.css
@@ -58,7 +58,10 @@ a.brand:hover .brand-sub { color: var(--amber-2); }
   height: 6px; border-radius: 4px; background: linear-gradient(90deg, var(--amber), var(--amber-2));
   width: 0%; transition: width .2s ease; margin-bottom: 6px;
 }
-.easy-progress-label { font-size: 12px; color: var(--muted); font-family: var(--font-mono); }
+.easy-progress-row { display: flex; align-items: center; gap: 10px; }
+.easy-progress-label { flex: 1; min-width: 0; font-size: 12px; color: var(--muted); font-family: var(--font-mono);
+  overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.easy-progress-stop:disabled { opacity: .6; cursor: default; }
 
 .easy-bar {
   flex: none; display: flex; align-items: flex-end; gap: 12px;
diff --git a/easy_gen/frontend/preview.js b/easy_gen/frontend/preview.js
index 9902058d..3dd97fa6 100644
--- a/easy_gen/frontend/preview.js
+++ b/easy_gen/frontend/preview.js
@@ -22,7 +22,14 @@
     progressWrap.hidden = true;
     const bar = el("div", "easy-progress-bar");
     const label = el("div", "easy-progress-label");
-    progressWrap.append(bar, label);
+    // Same "■ Interrupt" affordance as the Cutting Room's player readout, and it lives in the
+    // progress panel so it only exists while there's something to stop.
+    const stopBtn = el("button", "gen-interrupt easy-progress-stop", "■ Interrupt");
+    stopBtn.type = "button";
+    stopBtn.title = "Stop the current generation";
+    const progressRow = el("div", "easy-progress-row");
+    progressRow.append(label, stopBtn);
+    progressWrap.append(bar, progressRow);
     root.append(inner, closeBtn, badge, progressWrap);
 
     let pollTimer = null;
@@ -138,8 +145,29 @@
       progressWrap.hidden = false;
       label.textContent = "Starting…";
       bar.style.width = "0%";
+      // An interrupted job lands in ComfyUI's history as status_str "error" with no media —
+      // indistinguishable from a real failure at the API level. Remember that the user asked
+      // for it so the poll below reports "stopped", not "Generation failed".
+      let interrupted = false;
+      stopBtn.disabled = false;
+      stopBtn.textContent = "■ Interrupt";
+      stopBtn.onclick = async () => {
+        interrupted = true;
+        stopBtn.disabled = true;
+        stopBtn.textContent = "Interrupting…";
+        label.textContent = "Interrupting…";
+        try { await API.interrupt(); }
+        catch (e) {
+          // The run may well still be going — say so instead of leaving a dead button.
+          interrupted = false;
+          stopBtn.disabled = false;
+          stopBtn.textContent = "■ Interrupt";
+          label.textContent = "Could not interrupt: " + (e.message || e);
+        }
+      };
 
       progressTimer = setInterval(async () => {
+        if (interrupted) return; // don't paint "Sampling…" over "Interrupting…"
         try {
           const pr = await API.progress();
           if (pr.max > 0) {
@@ -165,14 +193,19 @@
           stopPolling();
           progressWrap.hidden = true;
           const media = res.media && res.media.length ? res.media[res.media.length - 1] : null;
-          if (media) setGenerated(media, projectId); else showEmpty("Generation finished but produced no media.");
-          if (onDone) onDone(true, res);
+          // A run stopped mid-sampling can still have written partial media — show it if so,
+          // it's the whole point of interrupting a long run you can already tell is wrong.
+          if (media) setGenerated(media, projectId);
+          else if (interrupted) showEmpty("Generation stopped.");
+          else showEmpty("Generation finished but produced no media.");
+          if (onDone) onDone(!interrupted, res);
           return;
         }
         if (res.state === "error") {
           stopPolling();
           progressWrap.hidden = true;
-          showError(res.error || "Generation failed.");
+          if (interrupted) showEmpty("Generation stopped.");
+          else showError(res.error || "Generation failed.");
           if (onDone) onDone(false, res);
           return;
         }

From 5af0a1b5d3edde73fb1ca1426de0fc9ccbae17b2 Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Wed, 29 Jul 2026 16:25:12 +0300
Subject: [PATCH 04/29] Models: treat V3 MultiType widgets as widgets, not
 required sockets
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

LTXVEmptyLatentAudio.frame_rate arrives from object_info as
("FLOAT,INT", {"widgetType": "INT", ...}) — a V3 MultiType wrapped around an
int widget. The editor split types on exact string match, so the union looked
like an unknown connection type: the field vanished from the node's widgets,
turned into a required input source no node could satisfy, and blocked
generation with 'has no source'.

Classification now goes through nodes.widget_type_of(): an input whose members
are all widget types (or that carries a widgetType hint) is a widget, rendered
and defaulted as its widget member. Genuine unions ("IMAGE,MASK") stay sockets
and match a producer of any member via type_accepts(), used by auto-wire,
bypass passthrough, the source/destination pickers and the image-target list.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 movie_editor/backend/builder.py    | 39 +++++++++++++-------
 movie_editor/backend/nodes.py      | 59 +++++++++++++++++++++++++++---
 movie_editor/frontend/models.js    | 26 ++++++++-----
 movie_editor/server.py             |  4 +-
 movie_editor/tests/test_builder.py | 30 +++++++++++++++
 movie_editor/tests/test_nodes.py   | 41 +++++++++++++++++++++
 6 files changed, 169 insertions(+), 30 deletions(-)

diff --git a/movie_editor/backend/builder.py b/movie_editor/backend/builder.py
index f6b5d9d4..ad97932b 100644
--- a/movie_editor/backend/builder.py
+++ b/movie_editor/backend/builder.py
@@ -25,7 +25,8 @@ from typing import Any, Optional
 
 from . import config
 from . import pipeline_wiring
-from .nodes import WIDGET_PRIMITIVES, connection_inputs, node_outputs, _combo_default, _combo_choices
+from .nodes import (WIDGET_PRIMITIVES, connection_inputs, node_outputs, type_accepts,
+                    widget_type_of, _combo_default, _combo_choices)
 
 # ── fixed core ────────────────────────────────────────────────────────────────
 # logical id -> class_type
@@ -116,7 +117,7 @@ def _ordered_widget_names(node_def: dict) -> list[str]:
             opts = spec[1] if len(spec) > 1 and isinstance(spec[1], dict) else {}
             if opts.get("forceInput"):
                 continue  # forceInput STRING is a socket, never a widget value
-            if isinstance(t, list) or t in WIDGET_PRIMITIVES:
+            if isinstance(t, list) or widget_type_of(t, opts) in WIDGET_PRIMITIVES:
                 names.append(name)
     return names
 
@@ -158,18 +159,19 @@ def _widget_defaults(node_def: Optional[dict]) -> dict:
             opts = spec[1] if len(spec) > 1 and isinstance(spec[1], dict) else {}
             if opts.get("forceInput"):
                 continue
+            wt = widget_type_of(t, opts) if isinstance(t, str) else None
             if isinstance(t, list):
                 out[name] = opts.get("default", t[0] if t else None)
-            elif isinstance(t, str) and "COMBO" in t.upper():
+            elif wt and "COMBO" in wt.upper():
                 # "COMBO" or a V3 dynamic combo (COMFY_DYNAMICCOMBO_V3): emit the selected
                 # key string (options may be {"key": ...} dicts), not the option object.
                 out[name] = _combo_default(opts)
-            elif t in WIDGET_PRIMITIVES:
+            elif wt in WIDGET_PRIMITIVES:
                 # Always emit a value for every widget — ComfyUI's frontend does, and a
                 # required widget with no declared default (e.g. ImageTransform's bboxes)
                 # otherwise goes missing and ComfyUI rejects the prompt. Fall back to a
                 # type-appropriate empty so generation isn't blocked.
-                out[name] = opts.get("default", _WIDGET_EMPTY.get(t, ""))
+                out[name] = opts.get("default", _WIDGET_EMPTY.get(wt, ""))
     return out
 
 
@@ -192,7 +194,7 @@ def _widget_choices(node_def: Optional[dict]) -> dict:
             if isinstance(t, list):
                 if t:
                     out[name] = t
-            elif isinstance(t, str) and "COMBO" in t.upper():
+            elif isinstance(t, str) and "COMBO" in (widget_type_of(t, opts) or "").upper():
                 choices = _combo_choices(opts)
                 if choices:
                     out[name] = choices
@@ -627,7 +629,7 @@ def core_graph(object_info: dict, models_config: dict | None = None) -> list[dic
 
     def _options(t, builtin_label, self_cid):
         opts = [{"value": "", "label": f"built-in: {builtin_label}"}]
-        for val, lbl in producers.get(t, []):
+        for val, lbl in _matching_producers(producers, t):
             if val.startswith(f"core:{self_cid}:"):
                 continue
             opts.append({"value": val, "label": lbl})
@@ -714,6 +716,18 @@ def _producers(graph, slots, slot_node_id, slot_def, object_info):
     return out
 
 
+def _matching_producers(producers: dict, t: str) -> list:
+    """Producers that can feed an input of type `t`. A union type ("IMAGE,MASK") is fed by
+    any of its members, so collect across them instead of matching the string exactly."""
+    if t in producers:
+        return producers[t]
+    out = []
+    for pt, lst in producers.items():
+        if type_accepts(t, pt):
+            out.extend(lst)
+    return out
+
+
 def _reaches_upstream(graph, start, goal):
     """True if `goal` is upstream of `start` — i.e. `start` transitively consumes `goal`'s
     output. Used to decide whether wiring `start`'s output into a node would close a loop."""
@@ -838,7 +852,7 @@ def _autowire(graph, slots, slot_node_id, slot_def, object_info, producers, repo
             continue
         if isinstance(node["inputs"].get(inp), list):
             continue  # already wired (explicit/core)
-        raw = [p for p in producers.get(t, []) if p[0] != node_id]
+        raw = [p for p in _matching_producers(producers, t) if p[0] != node_id]
         # Never auto-wire a source that already depends on this node — that closes a loop and
         # ComfyUI rejects the whole graph. Drop such candidates so auto-wire stays acyclic.
         cands = [p for p in raw if not _reaches_upstream(graph, p[0], node_id)]
@@ -880,14 +894,13 @@ def _apply_bypass(graph, slots, slot_node_id, slot_def, report):
             continue
         nd = slot_def.get(s["id"]) or {}
         outs = node_outputs(nd)
-        by_type: dict[str, list[str]] = {}
-        for ci in connection_inputs(nd):
-            by_type.setdefault(ci["type"], []).append(ci["name"])
+        cis = connection_inputs(nd)
         passthrough = {}
         ok = True
         for i, o in enumerate(outs):
-            names = by_type.get(o["type"])
-            if not names or len(names) != 1:
+            # A union-typed input ("IMAGE,MASK") can carry any of its members through.
+            names = [ci["name"] for ci in cis if type_accepts(ci["type"], o["type"])]
+            if len(names) != 1:
                 ok = False
                 break
             passthrough[i] = graph[sid]["inputs"].get(names[0])
diff --git a/movie_editor/backend/nodes.py b/movie_editor/backend/nodes.py
index a2b8b840..4af32be4 100644
--- a/movie_editor/backend/nodes.py
+++ b/movie_editor/backend/nodes.py
@@ -36,6 +36,47 @@ def _is_widget_type(t) -> bool:
     return isinstance(t, str) and (t in _WIDGET_TYPES or _is_combo_type(t))
 
 
+def type_parts(t) -> list[str]:
+    """Member types of a ComfyUI type string. A V3 MultiType input serializes its members
+    comma-joined — "FLOAT,INT" (an int widget that also accepts a float link), "IMAGE,MASK"
+    (a socket taking either) — so a single string can name several types."""
+    if not isinstance(t, str):
+        return []
+    return [p.strip() for p in t.split(",") if p.strip()]
+
+
+def widget_type_of(t, opts: dict | None = None) -> str | None:
+    """The widget type an input renders as, or None if it is a pure graph socket.
+
+    A V3 MultiType wrapped around a widget input (io.MultiType.Input(io.Int.Input(...), ...))
+    is a WIDGET in ComfyUI's frontend, not a socket: it carries "widgetType" in its options
+    and lists the widget's own type first, e.g. LTXVEmptyLatentAudio.frame_rate arriving as
+    ("FLOAT,INT", {"widgetType": "INT", "default": 25}). Treating it as a required socket
+    would demand a source for a field the user simply types into."""
+    opts = opts or {}
+    wt = opts.get("widgetType")
+    if _is_widget_type(wt):
+        return wt
+    parts = type_parts(t)
+    if parts and all(_is_widget_type(p) for p in parts):
+        return parts[0]
+    return None
+
+
+def link_types(t) -> list[str]:
+    """The graph-connection member types of a type string (widget members dropped)."""
+    return [_normalize_type(p) for p in type_parts(t) if not _is_widget_type(p)]
+
+
+def type_accepts(input_type: str, output_type: str) -> bool:
+    """Whether an output of `output_type` can feed an input of `input_type`. Either side may
+    be a union, so they match when any member type is shared."""
+    a, b = type_parts(input_type), type_parts(output_type)
+    if not a or not b:
+        return input_type == output_type
+    return bool({_normalize_type(x) for x in a} & {_normalize_type(y) for y in b})
+
+
 def _combo_choices(opts: dict) -> list:
     """Normalise combo options to plain string/int choices. V3 dynamic combos express
     options as dicts {"key": <value>, "inputs": [...]}; standard combos are list[str]."""
@@ -120,8 +161,9 @@ def _all_input_types(node_def: dict) -> list[str]:
     for group in ("required", "optional"):
         for spec in (inp.get(group) or {}).values():
             t = spec[0] if isinstance(spec, list) and spec else None
-            if isinstance(t, str) and t not in _WIDGET_TYPES:
-                types.append(_normalize_type(t))
+            opts = spec[1] if isinstance(spec, list) and len(spec) > 1 and isinstance(spec[1], dict) else {}
+            if isinstance(t, str) and not widget_type_of(t, opts):
+                types.extend(link_types(t))
     return types
 
 
@@ -153,15 +195,17 @@ def connection_inputs(node_def: dict) -> list[dict]:
             if not isinstance(t, str):
                 continue
             opts = spec[1] if len(spec) > 1 and isinstance(spec[1], dict) else {}
-            if _is_widget_type(t):
+            wt = widget_type_of(t, opts)
+            if wt:
                 # A widget-typed input is a SOCKET (wireable) only when forceInput is set —
                 # e.g. refinement_key_input is ("STRING", {"forceInput": True}). It always
                 # has a widget fallback, so it's NEVER auto-required (it must not block
                 # generation when left unwired). Plain widgets (incl. V3 dynamic combos
-                # like COMFY_DYNAMICCOMBO_V3) are handled by widget_inputs, not here.
+                # like COMFY_DYNAMICCOMBO_V3 and MultiType widgets like ("FLOAT,INT", ...))
+                # are handled by widget_inputs, not here.
                 if not opts.get("forceInput"):
                     continue
-                out.append({"name": name, "type": _normalize_type(t), "required": False})
+                out.append({"name": name, "type": _normalize_type(wt), "required": False})
                 continue
             # V3 nodes can mark a required-group input as optional via the flag.
             is_required = group == "required" and not opts.get("optional", False)
@@ -201,6 +245,9 @@ def widget_inputs(node_def: dict) -> list[dict]:
             if opts.get("forceInput"):
                 continue
             field = {"name": name, "required": group == "required", "options": opts}
+            # A MultiType widget ("FLOAT,INT") renders as its widget member, not the union.
+            if isinstance(t, str):
+                t = widget_type_of(t, opts) or t
             if isinstance(t, list):
                 # Old-style combo: t is the list of choices (e.g. folder_paths filenames).
                 field["kind"] = "combo"
@@ -307,7 +354,7 @@ def ports_from_input_types(label: str, node_key: str, input_types: dict) -> list
             opts = spec[1] if len(spec) > 1 and isinstance(spec[1], dict) else {}
             # Expose typed sockets, plus forceInput widget sockets (e.g. the STRING
             # refinement_key_input on Studio/Sampler) so they can be wired manually.
-            if _is_widget_type(t) and not opts.get("forceInput"):
+            if widget_type_of(t, opts) and not opts.get("forceInput"):
                 continue
             ports.append({"id": f"{node_key}.{name}", "node": label, "input": name,
                           "type": t, "label": f"{label} · {name}"})
diff --git a/movie_editor/frontend/models.js b/movie_editor/frontend/models.js
index 9c5b14df..6584ea7d 100644
--- a/movie_editor/frontend/models.js
+++ b/movie_editor/frontend/models.js
@@ -134,7 +134,7 @@
   function allowedSources(slot, ci) {
     const all = sources(slot, ci.type);
     if (!pipelineLocked()) return all;
-    if (slot.role === "image_processing" && ci.name === "image" && ci.type === "IMAGE") {
+    if (slot.role === "image_processing" && ci.name === "image" && typeAccepts(ci.type, "IMAGE")) {
       return all.filter((s) => !s.value || s.value === "timeline" || s.value.startsWith("out:"));
     }
     return all.filter((s) => !s.value || s.value.startsWith("out:") || s.value === "timeline");
@@ -361,7 +361,7 @@
     // that feeds nothing must not be flagged or block generation.
     if (slotIsActive(slot)) (spec.connection_inputs || []).forEach((ci) => {
       if (!ci.required) return;
-      if (ci.type === "IMAGE") return;  // a scene/timeline image can always feed an IMAGE input
+      if (typeAccepts(ci.type, "IMAGE")) return;  // a scene/timeline image can always feed an IMAGE input
       const src = (slot.input_sources || {})[ci.name];
       if (src && src !== "auto") return;  // explicitly sourced (incl. "timeline")
       const incoming = (config.slots || []).some((s2) =>
@@ -546,16 +546,24 @@
   }
 
   const _KIND2T = { int: "INT", float: "FLOAT", string: "STRING", boolean: "BOOLEAN" };
+  // A ComfyUI type string can name several types at once — a V3 MultiType socket serializes
+  // its members comma-joined ("IMAGE,MASK"). An output feeds an input when they share one.
+  function typeAccepts(inputType, outputType) {
+    if (inputType === outputType) return true;
+    const parts = (t) => String(t || "").split(",").map((p) => p.trim()).filter(Boolean);
+    const a = parts(inputType), b = parts(outputType);
+    return a.some((x) => b.includes(x));
+  }
   function destinations(slot, type) {
     const out = [{ value: "", label: "— unwired —" }];
     // Global editor outputs: wire your final video/audio producer here and the editor shows
     // it (works with or without the built-in pipeline). IMAGE -> video, AUDIO -> audio.
-    if (type === "IMAGE") out.push({ value: "global:video", label: "🌐 Global video output (shown in editor)" });
-    if (type === "AUDIO") out.push({ value: "global:audio", label: "🌐 Global audio output (shown in editor)" });
-    ports.filter((p) => p.type === type).forEach((p) => out.push({ value: "port:" + p.id, label: p.label }));
+    if (typeAccepts(type, "IMAGE")) out.push({ value: "global:video", label: "🌐 Global video output (shown in editor)" });
+    if (typeAccepts(type, "AUDIO")) out.push({ value: "global:audio", label: "🌐 Global audio output (shown in editor)" });
+    ports.filter((p) => typeAccepts(p.type, type)).forEach((p) => out.push({ value: "port:" + p.id, label: p.label }));
     config.slots.filter((s) => s.id !== slot.id).forEach((s2) => {
       const c2 = specFor(s2);
-      (c2?.connection_inputs || []).filter((ci) => ci.type === type).forEach((ci) =>
+      (c2?.connection_inputs || []).filter((ci) => typeAccepts(ci.type, type)).forEach((ci) =>
         out.push({ value: `node:${s2.id}:${ci.name}`, label: `${slotFullLabel(s2)} · ${ci.name}` }));
       // Widget inputs can also receive a connection (ComfyUI converts a widget to an
       // input when wired) — e.g. EmptyLatentVideo.width/height. Offer them as targets.
@@ -569,12 +577,12 @@
   // Source IDs: "" = auto, "out:<slotId>:<outName>", "core:<coreId>:<outIdx>", "timeline" (IMAGE only).
   function sources(slot, type) {
     const out = [{ value: "", label: "(auto-wire)" }];
-    if (type === "IMAGE") out.push({ value: "timeline", label: "Timeline (scene image)" });
-    coreProducers.filter((p) => p.type === type).forEach((p) =>
+    if (typeAccepts(type, "IMAGE")) out.push({ value: "timeline", label: "Timeline (scene image)" });
+    coreProducers.filter((p) => typeAccepts(type, p.type)).forEach((p) =>
       out.push({ value: p.id, label: p.label }));
     config.slots.filter((s) => s.id !== slot.id).forEach((s2) => {
       const c2 = specFor(s2);
-      (c2?.outputs || []).filter((o) => o.type === type).forEach((o) =>
+      (c2?.outputs || []).filter((o) => typeAccepts(type, o.type)).forEach((o) =>
         out.push({ value: `out:${s2.id}:${o.name}`, label: `${slotFullLabel(s2)} → ${o.name}` }));
     });
     return out;
diff --git a/movie_editor/server.py b/movie_editor/server.py
index d605b257..cd2c9ae0 100644
--- a/movie_editor/server.py
+++ b/movie_editor/server.py
@@ -2264,14 +2264,14 @@ if web is not None and PromptServer is not None:
             oi = {}
         out = []
         for p in nodes.pipeline_ports(oi):
-            if p.get("type") == "IMAGE":
+            if nodes.type_accepts(p.get("type") or "", "IMAGE"):
                 out.append({"value": "port:" + p["id"], "label": p["label"]})
         pid = req.query.get("pid")
         models_cfg = _project_models(projects.get(pid)) if pid else nodes.load_models()
         for slot in models_cfg.get("slots", []):
             nd = oi.get(slot.get("node_class")) or {}
             for ci in nodes.connection_inputs(nd):
-                if ci["type"] == "IMAGE":
+                if nodes.type_accepts(ci["type"], "IMAGE"):
                     label = (slot.get("label") or slot.get("node_class")) + " · " + ci["name"]
                     out.append({"value": f"node:{slot['id']}:{ci['name']}", "label": label})
         return web.json_response({"targets": out})
diff --git a/movie_editor/tests/test_builder.py b/movie_editor/tests/test_builder.py
index 6d22ff65..9c6154b6 100644
--- a/movie_editor/tests/test_builder.py
+++ b/movie_editor/tests/test_builder.py
@@ -207,6 +207,36 @@ def test_ambiguous_type_is_reported_not_guessed():
     assert any("FunPackLTXAVSceneChainSampler" in a and ".vae" in a for a in report["ambiguous"])
 
 
+def test_multitype_widget_input_does_not_block_and_keeps_its_value():
+    # LTXVEmptyLatentAudio.frame_rate arrives as a V3 MultiType widget ("FLOAT,INT" with a
+    # widgetType hint). It is a field, not a socket: it must not demand a source (nothing
+    # outputs "FLOAT,INT", so the run was blocked) and its value must reach the graph.
+    oi = dict(OI)
+    oi["LTXVEmptyLatentAudio"] = {
+        "input": {"required": {
+            "frames_number": ["INT", {"default": 97}],
+            "frame_rate": ["FLOAT,INT", {"widgetType": "INT", "default": 25}],
+            "audio_vae": ["VAE"],
+        }},
+        "output": ["LATENT"], "output_name": ["Latent"]}
+    models = {"full_control": True, "slots": [
+        {"id": "u", "node_class": "UnetLoader", "inputs": {}, "wires": {"MODEL": "port:FunPackStudio.model"}},
+        {"id": "c", "node_class": "ClipLoader", "inputs": {}, "wires": {"CLIP": "port:FunPackStudio.clip"}},
+        {"id": "v", "node_class": "VaeLoader", "inputs": {},
+         "wires": {"VAE": "port:FunPackLTXAVSceneChainSampler.vae"}},
+        {"id": "av", "node_class": "VaeLoader", "inputs": {},
+         "wires": {"VAE": ["node:ae:audio_vae", "port:LTXVAudioVAEDecode.audio_vae"]}},
+        {"id": "ae", "node_class": "LTXVEmptyLatentAudio", "inputs": {"frame_rate": 30},
+         "wires": {"Latent": "port:LTXVConcatAVLatent.audio_latent"}},
+    ]}
+    graph, report = builder.build(oi, models, PARAMS)
+    assert report["blocking"] == []
+    assert not any("frame_rate" in m for m in report["unsatisfied"] + report["ambiguous"])
+    assert graph["slot_ae"]["inputs"]["frame_rate"] == 30       # user value, not a link
+    assert graph["slot_ae"]["inputs"]["frames_number"] == 97     # default still emitted
+    assert graph["slot_ae"]["inputs"]["audio_vae"] == ["slot_av", 0]
+
+
 def _loaders():
     return [
         {"id": "u", "node_class": "UnetLoader", "inputs": {}, "wires": {"MODEL": "port:FunPackStudio.model"}},
diff --git a/movie_editor/tests/test_nodes.py b/movie_editor/tests/test_nodes.py
index 7de08512..999f8157 100644
--- a/movie_editor/tests/test_nodes.py
+++ b/movie_editor/tests/test_nodes.py
@@ -154,6 +154,47 @@ def test_v1_combo_and_force_input():
     assert ci["blocks"] == "SELECTEDDITBLOCKS"
 
 
+def test_multitype_widget_is_a_widget_not_a_required_socket():
+    """A V3 MultiType built around a widget input serializes comma-joined with a widgetType
+    hint — e.g. LTXVEmptyLatentAudio.frame_rate as ("FLOAT,INT", {"widgetType": "INT"}).
+    It is a field the user types into; treating it as a socket demanded a source that no
+    node produces and blocked generation."""
+    oi = dict(OI)
+    oi["LTXVEmptyLatentAudio"] = {
+        "input": {"required": {
+            "frames_number": ["INT", {"default": 97}],
+            "frame_rate": ["FLOAT,INT", {"widgetType": "INT", "default": 25, "min": 1}],
+            "batch_size": ["INT", {"default": 1}],
+            "audio_vae": ["VAE"],
+        }},
+        "output": ["LATENT"], "output_name": ["Latent"],
+        "display_name": "LTXV Empty Latent Audio",
+    }
+    desc = nodes.describe_node(oi, "LTXVEmptyLatentAudio")
+    widgets = {w["name"]: w for w in desc["inputs"]}
+    assert widgets["frame_rate"]["kind"] == "int"        # renders as the widget it is
+    assert widgets["frame_rate"]["default"] == 25
+    ci = {c["name"]: c["type"] for c in desc["connection_inputs"]}
+    assert ci == {"audio_vae": "VAE"}                    # frame_rate is NOT a socket
+    # ...and it still qualifies for the audio_encoder role (union widget isn't an input type)
+    assert "LTXVEmptyLatentAudio" in [c["class"] for c in nodes.candidates(oi, "audio_encoder")]
+
+
+def test_multitype_socket_stays_a_socket_and_matches_any_member():
+    """A MultiType with no widget member ("IMAGE,MASK") is a real socket — it must still be
+    offered as one, and fed by a producer of either member type."""
+    oi = {"ImageResizeMatch": {"input": {"required": {"image": ["IMAGE"],
+                                                      "match": ["IMAGE,MASK"]}},
+                               "output": ["IMAGE"], "display_name": "Resize to Match"}}
+    ci = {c["name"]: (c["type"], c["required"]) for c in nodes.describe_node(oi, "ImageResizeMatch")["connection_inputs"]}
+    assert ci["match"] == ("IMAGE,MASK", True)
+    assert nodes.type_accepts("IMAGE,MASK", "MASK")
+    assert nodes.type_accepts("IMAGE,MASK", "IMAGE")
+    assert not nodes.type_accepts("IMAGE,MASK", "LATENT")
+    assert nodes.widget_type_of("IMAGE,MASK", {}) is None
+    assert nodes.widget_type_of("FLOAT,INT", {}) == "FLOAT"   # no hint → first member wins
+
+
 def test_models_store_roundtrip(tmp_path, monkeypatch):
     from movie_editor.backend import config
     monkeypatch.setattr(config, "DATA_DIR", tmp_path)

From 3948f640333c16c44b40b279804ed85981c7e224 Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Wed, 29 Jul 2026 17:28:35 +0300
Subject: [PATCH 05/29] Identity transfer: support ComfyUI's new RoPE matrix
 layout
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

ComfyUI 7c59a07 ("Use comfy kitchen rope functions in ltx models", 2026-07-24)
changed the LTX positional-embedding payload from (cos, sin, split_mode) to
(rotation_matrix, split_mode), where the matrix is (B, T, heads, D, 2, 2)
holding [[cos, -sin], [sin, cos]].

rotate_overlap_freqs read pe[1] as the sin tensor — now a bool — so it raised,
and prepare_pe's bare `except: return pe` swallowed it. The Best-FaceID
reference tokens were still appended on the target's frame-0 coordinate grid
but WITHOUT the source-phase tag that marks them as a reference, so the model
read them as literal frame 0 and opened the clip on the reference image.
Anyone on ComfyUI >= 2026-07-24 saw i2v-like behaviour they couldn't bypass.

rotate_overlap_freqs now detects the layout at runtime (pe[1] is a tensor =>
legacy cos/sin; otherwise the matrix form, tokens on axis 1, frequencies on
-3) and composes the same R(angle + phase) either way. An unrecognised payload
raises instead of silently skipping the tag.

The four LTXBaseModel wrappers no longer fail silently: each reports once per
install that identity conditioning is not being applied and that a ComfyUI
update is the likely cause. A logged warning would have made this obvious.

Tests: both layouts rotate only the ref-token tail, produce identical angles,
reject unknown payloads, and the matrix form survives end-to-end through
_install_identity_overlap.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 identity_transfer.py            | 80 ++++++++++++++++++++++++++-------
 samplers.py                     | 25 +++++++++--
 tests/test_identity_transfer.py | 77 +++++++++++++++++++++++++++++++
 3 files changed, 162 insertions(+), 20 deletions(-)

diff --git a/identity_transfer.py b/identity_transfer.py
index 172c26a3..a37d9627 100644
--- a/identity_transfer.py
+++ b/identity_transfer.py
@@ -121,25 +121,73 @@ def append_context_tokens(conditioning, tokens):
     return out
 
 
+def _segment_phase(length, seg_value, theta, device, dtype):
+    """(cos, sin) of phase = seg_value * theta^(-d/length) over the frequency axis."""
+    d = torch.arange(length, device=device, dtype=torch.float32)
+    phase = seg_value * (theta ** (-d / float(length)))
+    return phase.cos().to(dtype), phase.sin().to(dtype)
+
+
 def rotate_overlap_freqs(pe, ref_len, seg_value, theta=10000.0):
     """Rotate the LAST ref_len tokens' RoPE freqs by phase = seg_value * theta^(-d/L)
-    (port of ltx_core rope.apply_segment_phase). pe = (cos, sin, [split_flag])."""
+    (port of ltx_core rope.apply_segment_phase).
+
+    This phase tag is what separates the appended reference tokens from the target's real
+    frame-0 tokens — they deliberately share the frame-0 coordinate grid, so without it the
+    model reads the reference as literal frame 0 and renders the clip's opening as the
+    reference image. Never skip it silently; raise instead (see samplers.py's prepare_pe).
+
+    ComfyUI ships the positional embeddings in two layouts, told apart at runtime:
+
+      * ``(cos, sin, split_mode)`` — tokens on axis -2, frequencies on -1. ComfyUI before
+        7c59a07 (2026-07-24).
+      * ``(rotation_matrix, split_mode)`` — ``(B, T, heads, D, 2, 2)`` holding
+        ``[[cos, -sin], [sin, cos]]``, from ComfyUI 7c59a07 "Use comfy kitchen rope
+        functions in ltx models" onward.
+
+    Both encode R(angle); the phase composes onto it as R(angle + phase).
+    """
     if ref_len <= 0 or seg_value == 0.0:
         return pe
-    cos, sin = pe[0], pe[1]
+    if not isinstance(pe, (list, tuple)) or len(pe) < 2:
+        raise TypeError(
+            f"unexpected LTX positional-embedding payload {type(pe).__name__} — "
+            f"cannot apply the identity source-phase tag")
+    head, second = pe[0], pe[1]
     rest = tuple(pe[2:])
-    L = cos.shape[-1]
-    d = torch.arange(L, device=cos.device, dtype=torch.float32)
-    rate = theta ** (-d / float(L))
-    phase = seg_value * rate
-    pc = phase.cos().to(cos.dtype)
-    ps = phase.sin().to(sin.dtype)
-    idx = [slice(None)] * cos.dim()
-    idx[-2] = slice(cos.shape[-2] - ref_len, cos.shape[-2])
+
+    if torch.is_tensor(second):
+        # Legacy cos/sin pair: (..., T, L) for both the split and interleaved rope types.
+        cos, sin = head, second
+        pc, ps = _segment_phase(cos.shape[-1], seg_value, theta, cos.device, cos.dtype)
+        idx = [slice(None)] * cos.dim()
+        idx[-2] = slice(cos.shape[-2] - ref_len, cos.shape[-2])
+        idx = tuple(idx)
+        c0, s0 = cos[idx], sin[idx]
+        cos = cos.clone()
+        sin = sin.clone()
+        cos[idx] = c0 * pc - s0 * ps
+        sin[idx] = s0 * pc + c0 * ps
+        return (cos, sin, *rest)
+
+    # Rotation-matrix form. The 2x2 block is [[c, -s], [s, c]], so c/s read off column 0.
+    mat = head
+    if not torch.is_tensor(mat) or mat.dim() < 4 or tuple(mat.shape[-2:]) != (2, 2):
+        raise TypeError(
+            f"unexpected LTX rope matrix shape {tuple(mat.shape) if torch.is_tensor(mat) else type(mat).__name__} — "
+            f"expected (B, T, heads, D, 2, 2); cannot apply the identity source-phase tag")
+    if mat.shape[1] < ref_len:
+        raise ValueError(
+            f"LTX rope matrix has {mat.shape[1]} tokens on axis 1, fewer than the "
+            f"{ref_len} reference tokens to tag")
+    pc, ps = _segment_phase(mat.shape[-3], seg_value, theta, mat.device, mat.dtype)
+    idx = [slice(None)] * mat.dim()
+    idx[1] = slice(mat.shape[1] - ref_len, mat.shape[1])  # tokens live on axis 1 here
     idx = tuple(idx)
-    c0, s0 = cos[idx], sin[idx]
-    cos = cos.clone()
-    sin = sin.clone()
-    cos[idx] = c0 * pc - s0 * ps
-    sin[idx] = s0 * pc + c0 * ps
-    return (cos, sin, *rest)
+    blk = mat[idx]
+    c0, s0 = blk[..., 0, 0], blk[..., 1, 0]
+    c1 = c0 * pc - s0 * ps
+    s1 = s0 * pc + c0 * ps
+    mat = mat.clone()
+    mat[idx] = torch.stack((c1, -s1, s1, c1), dim=-1).reshape(blk.shape)
+    return (mat, second, *rest)
diff --git a/samplers.py b/samplers.py
index 225db714..4858c19e 100644
--- a/samplers.py
+++ b/samplers.py
@@ -4369,6 +4369,19 @@ class FunPackLTXAVSceneChainSampler:
         orig_prepare_timestep = ltxv._prepare_timestep
         orig_prepare_pe = ltxv._prepare_positional_embeddings
         orig_process_output = ltxv._process_output
+        # These wrappers reach into LTXBaseModel internals, so a ComfyUI refactor can break
+        # one of them. Falling back silently is how a broken source-phase tag once passed as
+        # "Best-FaceID makes the clip open on the reference image" — report each failure once
+        # per install (not per step) so the cause is visible in the console immediately.
+        _warned: set = set()
+
+        def _warn_once(what, exc):
+            if what in _warned:
+                return
+            _warned.add(what)
+            print(f"[FunPackSceneChain] identity_transfer: {what} failed ({type(exc).__name__}: {exc}) "
+                  f"— identity conditioning is NOT being applied correctly this run. "
+                  f"This usually means a ComfyUI update changed the LTX model internals.")
 
         def process_input(self_ltxv, x, keyframe_idxs, denoise_mask, **kw):
             out = orig_process_input(x, keyframe_idxs, denoise_mask, **kw)
@@ -4397,7 +4410,8 @@ class FunPackLTXAVSceneChainSampler:
                 else:
                     xx, pix = vx, vco
                 return xx, pix, add
-            except Exception:
+            except Exception as e:
+                _warn_once("reference-token append (_process_input)", e)
                 self_ltxv._funpack_id_ref_len = 0
                 return out
 
@@ -4426,7 +4440,10 @@ class FunPackLTXAVSceneChainSampler:
                     v_pe = _rotate_overlap_freqs(v_pe, ref_len, seg_value)
                     return [(v_pe, cross_v), pe[1]]
                 return _rotate_overlap_freqs(pe, ref_len, seg_value)
-            except Exception:
+            except Exception as e:
+                # Untagged reference tokens share the target's frame-0 grid, so the model
+                # renders them AS frame 0 — the clip opens on the reference image.
+                _warn_once("source-phase RoPE tag (_prepare_positional_embeddings)", e)
                 return pe
 
         def process_output(self_ltxv, x, embedded_timestep, keyframe_idxs, **kw):
@@ -4453,8 +4470,8 @@ class FunPackLTXAVSceneChainSampler:
                         x = x[:, :x.shape[1] - ref_len]
                         if hasattr(embedded_timestep, "shape") and embedded_timestep.dim() >= 2 and embedded_timestep.shape[1] > 1:
                             embedded_timestep = embedded_timestep[:, : embedded_timestep.shape[1] - ref_len]
-                except Exception:
-                    pass
+                except Exception as e:
+                    _warn_once("reference-token trim (_process_output)", e)
             return orig_process_output(x, embedded_timestep, keyframe_idxs, **kw)
 
         ltxv._process_input = types.MethodType(process_input, ltxv)
diff --git a/tests/test_identity_transfer.py b/tests/test_identity_transfer.py
index bbdd1d84..b67f5a87 100644
--- a/tests/test_identity_transfer.py
+++ b/tests/test_identity_transfer.py
@@ -76,6 +76,64 @@ def test_rotate_overlap_freqs_rotates_only_last_ref_len_tokens():
     assert split is False
 
 
+def _rope_matrix(angles, heads):
+    """Build ComfyUI's post-7c59a07 layout from per-(B,T,H,D) angles: (B,T,H,D,2,2)
+    holding [[cos, -sin], [sin, cos]] — mirrors freqs_cis_matrix's own stack/reshape."""
+    c, s = angles.cos(), angles.sin()
+    return torch.stack((c, -s, s, c), dim=-1).reshape(*angles.shape, 2, 2)
+
+
+def test_rotate_overlap_freqs_matrix_layout_rotates_only_last_ref_len_tokens():
+    """ComfyUI 7c59a07 ("Use comfy kitchen rope functions in ltx models") replaced the
+    (cos, sin, split_mode) payload with (rotation_matrix, split_mode). The old code read
+    pe[1] as the sin tensor — it's a bool now — so the source-phase tag was silently
+    skipped and the reference tokens read as literal frame 0."""
+    B, T, H, D = 2, 10, 3, 4
+    ref_len = 3
+    angles = torch.linspace(0.0, 3.0, B * T * H * D).reshape(B, T, H, D)
+    mat = _rope_matrix(angles, H)
+    out_mat, split = idt.rotate_overlap_freqs((mat, True), ref_len, 2.0)
+    assert split is True
+    assert out_mat.shape == mat.shape
+    # Tokens before the reference block are untouched...
+    assert torch.equal(out_mat[:, : T - ref_len], mat[:, : T - ref_len])
+    # ...and the reference block actually moved.
+    assert not torch.equal(out_mat[:, T - ref_len :], mat[:, T - ref_len :])
+    # The 2x2 structure survives: still [[c, -s], [s, c]] with unit determinant.
+    c, s = out_mat[..., 0, 0], out_mat[..., 1, 0]
+    assert torch.allclose(out_mat[..., 0, 1], -s, atol=1e-6)
+    assert torch.allclose(out_mat[..., 1, 1], c, atol=1e-6)
+    assert torch.allclose(c**2 + s**2, torch.ones_like(c), atol=1e-5)
+
+
+def test_rotate_overlap_freqs_matrix_matches_legacy_cos_sin_rotation():
+    """Both layouts must apply the SAME phase, so upgrading ComfyUI doesn't change what
+    Best-FaceID conditioning the model sees."""
+    B, T, H, D = 1, 6, 2, 4
+    ref_len, seg = 2, 2.0
+    angles = torch.linspace(0.0, 2.0, B * T * H * D).reshape(B, T, H, D)
+    # Legacy split layout is (B, H, T, D): tokens on axis -2, frequencies on -1.
+    legacy = angles.transpose(1, 2)
+    l_cos, l_sin, _ = idt.rotate_overlap_freqs((legacy.cos(), legacy.sin(), True), ref_len, seg)
+    m_out, _ = idt.rotate_overlap_freqs((_rope_matrix(angles, H), True), ref_len, seg)
+    m_cos = m_out[..., 0, 0].transpose(1, 2)
+    m_sin = m_out[..., 1, 0].transpose(1, 2)
+    assert torch.allclose(m_cos, l_cos, atol=1e-6)
+    assert torch.allclose(m_sin, l_sin, atol=1e-6)
+
+
+def test_rotate_overlap_freqs_raises_on_unknown_payload():
+    """A future layout change must fail loudly, not skip the tag and quietly turn the
+    reference tokens into frame 0."""
+    import pytest
+    with pytest.raises(TypeError):
+        idt.rotate_overlap_freqs(("not-a-tensor", True), 2, 2.0)
+    with pytest.raises(TypeError):
+        idt.rotate_overlap_freqs((torch.zeros(2, 3, 4), True), 2, 2.0)  # no trailing (2, 2)
+    with pytest.raises(ValueError):
+        idt.rotate_overlap_freqs((_rope_matrix(torch.zeros(1, 2, 1, 4), 1), True), 5, 2.0)
+
+
 # ── identity_transfer.append_context_tokens ────────────────────────────────────
 
 def test_append_context_tokens_pads_and_extends_mask():
@@ -269,6 +327,25 @@ def test_prepare_pe_rotates_only_the_ref_token_tail():
     s._strip_identity_overlap(handle)
 
 
+def test_prepare_pe_rotates_matrix_layout_end_to_end():
+    """Regression guard for ComfyUI 7c59a07: with the rotation-matrix payload the wrapper
+    must still tag the ref tokens. It used to raise inside rotate_overlap_freqs and get
+    swallowed by prepare_pe's except, leaving the reference readable as frame 0."""
+    s = _sampler()
+    ltxv = _FakeLTXV()
+    B, T, H, D = 1, 10, 2, 4
+    angles = torch.linspace(0.0, 3.0, B * T * H * D).reshape(B, T, H, D)
+    matrix = _rope_matrix(angles, H)
+    ltxv._prepare_positional_embeddings = lambda pixel_coords, frame_rate, x_dtype: (matrix, True)
+    handle = s._install_identity_overlap(_fake_model(ltxv), _ref_latent(), 2.0)
+    ltxv._process_input(torch.zeros(1, 5, 8), None, None)  # ref_len=2
+    out_mat, split_mode = ltxv._prepare_positional_embeddings(None, 25, torch.float32)
+    assert split_mode is True
+    assert torch.equal(out_mat[:, : T - 2], matrix[:, : T - 2])   # target tokens untouched
+    assert not torch.equal(out_mat[:, T - 2 :], matrix[:, T - 2 :])  # ref tokens tagged
+    s._strip_identity_overlap(handle)
+
+
 def test_prepare_pe_noop_when_ref_len_zero():
     s = _sampler()
     ltxv = _FakeLTXV()

From e01af7244542e4e61041b0446eff652c4a467cff Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Wed, 29 Jul 2026 21:49:31 +0300
Subject: [PATCH 06/29] Context windows on the Chain Sampler + fix upsampler
 load on ComfyUI v0.29.0

Two things, both driven by upstream ComfyUI moving 7 weeks ahead of the
local checkout (2cdaaf4a 2026-06-06 -> e651b7be 2026-07-28, 263 commits).

1. Segmented detailing crashed on ComfyUI v0.29.0. Upstream f8a3fd9d moved
   the LTX latent upsampler onto DynamicVram and made `operations` a required
   argument of LatentUpsampler.from_config; detailing.py still called it with
   one arg, so the pending live probe would have died before detecting
   anything. Now passes comfy.ops.disable_weight_init (what core's own loader
   does) with a TypeError fallback, since rentals run whatever they pulled.

2. New Chain Sampler option: context_windows. Upstream cd77c551 (CORE-3)
   added context-window sampling with real LTX2/LTXAV support - it unpacks
   the packed AV latent, maps each video window onto its proportional audio
   window, and re-slices denoise masks, keyframe_idxs and
   guide_attention_entries per window, so anchors, mid-scene guides and JoyAI
   memory survive inside a window. Nothing is ported: we build core's handler
   and hang it on the scene's model_options exactly as the stock
   LTXVContextWindows node does. Core picks it up in
   comfy.samplers.calc_cond_batch, which every FunPack sampler already routes
   through, so no sampler-loop change was needed and no graph change either -
   it rides the sampler_inputs bridge into both Editor and Easy Gen.

   Refuses (loudly, once per run, with a scene-report note) on cores without
   BaseModel.map_context_window_to_modalities: the handler class predates
   LTXAV support and would window the packed tensor blindly, which is the
   same packed-vs-unpacked trap that killed DynamicConditioning. Install and
   removal are per-scene under the existing wrapper-hygiene finally, so an
   interrupt cannot leak the handler or its two patcher wrappers into later
   runs.

   Knobs (all exposed, none hardcoded): length, overlap, schedule, blend,
   FreeNoise, and pin-anchor-in-every-window. Off by default. Engages only
   on scenes longer than the window, and says so in the scene report when it
   does not, so a scene that sampled whole never reads as a broken feature.

Verified: 8 new unit tests for the install/remove/capability-gate contract;
full suite at baseline (22 pre-existing cross-module stub failures, no new).
Editor checked live - knobs render in Engine > Chain Sampler > Experimental,
dependents gate on the toggle, and values persist into sampler_inputs.

UNVALIDATED LIVE on a rental.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 detailing.py                             |  11 +-
 movie_editor/frontend/engine_settings.js |  16 ++-
 samplers.py                              | 169 +++++++++++++++++++++-
 tests/test_context_windows.py            | 174 +++++++++++++++++++++++
 4 files changed, 367 insertions(+), 3 deletions(-)
 create mode 100644 tests/test_context_windows.py

diff --git a/detailing.py b/detailing.py
index fe01765a..ed075251 100644
--- a/detailing.py
+++ b/detailing.py
@@ -169,7 +169,16 @@ def load_latent_upsampler(model_name):
         raise ValueError(
             f"{model_name} is not an LTX latent upsampler (expected post_upsample_res_blocks keys).")
     config = json.loads(metadata["config"])
-    model = LatentUpsampler.from_config(config).to(
+    # ComfyUI v0.29.0 (upstream f8a3fd9d) moved the upsampler onto DynamicVram and made
+    # `operations` a required argument of from_config; older cores build nn.Modules
+    # directly and reject the kwarg. Rentals run whatever they pulled, so accept both.
+    try:
+        import comfy.ops
+
+        model = LatentUpsampler.from_config(config, operations=comfy.ops.disable_weight_init)
+    except TypeError:
+        model = LatentUpsampler.from_config(config)
+    model = model.to(
         dtype=comfy.model_management.vae_dtype(allowed_dtypes=[torch.bfloat16, torch.float32]))
     model.load_state_dict(sd)
     model.eval()
diff --git a/movie_editor/frontend/engine_settings.js b/movie_editor/frontend/engine_settings.js
index f0543596..d6ae69bc 100644
--- a/movie_editor/frontend/engine_settings.js
+++ b/movie_editor/frontend/engine_settings.js
@@ -226,6 +226,20 @@
     { name: "detail_denoise", label: "Detail re-noise strength", kind: "float", default: 0.85, min: 0.3, max: 0.99, step: 0.05,
       deps: [{ name: "segmented_detailing" }, { name: "detail_mode", value: "repair" }],
       hint: "How much noise the crop gets re-noised to before its 3-step refine (0.85 is the official LTX 2.3 recipe's own value). Higher = more freedom to genuinely reconstruct the region (fix bad anatomy), risking drift from the surrounding frame; lower = closer to a plain upscale — looks 'detailed' as interpolation but doesn't actually repair it. If the result looks upscaled but not corrected, raise this. Only used in 'repair' mode." },
+    { name: "context_windows", label: "Context windows (long scenes)", kind: "bool", default: false,
+      hint: "EXPERIMENTAL: denoise a scene that's LONGER than the model's comfortable window as overlapping windows instead of one giant pass — ComfyUI core's own mechanism, audio-aware on LTX (it maps each video window to its audio window and re-slices anchors, guides and JoyAI memory per window). Engages only on scenes longer than the window length below; shorter scenes are untouched and pay nothing. Cost isn't a flat multiple — the total work is about the same, plus the overlap being computed twice (~28% at the defaults). Needs ComfyUI v0.29.0 or newer; on older builds it's skipped with a note in the scene report. UNVALIDATED LIVE." },
+    { name: "context_window_length", label: "Window length (frames)", kind: "int", default: 145, min: 9, max: 2049, step: 8, dependsOn: "context_windows",
+      hint: "Window size in real frames. A scene at or below this length skips windowing entirely, so this doubles as the engage threshold. Keep it at or under the length the model already generates well in one pass — the point is to stay inside that range while the scene as a whole goes past it." },
+    { name: "context_window_overlap", label: "Window overlap (frames)", kind: "int", default: 40, min: 0, max: 512, step: 8, dependsOn: "context_windows",
+      hint: "How many frames consecutive windows share. This is the only thing carrying motion and appearance across a window boundary, and also the only extra compute this costs. Too low shows as a seam or a motion hitch at the boundary; too high pays for frames you already have." },
+    { name: "context_window_schedule", label: "Window schedule", kind: "combo", choices: ["uniform_standard", "static_standard", "uniform_looped", "batched"], default: "uniform_standard", dependsOn: "context_windows",
+      hint: "How windows are laid out each step. 'uniform_standard' (default) shifts the grid between steps so boundaries never bake in — safest. 'static_standard' keeps fixed cut points (cheapest, but a bad boundary stays bad). 'uniform_looped' wraps the end into the start for looping content. 'batched' uses disjoint chunks with no overlap logic (fastest, weakest continuity)." },
+    { name: "context_window_fuse", label: "Window blend", kind: "combo", choices: ["pyramid", "relative", "flat", "overlap-linear"], default: "pyramid", dependsOn: "context_windows",
+      hint: "How overlapping windows are weighted when merged. 'pyramid' (default) fades each window toward its edges so seams go soft. 'flat' averages equally (can smear). Change this if boundaries look ghosted rather than merely misaligned." },
+    { name: "context_window_freenoise", label: "FreeNoise blending", kind: "bool", default: true, dependsOn: "context_windows",
+      hint: "Shuffle rather than redraw the starting noise between windows, so overlapping regions begin from correlated noise. Free (a one-time permutation) and core's own default because it measurably improves how windows blend. Turn off only to A/B whether it's helping." },
+    { name: "context_window_retain_first", label: "Pin anchor in every window", kind: "bool", default: false, dependsOn: "context_windows",
+      hint: "Keep latent frame 0 (the i2v anchor) inside every window instead of just the first. Turn on if later windows drift away from the reference image. Off by default because on a continuation scene frame 0 is the carried tail of the previous scene, not the anchor — pinning it everywhere can make the scene read as static. Turn it off again if motion stalls." },
   ];
   const SAMPLER_KNOB_MAP = Object.fromEntries(SAMPLER_KNOBS.map((k) => [k.name, k]));
 
@@ -351,7 +365,7 @@
     chain_timing: ["frame_overlap", "transition_duration", "use_same_seed"],
     chain_guidance: ["cfg", "embed_guidance", "embed_guidance_source", "embed_guidance_strength", "score_slider", "score_slider_strength", "taste_nearest_prompt", "output_guidance", "output_guidance_strength", "dynashift", "dynashift_strength", "dynashift_threshold"],
     chain_decode: ["decode_noise_scale", "decode_timestep", "decode_tile_size"],
-    chain_experimental: ["plateau_cache", "plateau_cache_threshold", "segmented_detailing", "detail_targets", "detail_strength", "detail_threshold", "detail_max_area", "detail_mode", "detail_denoise", "mid_scene_guide", "mid_scene_guide_strength", "joyai_memory", "joyai_memory_size", "joyai_fix_frames", "joyai_frame_select", "joyai_memory_strength", "joyai_audio_memory", "v2a_grad_scale", "alg_blur_guides", "alg_guide_blur_strength", "alg_guide_blur_sigma_threshold", "bounded_attention_enabled", "identity_transfer_enabled", "source_id", "phase_scale", "id_strength", "arcface_mode", "debug_log"],
+    chain_experimental: ["context_windows", "context_window_length", "context_window_overlap", "context_window_schedule", "context_window_fuse", "context_window_freenoise", "context_window_retain_first", "plateau_cache", "plateau_cache_threshold", "segmented_detailing", "detail_targets", "detail_strength", "detail_threshold", "detail_max_area", "detail_mode", "detail_denoise", "mid_scene_guide", "mid_scene_guide_strength", "joyai_memory", "joyai_memory_size", "joyai_fix_frames", "joyai_frame_select", "joyai_memory_strength", "joyai_audio_memory", "v2a_grad_scale", "alg_blur_guides", "alg_guide_blur_strength", "alg_guide_blur_sigma_threshold", "bounded_attention_enabled", "identity_transfer_enabled", "source_id", "phase_scale", "id_strength", "arcface_mode", "debug_log"],
   };
 
   function countChainView(p, id) {
diff --git a/samplers.py b/samplers.py
index 4858c19e..351a1c91 100644
--- a/samplers.py
+++ b/samplers.py
@@ -2482,6 +2482,34 @@ class FunPackLTXAVSceneChainSampler:
                     "default": "repair",
                     "tooltip": "'repair' (default): upsample the crop, then re-denoise it through the video model for 3 extra steps — can genuinely fix wrong structure (bad anatomy) but costs real compute (~4x region area x 3 steps). 'sharpen': stop after the upsampler's own forward pass — no video-model calls at all, close to free — good for a region that's blurry/under-resolved but already correctly shaped; it CANNOT fix wrong structure (an extra finger stays an extra finger, just sharper), since a super-resolution net only adds detail consistent with what's already there.",
                 }),
+                "context_windows": ("BOOLEAN", {
+                    "default": False,
+                    "tooltip": "EXPERIMENTAL: denoise a scene LONGER than the model's native window as overlapping context windows instead of one giant pass (ComfyUI core's own comfy.context_windows, LTX2 branch — nothing ported). Each step splits the scene into windows of context_window_length frames, denoises each, and fuses the overlaps back together. Core's LTXAV path is genuinely audio-aware: it unpacks the packed AV latent, maps each video window onto its proportional AUDIO window, and re-slices denoise masks, keyframe_idxs and guide_attention_entries per window — so i2v anchors, mid-scene guides and JoyAI memory keep working inside a window. Cost is NOT a flat multiple: total tokens stay roughly the same and windowed attention is cheaper than full-length attention, but the overlap is recomputed (overlap/length extra work, ~28% at the defaults). Engages ONLY when the scene is longer than context_window_length — shorter scenes are untouched and pay nothing. Off by default. UNVALIDATED LIVE.",
+                }),
+                "context_window_length": ("INT", {
+                    "default": 145, "min": 9, "max": 2049, "step": 8,
+                    "tooltip": "Window size in REAL frames (must be 8n+1; core rounds down to latent frames). A scene at or below this length skips windowing entirely, so this doubles as the engage threshold. Keep it at or under the length the model actually generates well in one pass — the whole point is to stay inside that range while the scene as a whole goes past it.",
+                }),
+                "context_window_overlap": ("INT", {
+                    "default": 40, "min": 0, "max": 512, "step": 8,
+                    "tooltip": "How many real frames consecutive windows share. This is the ONLY thing carrying motion/appearance continuity across a window boundary, and it is also the only extra compute this feature costs (overlap/length = the redundant fraction). Too low and boundaries show as a seam or a motion hitch; too high and you pay for frames you already have.",
+                }),
+                "context_window_schedule": (["uniform_standard", "static_standard", "uniform_looped", "batched"], {
+                    "default": "uniform_standard",
+                    "tooltip": "How the windows are laid out across the scene, per step. 'uniform_standard' (default, core's own LTXV default) shifts the window grid between steps so boundaries land in different places each step and never bake in — the safest general choice. 'static_standard' keeps the same fixed cut points every step (cheapest, but a bad boundary stays bad). 'uniform_looped' wraps the last window into the first, for seamless looping content. 'batched' denoises disjoint chunks with no overlap logic (fastest, weakest continuity).",
+                }),
+                "context_window_fuse": (["pyramid", "relative", "flat", "overlap-linear"], {
+                    "default": "pyramid",
+                    "tooltip": "Weighting used to blend overlapping windows back together. 'pyramid' (default) fades each window toward its edges, so the middle of a window dominates and seams get soft. 'flat' averages equally (can smear). 'relative' and 'overlap-linear' weight by position within the overlap. Change this if boundaries look soft/ghosted rather than merely misaligned.",
+                }),
+                "context_window_freenoise": ("BOOLEAN", {
+                    "default": True,
+                    "tooltip": "Shuffle (rather than redraw) the initial noise between windows so overlapping regions start from correlated noise. Costs nothing — it is a one-time permutation of the starting noise — and is core's default for LTXV because it measurably improves how well windows blend. Turn it off only to A/B whether it is helping.",
+                }),
+                "context_window_retain_first": ("BOOLEAN", {
+                    "default": False,
+                    "tooltip": "Pin latent frame 0 (the i2v anchor) into EVERY window, in both the conditioning and the noise latent, instead of only the first window. Helps when later windows drift away from the reference image. Off by default because on a CONTINUATION scene frame 0 is the carried tail of the previous scene, not the anchor — pinning it there re-shows the same content in every window and can read as the scene going static. Turn it on if later windows lose the reference; turn it off if the scene stops moving.",
+                }),
             },
             "hidden": {
                 "unique_id": "UNIQUE_ID",
@@ -2537,6 +2565,18 @@ class FunPackLTXAVSceneChainSampler:
             raise ValueError("Scene chain latents must have a time dimension at index 2.")
         return int(tensor.shape[2])
 
+    def _context_scene_latent_frames(self, chunk):
+        """Video latent frames in this scene's chunk, or None if it can't be read.
+
+        Reported only — core decides for itself whether a scene is long enough to window.
+        Read off the VIDEO tensor (index 0 of the nested AV latent), while the chunk is
+        still unpacked 5D; after comfy packs it the time axis is gone.
+        """
+        try:
+            return self._tensor_frames(self._latent_tensors(chunk)[0])
+        except Exception:
+            return None
+
     def _latent_tensors(self, latent):
         samples = latent.get("samples")
         if self._is_nested(samples):
@@ -4285,6 +4325,79 @@ class FunPackLTXAVSceneChainSampler:
             except Exception:
                 pass
 
+    # Wrapper keys used by context windows; core registers them under these names.
+    _CTX_WRAPPER_KEYS = ("ContextWindows_prepare_sampling", "ContextWindows_sampler_sample")
+
+    def _install_context_windows(self, model, length, overlap, schedule, fuse,
+                                 freenoise, retain_first):
+        """Hand this scene's denoise to ComfyUI core's context-window sampler.
+
+        Nothing is ported: core owns the whole mechanism (comfy.context_windows), we only
+        build its handler and hang it on this scene's model_options, the same way the stock
+        LTXVContextWindows node does. Core picks it up inside comfy.samplers.calc_cond_batch,
+        which every FunPack sampler already goes through (they all call model(x, sigma, ...)
+        on the CFGGuider rather than apply_model directly), so no sampler change is needed.
+
+        Returns (remove_fn, latent_len) or None when the running ComfyUI core predates LTXAV
+        window support. That capability gate is the important part: the handler class itself
+        has existed for a long time for unpacked video, but the packed AV latent needs
+        BaseModel.map_context_window_to_modalities (+ resize_cond_for_context_window) to
+        unpack the AV stream, map each video window onto its audio window and re-slice
+        keyframe_idxs / guide_attention_entries. Without those, enabling this on LTXAV would
+        window the packed tensor blindly and quietly wreck audio and guides — the same class
+        of packed-vs-unpacked mistake that killed DynamicConditioning. Refuse instead.
+        """
+        try:
+            import comfy.context_windows as _cw
+            import comfy.patcher_extension as _pe
+        except ImportError:
+            return None
+        base = getattr(model, "model", None)
+        if not hasattr(base, "map_context_window_to_modalities"):
+            return None
+        # Real frames -> latent frames, exactly as core's LTXVContextWindows node does it.
+        latent_len = max(((int(length) - 1) // 8) + 1, 1)
+        latent_overlap = max(int(overlap) // 8, 0)
+        retain = "0" if retain_first else ""
+        try:
+            handler = _cw.IndexListContextHandler(
+                context_schedule=_cw.get_matching_context_schedule(schedule),
+                fuse_method=_cw.get_matching_fuse_method(fuse),
+                context_length=latent_len,
+                context_overlap=latent_overlap,
+                context_stride=1,
+                closed_loop=False,
+                dim=2,
+                freenoise=bool(freenoise),
+                cond_retain_index_list=retain,
+                latent_retain_index_list=retain,
+                split_conds_to_windows=False,
+            )
+        except TypeError:
+            return None  # signature drifted from the one this was written against
+        prev = model.model_options.get("context_handler")
+        had_prev = "context_handler" in model.model_options
+        model.model_options["context_handler"] = handler
+        _cw.create_prepare_sampling_wrapper(model)
+        if freenoise:
+            _cw.create_sampler_sample_wrapper(model)
+
+        def _remove():
+            if had_prev:
+                model.model_options["context_handler"] = prev
+            else:
+                model.model_options.pop("context_handler", None)
+            for wrapper_type, key in (
+                (_pe.WrappersMP.PREPARE_SAMPLING, self._CTX_WRAPPER_KEYS[0]),
+                (_pe.WrappersMP.SAMPLER_SAMPLE, self._CTX_WRAPPER_KEYS[1]),
+            ):
+                try:
+                    model.remove_wrappers_with_key(wrapper_type, key)
+                except Exception:
+                    pass
+
+        return _remove, latent_len
+
     def _build_plateau_cache_wrapper(self, model, threshold):
         """Plateau step-cache (MixCache/Chorus-family, adapted to LTX2.3's distilled schedule).
 
@@ -4700,6 +4813,9 @@ class FunPackLTXAVSceneChainSampler:
                segmented_detailing=False, detail_targets="hands",
                detail_upsampler="None", detail_strength=1.0, detail_threshold=0.35,
                detail_max_area=0.35, detail_denoise=0.85, detail_mode="repair",
+               context_windows=False, context_window_length=145, context_window_overlap=40,
+               context_window_schedule="uniform_standard", context_window_fuse="pyramid",
+               context_window_freenoise=True, context_window_retain_first=False,
                unique_id=None, prompt=None):
         if not isinstance(positive, list) or not positive:
             raise ValueError("positive conditioning must contain at least one scene entry.")
@@ -4758,6 +4874,12 @@ class FunPackLTXAVSceneChainSampler:
                 dynashift=dynashift, dynashift_strength=dynashift_strength,
                 dynashift_threshold=dynashift_threshold,
                 plateau_cache=plateau_cache, plateau_cache_threshold=plateau_cache_threshold,
+                context_windows=context_windows, context_window_length=context_window_length,
+                context_window_overlap=context_window_overlap,
+                context_window_schedule=context_window_schedule,
+                context_window_fuse=context_window_fuse,
+                context_window_freenoise=context_window_freenoise,
+                context_window_retain_first=context_window_retain_first,
             )
 
         max_scene_count = max(1, int(max_scenes))
@@ -4890,6 +5012,7 @@ class FunPackLTXAVSceneChainSampler:
         _identity_overlap_state: dict = {}
         _detail_upsampler_model = None  # lazy: resolved+loaded at the first detailed scene
         _detail_disabled_reason = None  # set on resolve/load failure: don't retry per scene
+        _ctx_unsupported_reported = False  # print the "core too old" line once, not per scene
 
         for scene_index, scene_cond in enumerate(scene_conditionings):
             scene_positive = [scene_cond]
@@ -5009,7 +5132,39 @@ class FunPackLTXAVSceneChainSampler:
             _v2a_handles = []
             _identity_overlap_handle = None
             _plateau_stats = None
+            _ctx_remove = None
             try:
+                # Context windows: core-owned, installed first so every FunPack wrapper below
+                # sits inside the per-window forward rather than around the whole clip.
+                if context_windows:
+                    _ctx = self._install_context_windows(
+                        model, context_window_length, context_window_overlap,
+                        context_window_schedule, context_window_fuse,
+                        context_window_freenoise, context_window_retain_first)
+                    if _ctx is None:
+                        if not _ctx_unsupported_reported:
+                            print("[FunPackSceneChain] context_windows requested but this ComfyUI "
+                                  "build has no LTXAV context-window support (needs the CORE-3 "
+                                  "context-windows change, ComfyUI >= v0.29.0) — skipped.")
+                            _ctx_unsupported_reported = True
+                        run_mechanisms.append("context_windows(SKIPPED: ComfyUI core too old)")
+                    else:
+                        _ctx_remove, _ctx_latent_len = _ctx
+                        # Core engages windowing only when the scene is longer than the window,
+                        # and logs that decision itself; say so here too so a scene that silently
+                        # sampled whole doesn't read as the feature being broken.
+                        _scene_latent_len = self._context_scene_latent_frames(chunk)
+                        if _scene_latent_len is not None and _scene_latent_len <= _ctx_latent_len:
+                            run_mechanisms.append(
+                                f"context_windows(inactive: scene {_scene_latent_len} <= window "
+                                f"{_ctx_latent_len} latent frames — raise num_frames_per_scene or "
+                                f"lower context_window_length)")
+                        else:
+                            run_mechanisms.append(
+                                f"context_windows({context_window_schedule},{context_window_fuse},"
+                                f"len={_ctx_latent_len},ovl={max(int(context_window_overlap) // 8, 0)}"
+                                f"{',freenoise' if context_window_freenoise else ''}"
+                                f"{',retain_first' if context_window_retain_first else ''})")
                 # Innermost wrapper (installed first): caches the raw base-model forward on the
                 # near-noise plateau so later plateau steps reuse it. All guidance wrappers below
                 # layer around it and still post-process each step's (cached-or-fresh) prediction.
@@ -5135,6 +5290,8 @@ class FunPackLTXAVSceneChainSampler:
                         run_mechanisms.append(
                             f"plateau_cache(skipped {_reused}/{_total} plateau fwd, thr={plateau_cache_threshold})")
             finally:
+                if _ctx_remove is not None:
+                    _ctx_remove()
                 self._remove_v2a_scale(_v2a_handles)
                 self._strip_identity_overlap(_identity_overlap_handle)
                 if model.model_options.get("model_function_wrapper") is not _scene_base_wrapper:
@@ -5456,7 +5613,11 @@ class FunPackLTXAVSceneChainSampler:
                             output_guidance=False, output_guidance_strength=0.02,
                             dynashift=False, dynashift_strength=0.3, dynashift_threshold=0.6,
                             alg_guide_blur_strength=2.0, alg_guide_blur_sigma_threshold=0.975,
-                            plateau_cache=False, plateau_cache_threshold=0.975):
+                            plateau_cache=False, plateau_cache_threshold=0.975,
+                            context_windows=False, context_window_length=145,
+                            context_window_overlap=40, context_window_schedule="uniform_standard",
+                            context_window_fuse="pyramid", context_window_freenoise=True,
+                            context_window_retain_first=False):
         """Sample one chain per Studio-packed variant entry (seed + index), persisting each result
         (latent + preview + per-entry cond + manifest) under ComfyUI temp for rating in Studio.
         Reuses sample() per entry with only the seed changed, so each entry is a clean generation."""
@@ -5510,6 +5671,12 @@ class FunPackLTXAVSceneChainSampler:
                 dynashift=dynashift, dynashift_strength=dynashift_strength,
                 dynashift_threshold=dynashift_threshold,
                 plateau_cache=plateau_cache, plateau_cache_threshold=plateau_cache_threshold,
+                context_windows=context_windows, context_window_length=context_window_length,
+                context_window_overlap=context_window_overlap,
+                context_window_schedule=context_window_schedule,
+                context_window_fuse=context_window_fuse,
+                context_window_freenoise=context_window_freenoise,
+                context_window_retain_first=context_window_retain_first,
                 unique_id=None, prompt=None,
             )
             last = out
diff --git a/tests/test_context_windows.py b/tests/test_context_windows.py
new file mode 100644
index 00000000..d979dffb
--- /dev/null
+++ b/tests/test_context_windows.py
@@ -0,0 +1,174 @@
+"""Context-window install/remove contract on the Scene Chain sampler.
+
+The mechanism itself is ComfyUI core's (comfy.context_windows) — nothing here tests
+core's windowing math. What IS ours, and what these cover:
+
+1. The capability gate. Core's handler class predates LTXAV support; only builds that
+   also have BaseModel.map_context_window_to_modalities can unpack the packed AV latent
+   and re-slice guides/audio per window. On an older core we must REFUSE, not window a
+   packed tensor blindly (the DynamicConditioning failure mode).
+2. Real-frame -> latent-frame conversion matches core's own LTXVContextWindows node.
+3. Install/remove leaves the shared model exactly as found, including on an interrupt
+   mid-scene — the same guarantee _strip_funpack_scene_wrappers gives the function
+   wrappers, but for patcher wrappers and the context_handler model_option.
+"""
+import sys
+import types
+from pathlib import Path
+
+import torch
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+for _name in (
+    "comfy", "comfy.k_diffusion", "comfy.k_diffusion.sampling",
+    "comfy.model_sampling", "comfy.nested_tensor", "comfy.sample",
+    "comfy.samplers", "comfy.utils",
+):
+    sys.modules.setdefault(_name, types.ModuleType(_name))
+sys.modules["comfy.nested_tensor"].NestedTensor = object
+
+import samplers  # noqa: E402
+
+
+class _Handler:
+    def __init__(self, **kwargs):
+        self.kwargs = kwargs
+
+
+def _install_fake_core(monkeypatch, ltxav_support=True, accept_latent_retain=True):
+    """Stand in for comfy.context_windows + comfy.patcher_extension.
+
+    Records what the sampler asks core to do, so the test asserts on the request
+    rather than on core's behaviour.
+    """
+    calls = {"prepare": 0, "sampler_sample": 0, "removed": []}
+
+    cw = types.ModuleType("comfy.context_windows")
+
+    def _handler(**kwargs):
+        if not accept_latent_retain and "latent_retain_index_list" in kwargs:
+            raise TypeError("unexpected keyword argument 'latent_retain_index_list'")
+        return _Handler(**kwargs)
+
+    cw.IndexListContextHandler = _handler
+    cw.get_matching_context_schedule = lambda s: f"sched:{s}"
+    cw.get_matching_fuse_method = lambda f: f"fuse:{f}"
+
+    def _prep(model):
+        calls["prepare"] += 1
+
+    def _samp(model):
+        calls["sampler_sample"] += 1
+
+    cw.create_prepare_sampling_wrapper = _prep
+    cw.create_sampler_sample_wrapper = _samp
+
+    pe = types.ModuleType("comfy.patcher_extension")
+    pe.WrappersMP = types.SimpleNamespace(
+        PREPARE_SAMPLING="prepare_sampling", SAMPLER_SAMPLE="sampler_sample")
+
+    monkeypatch.setitem(sys.modules, "comfy.context_windows", cw)
+    monkeypatch.setitem(sys.modules, "comfy.patcher_extension", pe)
+
+    inner = types.SimpleNamespace()
+    if ltxav_support:
+        inner.map_context_window_to_modalities = lambda *a, **k: None
+
+    model = types.SimpleNamespace(
+        model_options={},
+        model=inner,
+        remove_wrappers_with_key=lambda t, k: calls["removed"].append((t, k)),
+    )
+    return model, calls
+
+
+def _install(sampler, model, **overrides):
+    kwargs = dict(length=145, overlap=40, schedule="uniform_standard",
+                  fuse="pyramid", freenoise=True, retain_first=False)
+    kwargs.update(overrides)
+    return sampler._install_context_windows(model, **kwargs)
+
+
+def test_refuses_on_core_without_ltxav_window_support(monkeypatch):
+    model, calls = _install_fake_core(monkeypatch, ltxav_support=False)
+    s = samplers.FunPackLTXAVSceneChainSampler()
+    assert _install(s, model) is None
+    # Nothing installed: a refusal must not half-configure the shared model.
+    assert "context_handler" not in model.model_options
+    assert calls["prepare"] == 0 and calls["sampler_sample"] == 0
+
+
+def test_refuses_when_handler_signature_drifted(monkeypatch):
+    model, calls = _install_fake_core(monkeypatch, accept_latent_retain=False)
+    s = samplers.FunPackLTXAVSceneChainSampler()
+    assert _install(s, model) is None
+    assert "context_handler" not in model.model_options
+
+
+def test_real_frames_convert_to_latent_frames_like_core_node(monkeypatch):
+    model, _ = _install_fake_core(monkeypatch)
+    s = samplers.FunPackLTXAVSceneChainSampler()
+    remove, latent_len = _install(s, model, length=145, overlap=40)
+    # Core's LTXVContextWindows: ((145 - 1) // 8) + 1 = 19, 40 // 8 = 5.
+    assert latent_len == 19
+    handler = model.model_options["context_handler"]
+    assert handler.kwargs["context_length"] == 19
+    assert handler.kwargs["context_overlap"] == 5
+    assert handler.kwargs["dim"] == 2
+    remove()
+
+
+def test_retain_first_sets_both_cond_and_latent_retain(monkeypatch):
+    model, _ = _install_fake_core(monkeypatch)
+    s = samplers.FunPackLTXAVSceneChainSampler()
+    remove, _ = _install(s, model, retain_first=True)
+    handler = model.model_options["context_handler"]
+    # i2v anchors live in the noise latent, not only in conditioning channels, so both
+    # lists must be set — cond alone would drop the anchor from later windows.
+    assert handler.kwargs["cond_retain_index_list"] == "0"
+    assert handler.kwargs["latent_retain_index_list"] == "0"
+    remove()
+
+
+def test_freenoise_off_skips_the_sampler_sample_wrapper(monkeypatch):
+    model, calls = _install_fake_core(monkeypatch)
+    s = samplers.FunPackLTXAVSceneChainSampler()
+    remove, _ = _install(s, model, freenoise=False)
+    assert calls["prepare"] == 1
+    assert calls["sampler_sample"] == 0
+    remove()
+
+
+def test_remove_restores_model_options_and_drops_both_wrappers(monkeypatch):
+    model, calls = _install_fake_core(monkeypatch)
+    s = samplers.FunPackLTXAVSceneChainSampler()
+    remove, _ = _install(s, model)
+    assert "context_handler" in model.model_options
+    remove()
+    assert "context_handler" not in model.model_options
+    assert calls["removed"] == [
+        ("prepare_sampling", "ContextWindows_prepare_sampling"),
+        ("sampler_sample", "ContextWindows_sampler_sample"),
+    ]
+
+
+def test_remove_restores_a_pre_existing_foreign_handler(monkeypatch):
+    """A user-placed LTXVContextWindows node upstream must survive our scene."""
+    model, _ = _install_fake_core(monkeypatch)
+    foreign = object()
+    model.model_options["context_handler"] = foreign
+    s = samplers.FunPackLTXAVSceneChainSampler()
+    remove, _ = _install(s, model)
+    assert model.model_options["context_handler"] is not foreign
+    remove()
+    assert model.model_options["context_handler"] is foreign
+
+
+def test_scene_latent_frame_count_reads_the_video_stream():
+    s = samplers.FunPackLTXAVSceneChainSampler()
+    chunk = {"samples": torch.zeros(1, 128, 23, 8, 8)}
+    assert s._context_scene_latent_frames(chunk) == 23
+    # Unreadable latent reports None rather than raising: this value is only ever used
+    # for the scene report, never for control flow.
+    assert s._context_scene_latent_frames({"samples": None}) is None

From e490530d1670758e019e2d701f9110544c4efe5b Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Wed, 29 Jul 2026 21:53:07 +0300
Subject: [PATCH 07/29] Chain Sampler: plateau_cache and context_windows are
 mutually exclusive

The plateau step-cache is keyed by (input.shape, cond_or_uncond), and every
context window inside one step calls the model with the SAME shape. With both
toggles on, windows 2..N would have been handed window 1's cached prediction
on every plateau step - one window's content bleeding across the whole clip,
silently, on a combination that is two ticked checkboxes away.

Context windows now wins and the cache is skipped, with the reason in the
scene report and in both tooltips, rather than quietly honouring one of two
requested settings. Caught by reasoning through the interaction, not by a
live run - neither feature has been validated on a rental yet.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 movie_editor/frontend/engine_settings.js |  2 +-
 samplers.py                              | 15 +++++++++++++--
 2 files changed, 14 insertions(+), 3 deletions(-)

diff --git a/movie_editor/frontend/engine_settings.js b/movie_editor/frontend/engine_settings.js
index d6ae69bc..470dd944 100644
--- a/movie_editor/frontend/engine_settings.js
+++ b/movie_editor/frontend/engine_settings.js
@@ -208,7 +208,7 @@
     { name: "debug_log", label: "Debug log", kind: "bool", default: false, dependsOn: "identity_transfer_enabled",
       hint: "Print per-scene identity-transfer shape/status logs to the ComfyUI console." },
     { name: "plateau_cache", label: "Plateau step-cache (speed)", kind: "bool", default: false,
-      hint: "EXPERIMENTAL speed: the near-pure-noise early steps carry almost no signal, so the transformer output barely changes across them. Computes it once at the top of the plateau and reuses it for the rest, skipping ~3-4 of 8 transformer passes. Deterministic given seed (safe in Batch Training) but an approximation — A/B it before trusting on finals. Much of wall-clock time is outside the sampler, so total speedup is smaller than the forward count suggests. UNVALIDATED LIVE." },
+      hint: "Ignored while Context windows is on — the cache can't tell one window from another within a step, so it's skipped with a note in the scene report. EXPERIMENTAL speed: the near-pure-noise early steps carry almost no signal, so the transformer output barely changes across them. Computes it once at the top of the plateau and reuses it for the rest, skipping ~3-4 of 8 transformer passes. Deterministic given seed (safe in Batch Training) but an approximation — A/B it before trusting on finals. Much of wall-clock time is outside the sampler, so total speedup is smaller than the forward count suggests. UNVALIDATED LIVE." },
     { name: "plateau_cache_threshold", label: "Plateau threshold (sigma)", kind: "float", default: 0.975, min: 0.5, max: 0.999, step: 0.005, dependsOn: "plateau_cache",
       hint: "Steps with sigma at or above this count as the reusable plateau. Higher = fewer steps cached (safer); lower = more cached (faster, more approximation). 0.975 catches the documented noise plateau while leaving structure formation fully computed." },
     { name: "segmented_detailing", label: "Segmented detailing (region refine)", kind: "bool", default: false,
diff --git a/samplers.py b/samplers.py
index 351a1c91..07dd81b1 100644
--- a/samplers.py
+++ b/samplers.py
@@ -2440,7 +2440,7 @@ class FunPackLTXAVSceneChainSampler:
                 }),
                 "plateau_cache": ("BOOLEAN", {
                     "default": False,
-                    "tooltip": "EXPERIMENTAL speed (MixCache/Chorus-family step-caching, adapted to LTX2.3's distilled schedule): the near-pure-noise plateau steps (sigma above plateau_cache_threshold) carry almost no signal, so the model's output barely changes across them. This computes the full transformer forward once at the top of the plateau, then REUSES that output for the remaining plateau steps instead of recomputing — skipping those transformer passes entirely. On the default 8-step schedule (sigmas 1.0→0.975 are the plateau) that's ~3-4 of 8 forwards skipped. DETERMINISTIC given seed (no diversity/rating impact, safe in Batch Training) but an APPROXIMATION — validate A/B before trusting on final renders. Note: much of wall-clock time is outside the sampler (encode/decode), so sampler speedup ≠ total speedup. Off by default. UNVALIDATED LIVE.",
+                    "tooltip": "EXPERIMENTAL speed (MixCache/Chorus-family step-caching, adapted to LTX2.3's distilled schedule). IGNORED while context_windows is on (the cache can't tell one window from another within a step) — the scene report says so. Mechanism: the near-pure-noise plateau steps (sigma above plateau_cache_threshold) carry almost no signal, so the model's output barely changes across them. This computes the full transformer forward once at the top of the plateau, then REUSES that output for the remaining plateau steps instead of recomputing — skipping those transformer passes entirely. On the default 8-step schedule (sigmas 1.0→0.975 are the plateau) that's ~3-4 of 8 forwards skipped. DETERMINISTIC given seed (no diversity/rating impact, safe in Batch Training) but an APPROXIMATION — validate A/B before trusting on final renders. Note: much of wall-clock time is outside the sampler (encode/decode), so sampler speedup ≠ total speedup. Off by default. UNVALIDATED LIVE.",
                 }),
                 "plateau_cache_threshold": ("FLOAT", {
                     "default": 0.975, "min": 0.5, "max": 0.999, "step": 0.005,
@@ -5168,7 +5168,18 @@ class FunPackLTXAVSceneChainSampler:
                 # Innermost wrapper (installed first): caches the raw base-model forward on the
                 # near-noise plateau so later plateau steps reuse it. All guidance wrappers below
                 # layer around it and still post-process each step's (cached-or-fresh) prediction.
-                if plateau_cache:
+                #
+                # MUTUALLY EXCLUSIVE with context windows: the cache is keyed by
+                # (input.shape, cond_or_uncond), and every window within one step calls the model
+                # with the SAME shape. Windows 2..N would therefore be handed window 1's cached
+                # prediction on every plateau step — one window's content bleeding across the whole
+                # clip. Context windows wins (it's a capability, the cache is a speed experiment);
+                # say so in the report rather than silently dropping one of two ticked boxes.
+                if plateau_cache and _ctx_remove is not None:
+                    run_mechanisms.append(
+                        "plateau_cache(SKIPPED: incompatible with context_windows — the per-step "
+                        "cache cannot tell two windows apart)")
+                elif plateau_cache:
                     _plateau_stats = self._build_plateau_cache_wrapper(model, plateau_cache_threshold)
                 # Loop temporal style (auto director's funpack_temporal_loop): Mobius latent
                 # roll. Installed BELOW the guidance wrappers (embed guidance / slider /

From 2ea42448fdf688b25e520cc4bf633d2df3c0afd5 Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Wed, 29 Jul 2026 21:54:00 +0300
Subject: [PATCH 08/29] Context windows: correct the cost figure in both
 tooltips

overlap/length (~28%) is the per-window redundancy, not the whole-clip cost.
The real figure is stride-based: at 145/40 each window advances 105 new frames,
so a windowed scene does ~1.45x the per-frame work regardless of length. That
is offset by attention, which is quadratic in one pass and near-flat when
windowed: ~1.05x at 200 frames, 0.68x at 305, 0.42x at 500. Net: roughly
break-even around 200 frames, a real win past ~300.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 movie_editor/frontend/engine_settings.js | 2 +-
 samplers.py                              | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/movie_editor/frontend/engine_settings.js b/movie_editor/frontend/engine_settings.js
index 470dd944..b4e04244 100644
--- a/movie_editor/frontend/engine_settings.js
+++ b/movie_editor/frontend/engine_settings.js
@@ -227,7 +227,7 @@
       deps: [{ name: "segmented_detailing" }, { name: "detail_mode", value: "repair" }],
       hint: "How much noise the crop gets re-noised to before its 3-step refine (0.85 is the official LTX 2.3 recipe's own value). Higher = more freedom to genuinely reconstruct the region (fix bad anatomy), risking drift from the surrounding frame; lower = closer to a plain upscale — looks 'detailed' as interpolation but doesn't actually repair it. If the result looks upscaled but not corrected, raise this. Only used in 'repair' mode." },
     { name: "context_windows", label: "Context windows (long scenes)", kind: "bool", default: false,
-      hint: "EXPERIMENTAL: denoise a scene that's LONGER than the model's comfortable window as overlapping windows instead of one giant pass — ComfyUI core's own mechanism, audio-aware on LTX (it maps each video window to its audio window and re-slices anchors, guides and JoyAI memory per window). Engages only on scenes longer than the window length below; shorter scenes are untouched and pay nothing. Cost isn't a flat multiple — the total work is about the same, plus the overlap being computed twice (~28% at the defaults). Needs ComfyUI v0.29.0 or newer; on older builds it's skipped with a note in the scene report. UNVALIDATED LIVE." },
+      hint: "EXPERIMENTAL: denoise a scene that's LONGER than the model's comfortable window as overlapping windows instead of one giant pass — ComfyUI core's own mechanism, audio-aware on LTX (it maps each video window to its audio window and re-slices anchors, guides and JoyAI memory per window). Engages only on scenes longer than the window length below; shorter scenes are untouched and pay nothing. Cost at the defaults (145/40) is about 1.45× the per-frame work, since each window re-does its 40-frame overlap — offset by attention getting cheaper the longer the scene is (quadratic in one pass, near-flat when windowed). Roughly break-even around 200 frames, a net win past ~300. Needs ComfyUI v0.29.0 or newer; on older builds it's skipped with a note in the scene report. UNVALIDATED LIVE." },
     { name: "context_window_length", label: "Window length (frames)", kind: "int", default: 145, min: 9, max: 2049, step: 8, dependsOn: "context_windows",
       hint: "Window size in real frames. A scene at or below this length skips windowing entirely, so this doubles as the engage threshold. Keep it at or under the length the model already generates well in one pass — the point is to stay inside that range while the scene as a whole goes past it." },
     { name: "context_window_overlap", label: "Window overlap (frames)", kind: "int", default: 40, min: 0, max: 512, step: 8, dependsOn: "context_windows",
diff --git a/samplers.py b/samplers.py
index 07dd81b1..26dd3539 100644
--- a/samplers.py
+++ b/samplers.py
@@ -2484,7 +2484,7 @@ class FunPackLTXAVSceneChainSampler:
                 }),
                 "context_windows": ("BOOLEAN", {
                     "default": False,
-                    "tooltip": "EXPERIMENTAL: denoise a scene LONGER than the model's native window as overlapping context windows instead of one giant pass (ComfyUI core's own comfy.context_windows, LTX2 branch — nothing ported). Each step splits the scene into windows of context_window_length frames, denoises each, and fuses the overlaps back together. Core's LTXAV path is genuinely audio-aware: it unpacks the packed AV latent, maps each video window onto its proportional AUDIO window, and re-slices denoise masks, keyframe_idxs and guide_attention_entries per window — so i2v anchors, mid-scene guides and JoyAI memory keep working inside a window. Cost is NOT a flat multiple: total tokens stay roughly the same and windowed attention is cheaper than full-length attention, but the overlap is recomputed (overlap/length extra work, ~28% at the defaults). Engages ONLY when the scene is longer than context_window_length — shorter scenes are untouched and pay nothing. Off by default. UNVALIDATED LIVE.",
+                    "tooltip": "EXPERIMENTAL: denoise a scene LONGER than the model's native window as overlapping context windows instead of one giant pass (ComfyUI core's own comfy.context_windows, LTX2 branch — nothing ported). Each step splits the scene into windows of context_window_length frames, denoises each, and fuses the overlaps back together. Core's LTXAV path is genuinely audio-aware: it unpacks the packed AV latent, maps each video window onto its proportional AUDIO window, and re-slices denoise masks, keyframe_idxs and guide_attention_entries per window — so i2v anchors, mid-scene guides and JoyAI memory keep working inside a window. Cost at the defaults (145/40): about 1.45x the per-frame work, because each window re-does its 40-frame overlap, offset against attention getting CHEAPER the longer the scene is (attention is quadratic in one pass, near-flat when windowed) - roughly break-even around 200 frames, a net win past ~300. Engages ONLY when the scene is longer than context_window_length — shorter scenes are untouched and pay nothing. Off by default. UNVALIDATED LIVE.",
                 }),
                 "context_window_length": ("INT", {
                     "default": 145, "min": 9, "max": 2049, "step": 8,

From e158d02e4688a8e37357e24d6523f0f25a6f4845 Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Wed, 29 Jul 2026 22:19:09 +0300
Subject: [PATCH 09/29] Chain Sampler: anchor_shift - keep the real i2v anchor,
 then delete it

User's idea, and the framing is the point: this is "faking t2v" when it is
really i2v. Every existing way of stopping the anchor from dominating the
opening WEAKENS it first - ALG blurs it and loses character detail, and if you
under-blur you get both failure modes at once; Best-FaceID overlap tokens
approximate it and lose some detail too. This weakens nothing. The anchor is
pinned at full strength, untouched, for as long as it takes to transfer
identity/style/composition - and is then removed from the clip entirely.

Two passes:
  pass 1  sigma[0] .. anchor_shift_sigma, anchor pinned as usual
  shift   drop the first N latent frames, slide everything left, refill the
          freed tail, drop the pin (clip LENGTH is unchanged - nothing extra
          is ever generated; the dropped head is regrown at the end)
  pass 2  restart sigma .. 0, unpinned

Two passes rather than a roll between steps for a specific reason: pass 2
re-enters through comfy's CONST noise scaling (x = s*noise + (1-s)*latent),
which puts the shifted latent back ON the rectified-flow manifold. A raw
in-flight roll skips that, and project_sigmas records that this model cannot
recover from off-manifold latent states - that is what killed churn. Same
on-manifold re-entry that segmented detailing's stage-2 tail already uses.

Every choice is a knob, because WHERE to cut is the entire experiment and I
have no measurement for it: shift sigma (default 0.909, the first step where
structure actually forms - above it nothing has formed and the anchor would be
discarded before doing any work), frames dropped, pass-2 restart sigma
(0 = continue, higher = rewind for more freedom at the joint), what the
regrown tail starts from, and whether audio is rewritten in pass 2 (on by
default: pass 1's audio was scored against frames that have since moved).

Refused, loudly and with the reason in the scene report, on continuation
scenes (the head is carried frames, not an anchor), on scenes carrying guide
frames (the slide would overwrite them) and on scenes with JoyAI audio memory
(resetting audio would destroy the injected tail).

One real bug caught by the new tests while writing them: SIGMAS are float32,
so a threshold typed as 0.725 is a float64 sitting just below the schedule's
float32 0.725, and a bare `v <= s` cut one step LATER than the number entered.
Now matched against core's own isclose tolerance.

11 new tests; suite at baseline (22 pre-existing failures, no new). Editor
checked live: knobs render, gate on the toggle, persist to sampler_inputs.
UNVALIDATED LIVE - the shift sigma is yours to find.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 movie_editor/frontend/engine_settings.js |  14 +-
 samplers.py                              | 190 ++++++++++++++++++++++-
 tests/test_anchor_shift.py               | 135 ++++++++++++++++
 3 files changed, 335 insertions(+), 4 deletions(-)
 create mode 100644 tests/test_anchor_shift.py

diff --git a/movie_editor/frontend/engine_settings.js b/movie_editor/frontend/engine_settings.js
index b4e04244..fd3ee12c 100644
--- a/movie_editor/frontend/engine_settings.js
+++ b/movie_editor/frontend/engine_settings.js
@@ -226,6 +226,18 @@
     { name: "detail_denoise", label: "Detail re-noise strength", kind: "float", default: 0.85, min: 0.3, max: 0.99, step: 0.05,
       deps: [{ name: "segmented_detailing" }, { name: "detail_mode", value: "repair" }],
       hint: "How much noise the crop gets re-noised to before its 3-step refine (0.85 is the official LTX 2.3 recipe's own value). Higher = more freedom to genuinely reconstruct the region (fix bad anatomy), risking drift from the surrounding frame; lower = closer to a plain upscale — looks 'detailed' as interpolation but doesn't actually repair it. If the result looks upscaled but not corrected, raise this. Only used in 'repair' mode." },
+    { name: "anchor_shift", label: "Anchor shift (fake t2v)", kind: "bool", default: false,
+      hint: "EXPERIMENTAL: keep the real, untouched i2v anchor — then delete it from the clip. The anchor is a pinned frame at position 0, so it holds character detail, style and composition better than anything that weakens it on the way in (ALG blurs it and loses detail; Best-FaceID tokens approximate it and lose some too), but it is also literally the first frame you see. This runs pass 1 down to the sigma below with the anchor pinned as normal, drops the first frames and slides everything left (clip length unchanged — no extra frames generated), then finishes the schedule with the pin gone. The result is an i2v generation that reads as t2v. Pass 2 re-enters through the model's own noise scaling, which is what keeps the shifted latent on-manifold. Skipped on continuation scenes and on scenes carrying guide frames or JoyAI audio memory, with the reason in the scene report. UNVALIDATED LIVE." },
+    { name: "anchor_shift_sigma", label: "Shift at sigma", kind: "float", default: 0.909, min: 0.05, max: 0.999, step: 0.001, dependsOn: "anchor_shift",
+      hint: "The knob this feature exists to let you tune. Pass 1 runs until the schedule first reaches this sigma, then the shift happens. 0.909 is where structure actually starts forming on the distilled schedule (1.0 and 0.975 are near-pure noise and carry almost no signal), so it's the earliest cut where the anchor has plausibly transferred anything — a starting guess, not a measured value. Higher = released sooner and cheaper, but the reference may never have landed. Lower = held longer, but more of pass 1's picture is thrown away by the slide and fewer steps remain to repair it." },
+    { name: "anchor_shift_frames", label: "Frames to drop", kind: "int", default: 8, min: 8, max: 512, step: 8, dependsOn: "anchor_shift",
+      hint: "How much of the front to drop at the shift, in real frames. 8 (one latent frame) removes just the anchor itself; more also removes the settling-in region where the shot is still visibly 'leaving' the reference still. Raise it if the opening still looks like it departed from a photo. The clip doesn't get shorter — whatever is dropped here is regrown at the end by pass 2." },
+    { name: "anchor_shift_restart_sigma", label: "Pass 2 restart sigma", kind: "float", default: 0.0, min: 0.0, max: 0.999, step: 0.001, dependsOn: "anchor_shift",
+      hint: "Where pass 2 re-enters. 0 (default) continues from where pass 1 stopped, so the total cost stays one full schedule. Setting it higher than the shift sigma rewinds — pass 2 re-noises the shifted latent back up and re-denoises from there, giving more freedom to rebuild the regrown tail and blend the joint, at the cost of repeating those steps and partly overwriting what pass 1 established. Try it if the seam is visible or the new ending looks thin." },
+    { name: "anchor_shift_tail", label: "Regrown tail starts from", kind: "combo", choices: ["extend_last", "wrap", "empty"], default: "extend_last", dependsOn: "anchor_shift",
+      hint: "What fills the freed end after the slide. 'extend_last' (default) repeats the final frame so pass 2 grows the new ending out of something continuous with it. 'wrap' puts the dropped head back at the end — continuous, but it re-shows the reference image at the END of the clip. 'empty' zeroes it and lets pass 2 generate freely — most freedom, most likely to drift from the rest of the shot." },
+    { name: "anchor_shift_fresh_audio", label: "Regenerate audio in pass 2", kind: "bool", default: true, dependsOn: "anchor_shift",
+      hint: "Reset the audio to an empty latent before pass 2 so it's written fresh against the shifted picture. On by default because pass 1's audio was formed against frames that no longer sit at those positions. Turn off only to A/B whether the carried audio actually sounds better." },
     { name: "context_windows", label: "Context windows (long scenes)", kind: "bool", default: false,
       hint: "EXPERIMENTAL: denoise a scene that's LONGER than the model's comfortable window as overlapping windows instead of one giant pass — ComfyUI core's own mechanism, audio-aware on LTX (it maps each video window to its audio window and re-slices anchors, guides and JoyAI memory per window). Engages only on scenes longer than the window length below; shorter scenes are untouched and pay nothing. Cost at the defaults (145/40) is about 1.45× the per-frame work, since each window re-does its 40-frame overlap — offset by attention getting cheaper the longer the scene is (quadratic in one pass, near-flat when windowed). Roughly break-even around 200 frames, a net win past ~300. Needs ComfyUI v0.29.0 or newer; on older builds it's skipped with a note in the scene report. UNVALIDATED LIVE." },
     { name: "context_window_length", label: "Window length (frames)", kind: "int", default: 145, min: 9, max: 2049, step: 8, dependsOn: "context_windows",
@@ -365,7 +377,7 @@
     chain_timing: ["frame_overlap", "transition_duration", "use_same_seed"],
     chain_guidance: ["cfg", "embed_guidance", "embed_guidance_source", "embed_guidance_strength", "score_slider", "score_slider_strength", "taste_nearest_prompt", "output_guidance", "output_guidance_strength", "dynashift", "dynashift_strength", "dynashift_threshold"],
     chain_decode: ["decode_noise_scale", "decode_timestep", "decode_tile_size"],
-    chain_experimental: ["context_windows", "context_window_length", "context_window_overlap", "context_window_schedule", "context_window_fuse", "context_window_freenoise", "context_window_retain_first", "plateau_cache", "plateau_cache_threshold", "segmented_detailing", "detail_targets", "detail_strength", "detail_threshold", "detail_max_area", "detail_mode", "detail_denoise", "mid_scene_guide", "mid_scene_guide_strength", "joyai_memory", "joyai_memory_size", "joyai_fix_frames", "joyai_frame_select", "joyai_memory_strength", "joyai_audio_memory", "v2a_grad_scale", "alg_blur_guides", "alg_guide_blur_strength", "alg_guide_blur_sigma_threshold", "bounded_attention_enabled", "identity_transfer_enabled", "source_id", "phase_scale", "id_strength", "arcface_mode", "debug_log"],
+    chain_experimental: ["anchor_shift", "anchor_shift_sigma", "anchor_shift_frames", "anchor_shift_restart_sigma", "anchor_shift_tail", "anchor_shift_fresh_audio", "context_windows", "context_window_length", "context_window_overlap", "context_window_schedule", "context_window_fuse", "context_window_freenoise", "context_window_retain_first", "plateau_cache", "plateau_cache_threshold", "segmented_detailing", "detail_targets", "detail_strength", "detail_threshold", "detail_max_area", "detail_mode", "detail_denoise", "mid_scene_guide", "mid_scene_guide_strength", "joyai_memory", "joyai_memory_size", "joyai_fix_frames", "joyai_frame_select", "joyai_memory_strength", "joyai_audio_memory", "v2a_grad_scale", "alg_blur_guides", "alg_guide_blur_strength", "alg_guide_blur_sigma_threshold", "bounded_attention_enabled", "identity_transfer_enabled", "source_id", "phase_scale", "id_strength", "arcface_mode", "debug_log"],
   };
 
   function countChainView(p, id) {
diff --git a/samplers.py b/samplers.py
index 26dd3539..1bd8fc45 100644
--- a/samplers.py
+++ b/samplers.py
@@ -2482,6 +2482,30 @@ class FunPackLTXAVSceneChainSampler:
                     "default": "repair",
                     "tooltip": "'repair' (default): upsample the crop, then re-denoise it through the video model for 3 extra steps — can genuinely fix wrong structure (bad anatomy) but costs real compute (~4x region area x 3 steps). 'sharpen': stop after the upsampler's own forward pass — no video-model calls at all, close to free — good for a region that's blurry/under-resolved but already correctly shaped; it CANNOT fix wrong structure (an extra finger stays an extra finger, just sharper), since a super-resolution net only adds detail consistent with what's already there.",
                 }),
+                "anchor_shift": ("BOOLEAN", {
+                    "default": False,
+                    "tooltip": "EXPERIMENTAL: let the i2v anchor condition the scene, then delete it from the clip. The anchor is a pinned latent frame at position 0 — it holds identity/style/composition all the way down the schedule, and it is also literally the first frame you see, so every i2v scene opens on the exact reference still. This splits the schedule: pass 1 runs down to anchor_shift_sigma with the anchor pinned as usual, then the first anchor_shift_frames frames are DROPPED and everything slides left (clip length unchanged — no extra frames are generated), then pass 2 finishes the schedule on the shifted latent with the pin gone. Pass 2 re-enters through comfy's CONST noise scaling, which puts the shifted latent back on the rectified-flow manifold — the reason this is two passes rather than a roll between steps. The whole experiment is WHERE to cut: above ~0.909 nothing has formed yet, so the anchor gets discarded before it has transferred anything; too low and pass 2 has no steps left to heal the seam. Off by default. UNVALIDATED LIVE.",
+                }),
+                "anchor_shift_sigma": ("FLOAT", {
+                    "default": 0.909, "min": 0.05, "max": 0.999, "step": 0.001,
+                    "tooltip": "Sigma at which pass 1 stops and the shift happens — the knob this whole feature exists to let you tune. Pass 1 runs until the schedule first reaches a sigma at or below this. 0.909 is the step where structure actually starts forming on the LTX distilled schedule (1.0 and 0.975 are the near-pure-noise plateau and carry almost no signal), so it is the earliest cut where the anchor has plausibly transferred anything — but it is a starting guess, not a measured value. Higher = anchor released sooner, cheaper, more likely the reference never really landed. Lower = anchor held longer, more of pass 1's picture is thrown away by the shift and fewer steps remain to repair it. If the schedule never reaches this sigma, the pass is skipped with a note.",
+                }),
+                "anchor_shift_frames": ("INT", {
+                    "default": 8, "min": 8, "max": 512, "step": 8,
+                    "tooltip": "How many frames to drop off the front at the shift, in real frames (converted to latent frames with the VAE's own time scale). One latent frame — 8 real frames at the standard scale — removes just the anchor itself. More also removes the settling-in region right after it, where the clip is still visibly 'leaving' the reference image; raise this if the opening still looks like it is departing from a still rather than already in motion. The clip does not get shorter: whatever is dropped here is regrown at the end by pass 2.",
+                }),
+                "anchor_shift_restart_sigma": ("FLOAT", {
+                    "default": 0.0, "min": 0.0, "max": 0.999, "step": 0.001,
+                    "tooltip": "Where pass 2 re-enters the schedule. 0 (default) means 'continue from where pass 1 stopped' — the cheapest option, total cost stays one full schedule. Setting it HIGHER than anchor_shift_sigma rewinds: pass 2 re-noises the shifted latent back up to that sigma and re-denoises from there, giving the model more freedom to rebuild the regrown tail and blend the seam, at the cost of repeating those steps (and of partly overwriting what pass 1 established). Try this if the joint is visible or the regrown tail looks thin at the default.",
+                }),
+                "anchor_shift_tail": (["extend_last", "wrap", "empty"], {
+                    "default": "extend_last",
+                    "tooltip": "What the freed tail starts from after the slide. 'extend_last' (default) repeats the final frame, so pass 2 grows the new ending out of content that is already continuous with it. 'wrap' puts the dropped head back at the end (Mobius) — cheap and continuous, but it re-shows the reference image at the END of the clip, which is usually not what you want. 'empty' zeros the region and lets pass 2's noise scaling generate it from scratch — most freedom, most likely to drift from the rest of the shot.",
+                }),
+                "anchor_shift_fresh_audio": ("BOOLEAN", {
+                    "default": True,
+                    "tooltip": "Reset the audio stream to an empty latent before pass 2, so audio is generated fresh against the shifted picture. On by default because pass 1's audio was formed against frames that no longer sit at those positions — carrying it over means audio scored to a picture that moved. Turn off only to A/B whether the carried audio actually sounds better.",
+                }),
                 "context_windows": ("BOOLEAN", {
                     "default": False,
                     "tooltip": "EXPERIMENTAL: denoise a scene LONGER than the model's native window as overlapping context windows instead of one giant pass (ComfyUI core's own comfy.context_windows, LTX2 branch — nothing ported). Each step splits the scene into windows of context_window_length frames, denoises each, and fuses the overlaps back together. Core's LTXAV path is genuinely audio-aware: it unpacks the packed AV latent, maps each video window onto its proportional AUDIO window, and re-slices denoise masks, keyframe_idxs and guide_attention_entries per window — so i2v anchors, mid-scene guides and JoyAI memory keep working inside a window. Cost at the defaults (145/40): about 1.45x the per-frame work, because each window re-does its 40-frame overlap, offset against attention getting CHEAPER the longer the scene is (attention is quadratic in one pass, near-flat when windowed) - roughly break-even around 200 frames, a net win past ~300. Engages ONLY when the scene is longer than context_window_length — shorter scenes are untouched and pay nothing. Off by default. UNVALIDATED LIVE.",
@@ -2969,6 +2993,104 @@ class FunPackLTXAVSceneChainSampler:
         latent.pop("noise_mask", None)
         return latent
 
+    # ---------------------------------------------------------------------------
+    # anchor_shift — let the i2v anchor do its work, then delete it from the clip.
+    #
+    # The anchor is a real, PINNED latent frame at temporal position 0: it constrains
+    # identity/style/composition all the way down the schedule, and it is also literally
+    # the first frame you see. This runs the schedule in two passes so it can be the
+    # former without being the latter:
+    #
+    #   pass 1: sigma[0] .. shift_sigma, anchor pinned as usual -> a partly-formed clip
+    #           that has already absorbed the reference
+    #   shift : drop the first N latent frames (the anchor and its settling-in region),
+    #           slide everything left, refill the freed tail, drop the pin
+    #   pass 2: restart_sigma .. 0 on the shifted latent
+    #
+    # Why two passes rather than mutating x between steps inside the sampler: pass 2 goes
+    # back through comfy's CONST noise scaling (x = s*noise + (1-s)*latent), which puts the
+    # shifted latent back ON the rectified-flow manifold at the restart sigma. A raw
+    # in-flight roll skips that, and [[project_sigmas]] records that this model cannot
+    # recover from off-manifold latent states (the churn dead end). Same on-manifold
+    # re-entry recipe that segmented detailing's stage-2 tail already uses in production.
+    #
+    # Everything about WHEN and HOW MUCH is a knob: shift sigma, frames dropped, restart
+    # sigma, tail refill, audio. The sigma in particular is the whole experiment - too high
+    # and the anchor is discarded before it has transferred anything (nothing has formed
+    # above ~0.909), too low and pass 2 has too few steps left to heal the seam.
+    # ---------------------------------------------------------------------------
+
+    def _anchor_shift_split_sigmas(self, sigmas, shift_sigma, restart_sigma):
+        """Cut the schedule into (pass 1, pass 2), or return None if it cannot be cut.
+
+        pass 1 runs from the top down to the first sigma at or below shift_sigma; pass 2
+        starts at the first sigma at or below restart_sigma (restart_sigma <= 0 means
+        "continue from where pass 1 stopped") and runs to the end. Both need at least one
+        real step, so a threshold outside the schedule's range is refused rather than
+        silently producing a zero-step pass.
+        """
+        if not isinstance(sigmas, torch.Tensor) or sigmas.numel() < 3:
+            return None
+        vals = [float(v) for v in sigmas.tolist()]
+        # SIGMAS are float32; a threshold typed as 0.725 is a float64 that sits just BELOW the
+        # float32 0.725 in the schedule, so a bare `v <= s` silently cuts one step later than
+        # the number the user entered. Match core's own tolerance convention (isclose rtol=1e-4).
+        eps = 1e-4
+
+        def _first_at_or_below(s):
+            return next((i for i, v in enumerate(vals) if v <= s + eps), None)
+
+        cut = _first_at_or_below(float(shift_sigma))
+        if cut is None or cut < 1:
+            return None  # threshold above the first sigma, or not reached at all
+        restart = float(restart_sigma)
+        if restart <= 0:
+            start = cut
+        else:
+            start = _first_at_or_below(restart)
+            if start is None:
+                return None
+        first = sigmas[:cut + 1]
+        second = sigmas[start:]
+        if first.numel() < 2 or second.numel() < 2:
+            return None
+        return first, second, vals[cut], vals[start]
+
+    def _anchor_shift_latent(self, latent, drop, tail_mode, fresh_audio):
+        """Slide the video stream left by `drop` latent frames and refill the freed tail.
+
+        The head frames (anchor + settling-in region) are dropped, not cropped: the clip
+        keeps its full length, so no extra frames are ever generated to pay for this. The
+        freed tail is what pass 2 will grow into; `tail_mode` picks what it starts from.
+        Audio is optionally reset to an empty latent so pass 2 writes it fresh against the
+        shifted picture instead of inheriting pass 1's audio, which was scored against
+        frames that no longer exist at those positions.
+        """
+        result = self._clone_latent(latent)
+        tensors = self._latent_tensors(result)
+        video = tensors[0]
+        frames = self._tensor_frames(video)
+        drop = max(0, min(int(drop), frames - 1))
+        if drop <= 0:
+            return result, 0
+        head, body = video[:, :, :drop], video[:, :, drop:]
+        if tail_mode == "wrap":
+            tail = head  # Mobius: the dropped head reappears at the end
+        elif tail_mode == "extend_last":
+            tail = body[:, :, -1:].repeat(1, 1, drop, 1, 1)
+        else:  # "empty": zeros, so pass 2's noise scaling starts that region from noise
+            tail = torch.zeros_like(head)
+        tensors[0] = torch.cat([body, tail], dim=2)
+        if fresh_audio and len(tensors) > 1 and tensors[1] is not None:
+            tensors[1] = torch.zeros_like(tensors[1])
+        if self._is_nested(result.get("samples")):
+            result["samples"] = comfy.nested_tensor.NestedTensor(tensors)
+        else:
+            result["samples"] = tensors[0]
+        # The pin belongs to a frame that no longer exists; pass 2 must run unpinned.
+        result.pop("noise_mask", None)
+        return result, drop
+
     def _output_connected(self, prompt, unique_id, output_index):
         """Return True if the given output slot index is wired to any downstream node."""
         if not prompt or not unique_id:
@@ -4816,6 +4938,9 @@ class FunPackLTXAVSceneChainSampler:
                context_windows=False, context_window_length=145, context_window_overlap=40,
                context_window_schedule="uniform_standard", context_window_fuse="pyramid",
                context_window_freenoise=True, context_window_retain_first=False,
+               anchor_shift=False, anchor_shift_sigma=0.909, anchor_shift_frames=8,
+               anchor_shift_restart_sigma=0.0, anchor_shift_tail="extend_last",
+               anchor_shift_fresh_audio=True,
                unique_id=None, prompt=None):
         if not isinstance(positive, list) or not positive:
             raise ValueError("positive conditioning must contain at least one scene entry.")
@@ -4880,6 +5005,11 @@ class FunPackLTXAVSceneChainSampler:
                 context_window_fuse=context_window_fuse,
                 context_window_freenoise=context_window_freenoise,
                 context_window_retain_first=context_window_retain_first,
+                anchor_shift=anchor_shift, anchor_shift_sigma=anchor_shift_sigma,
+                anchor_shift_frames=anchor_shift_frames,
+                anchor_shift_restart_sigma=anchor_shift_restart_sigma,
+                anchor_shift_tail=anchor_shift_tail,
+                anchor_shift_fresh_audio=anchor_shift_fresh_audio,
             )
 
         max_scene_count = max(1, int(max_scenes))
@@ -5284,14 +5414,60 @@ class FunPackLTXAVSceneChainSampler:
                             )
                             run_mechanisms.append(f"identity_transfer_arcface(id_strength={id_strength})")
                 _t_sample0 = _time.perf_counter()
-                sampled = self._sample_chunk(
-                    model, sampler, sigmas, scene_seed, cfg, scene_positive, scene_negative, chunk,
+                _sample_kwargs = dict(
                     pbar=pbar, step_offset=scene_index * steps_per_scene,
                     alg_guide_tail_frames=(guide_tail if (alg_blur_guides and guide_tail > 0) else 0),
                     alg_guide_blur_strength=alg_guide_blur_strength,
                     alg_guide_blur_sigma_threshold=alg_guide_blur_sigma_threshold,
                     bounded_attention_enabled=bounded_attention_enabled,
                 )
+                # anchor_shift: "fake t2v" — run with the real, untouched i2v anchor, then
+                # delete it from the clip instead of weakening it (ALG blurs the anchor and
+                # loses character detail; overlap tokens approximate it and lose some too).
+                _shift_split = None
+                if anchor_shift:
+                    _shift_drop = self._expected_latent_frames(
+                        int(anchor_shift_frames) + 1, time_scale) - 1
+                    if carried + soft_carried > 0:
+                        _reason = ("continuation scene — the head is carried frames from the "
+                                   "previous scene, not an anchor")
+                    elif guide_tail > 0:
+                        _reason = ("scene has appended guide frames at the tail (mid_scene_guide "
+                                   "/ carried i2v guides) — the slide would overwrite them")
+                    elif audio_tail > 0:
+                        _reason = ("scene has appended JoyAI audio memory — resetting the audio "
+                                   "stream would destroy the injected tail")
+                    elif self._context_scene_latent_frames(chunk) is None:
+                        _reason = "scene latent could not be read"
+                    elif _shift_drop <= 0:
+                        _reason = f"anchor_shift_frames={anchor_shift_frames} is under one latent frame"
+                    else:
+                        _shift_split = self._anchor_shift_split_sigmas(
+                            sigmas, anchor_shift_sigma, anchor_shift_restart_sigma)
+                        _reason = (f"schedule never reaches anchor_shift_sigma="
+                                   f"{anchor_shift_sigma} with a step left on both sides")
+                    if _shift_split is None:
+                        run_mechanisms.append(f"anchor_shift(SKIPPED: {_reason})")
+                if _shift_split is not None:
+                    _sig_a, _sig_b, _cut_at, _restart_at = _shift_split
+                    _pass1 = self._sample_chunk(
+                        model, sampler, _sig_a, scene_seed, cfg, scene_positive, scene_negative,
+                        chunk, **_sample_kwargs)
+                    _shifted, _dropped = self._anchor_shift_latent(
+                        _pass1, _shift_drop, anchor_shift_tail, anchor_shift_fresh_audio)
+                    # Fresh noise for pass 2: reusing scene_seed's field would re-apply the
+                    # exact noise pass 1 just resolved, against content that has moved.
+                    sampled = self._sample_chunk(
+                        model, sampler, _sig_b, scene_seed + 4242, cfg, scene_positive,
+                        scene_negative, _shifted, **_sample_kwargs)
+                    run_mechanisms.append(
+                        f"anchor_shift(cut@{_cut_at:g} restart@{_restart_at:g}, "
+                        f"dropped {_dropped} latent frames, tail={anchor_shift_tail}"
+                        f"{', fresh audio' if anchor_shift_fresh_audio else ''})")
+                else:
+                    sampled = self._sample_chunk(
+                        model, sampler, sigmas, scene_seed, cfg, scene_positive, scene_negative,
+                        chunk, **_sample_kwargs)
                 _scene_sample_s = _time.perf_counter() - _t_sample0
                 _phase_sampling += _scene_sample_s
                 if _plateau_stats is not None:
@@ -5628,7 +5804,10 @@ class FunPackLTXAVSceneChainSampler:
                             context_windows=False, context_window_length=145,
                             context_window_overlap=40, context_window_schedule="uniform_standard",
                             context_window_fuse="pyramid", context_window_freenoise=True,
-                            context_window_retain_first=False):
+                            context_window_retain_first=False,
+                            anchor_shift=False, anchor_shift_sigma=0.909, anchor_shift_frames=8,
+                            anchor_shift_restart_sigma=0.0, anchor_shift_tail="extend_last",
+                            anchor_shift_fresh_audio=True):
         """Sample one chain per Studio-packed variant entry (seed + index), persisting each result
         (latent + preview + per-entry cond + manifest) under ComfyUI temp for rating in Studio.
         Reuses sample() per entry with only the seed changed, so each entry is a clean generation."""
@@ -5688,6 +5867,11 @@ class FunPackLTXAVSceneChainSampler:
                 context_window_fuse=context_window_fuse,
                 context_window_freenoise=context_window_freenoise,
                 context_window_retain_first=context_window_retain_first,
+                anchor_shift=anchor_shift, anchor_shift_sigma=anchor_shift_sigma,
+                anchor_shift_frames=anchor_shift_frames,
+                anchor_shift_restart_sigma=anchor_shift_restart_sigma,
+                anchor_shift_tail=anchor_shift_tail,
+                anchor_shift_fresh_audio=anchor_shift_fresh_audio,
                 unique_id=None, prompt=None,
             )
             last = out
diff --git a/tests/test_anchor_shift.py b/tests/test_anchor_shift.py
new file mode 100644
index 00000000..ff42173f
--- /dev/null
+++ b/tests/test_anchor_shift.py
@@ -0,0 +1,135 @@
+"""anchor_shift — "fake t2v": run with the real untouched i2v anchor, then delete it.
+
+The point of the feature is that the anchor is NOT weakened on the way in (ALG blurs it and
+loses character detail; Best-FaceID overlap tokens approximate it and lose some too) — it is
+pinned at full strength for pass 1 and then removed from the clip entirely. So the invariants
+worth testing are about the shift itself:
+
+1. The schedule is cut into two passes that each still have a real step, or refused outright.
+2. The slide drops the head WITHOUT shortening the clip — no extra frames are ever generated.
+3. The pin is dropped with the frame it belonged to (pass 2 must run unpinned).
+4. Audio is reset when asked, since pass 1's audio was formed against frames that moved.
+"""
+import sys
+import types
+from pathlib import Path
+
+import torch
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+for _name in (
+    "comfy", "comfy.k_diffusion", "comfy.k_diffusion.sampling",
+    "comfy.model_sampling", "comfy.nested_tensor", "comfy.sample",
+    "comfy.samplers", "comfy.utils",
+):
+    sys.modules.setdefault(_name, types.ModuleType(_name))
+sys.modules["comfy.nested_tensor"].NestedTensor = object
+
+import samplers  # noqa: E402
+
+
+# The standard LTX distilled schedule: plateau, then structure at 0.909, then detail.
+SCHEDULE = torch.tensor([1.0, 0.975, 0.909, 0.725, 0.422, 0.0])
+
+
+def _node():
+    return samplers.FunPackLTXAVSceneChainSampler()
+
+
+def _latent(frames=10, audio=True):
+    video = torch.arange(frames, dtype=torch.float32).view(1, 1, frames, 1, 1).repeat(1, 4, 1, 2, 2)
+    latent = {"samples": video, "noise_mask": torch.zeros_like(video)}
+    if audio:
+        latent["_audio"] = torch.ones(1, 4, frames * 2)
+    return latent
+
+
+# ── schedule splitting ──────────────────────────────────────────────────────
+
+def test_split_cuts_at_the_requested_sigma_and_continues_by_default():
+    first, second, cut_at, restart_at = _node()._anchor_shift_split_sigmas(SCHEDULE, 0.909, 0.0)
+    # float32: the schedule stores 0.909 as 0.90899997, so compare loosely.
+    assert abs(cut_at - 0.909) < 1e-5 and abs(restart_at - 0.909) < 1e-5
+    # pass 1 ends ON the cut sigma; pass 2 resumes from it, so no step is run twice.
+    assert [round(v, 3) for v in first.tolist()] == [1.0, 0.975, 0.909]
+    assert [round(v, 3) for v in second.tolist()] == [0.909, 0.725, 0.422, 0.0]
+
+
+def test_restart_sigma_above_the_cut_rewinds_pass_two():
+    first, second, cut_at, restart_at = _node()._anchor_shift_split_sigmas(SCHEDULE, 0.725, 0.975)
+    assert abs(cut_at - 0.725) < 1e-5 and abs(restart_at - 0.975) < 1e-5
+    assert [round(v, 3) for v in second.tolist()] == [0.975, 0.909, 0.725, 0.422, 0.0]
+
+
+def test_split_refuses_when_a_pass_would_have_no_steps():
+    n = _node()
+    # Threshold at/above the first sigma: pass 1 would be a single point, no step.
+    assert n._anchor_shift_split_sigmas(SCHEDULE, 1.0, 0.0) is None
+    # Threshold below everything in the schedule: never reached.
+    assert n._anchor_shift_split_sigmas(SCHEDULE, 0.001, 0.0) is None
+    # One step either side is legitimate, even on a minimal 3-sigma schedule.
+    assert n._anchor_shift_split_sigmas(torch.tensor([1.0, 0.5, 0.0]), 0.5, 0.0) is not None
+    # ...but cutting at the FINAL sigma leaves pass 2 a single point, no step.
+    assert n._anchor_shift_split_sigmas(torch.tensor([1.0, 0.5, 0.0]), 0.0, 0.0) is None
+
+
+def test_split_refuses_a_degenerate_schedule():
+    n = _node()
+    assert n._anchor_shift_split_sigmas(torch.tensor([1.0, 0.0]), 0.5, 0.0) is None
+    assert n._anchor_shift_split_sigmas(None, 0.9, 0.0) is None
+
+
+# ── the slide ───────────────────────────────────────────────────────────────
+
+def test_slide_drops_the_head_without_shortening_the_clip():
+    latent = _latent(frames=10)
+    shifted, dropped = _node()._anchor_shift_latent(latent, 2, "extend_last", False)
+    assert dropped == 2
+    v = shifted["samples"]
+    # Length preserved — the feature must never cost extra generated frames.
+    assert v.shape[2] == 10
+    # Frames 2..9 slid to 0..7; the anchor (frame 0) is gone from the clip entirely.
+    assert [float(v[0, 0, i, 0, 0]) for i in range(8)] == [2., 3., 4., 5., 6., 7., 8., 9.]
+    # ...and the freed tail continues from the last real frame.
+    assert [float(v[0, 0, i, 0, 0]) for i in (8, 9)] == [9., 9.]
+
+
+def test_wrap_tail_puts_the_dropped_head_at_the_end():
+    shifted, _ = _node()._anchor_shift_latent(_latent(frames=10), 2, "wrap", False)
+    v = shifted["samples"]
+    assert [float(v[0, 0, i, 0, 0]) for i in (8, 9)] == [0., 1.]
+
+
+def test_empty_tail_zeroes_the_freed_region():
+    shifted, _ = _node()._anchor_shift_latent(_latent(frames=10), 3, "empty", False)
+    v = shifted["samples"]
+    assert torch.equal(v[:, :, -3:], torch.zeros_like(v[:, :, -3:]))
+    assert float(v[0, 0, 0, 0, 0]) == 3.0
+
+
+def test_slide_drops_the_pin_with_the_frame_it_belonged_to():
+    latent = _latent(frames=10)
+    assert "noise_mask" in latent
+    shifted, _ = _node()._anchor_shift_latent(latent, 1, "extend_last", False)
+    # Pass 2 must run unpinned — the pinned frame no longer exists.
+    assert "noise_mask" not in shifted
+
+
+def test_slide_never_consumes_the_whole_clip():
+    shifted, dropped = _node()._anchor_shift_latent(_latent(frames=4), 99, "extend_last", False)
+    assert dropped == 3  # clamped to frames - 1
+    assert shifted["samples"].shape[2] == 4
+
+
+def test_zero_drop_is_a_no_op():
+    shifted, dropped = _node()._anchor_shift_latent(_latent(frames=6), 0, "extend_last", True)
+    assert dropped == 0
+    assert torch.equal(shifted["samples"], _latent(frames=6)["samples"])
+
+
+def test_source_latent_is_never_mutated():
+    latent = _latent(frames=8)
+    before = latent["samples"].clone()
+    _node()._anchor_shift_latent(latent, 3, "extend_last", True)
+    assert torch.equal(latent["samples"], before)

From 83124a37abab71877c046224dcbb5d18d66f1c44 Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Wed, 29 Jul 2026 22:23:24 +0300
Subject: [PATCH 10/29] anchor_shift: refuse on t2v scenes, and warn when the
 anchor survives the slide

Found while checking whether this works in Easy Gen. It does - the knobs render
and persist there through the same shared engine_settings.js - but Easy Gen's
default scene has no anchor image, which exposed a hole: nothing checked that
the scene actually HAS a pinned i2v anchor. On a genuine t2v scene the slide
would have dropped real generated frames and regrown them at the end, for no
benefit at all. This is the "fake t2v" trick; it needs a real anchor to fake
it with. Now refused with that reason in the scene report.

Second guard: if anchor_shift_frames drops FEWER latent frames than the scene
actually pins, part of the anchor survives and stays visible - the exact
outcome the feature exists to prevent. The report now names the pinned count
and the value to raise the knob to.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 samplers.py                | 34 +++++++++++++++++++++++++++++++++-
 tests/test_anchor_shift.py | 21 +++++++++++++++++++++
 2 files changed, 54 insertions(+), 1 deletion(-)

diff --git a/samplers.py b/samplers.py
index 1bd8fc45..92005c7b 100644
--- a/samplers.py
+++ b/samplers.py
@@ -3020,6 +3020,23 @@ class FunPackLTXAVSceneChainSampler:
     # above ~0.909), too low and pass 2 has too few steps left to heal the seam.
     # ---------------------------------------------------------------------------
 
+    def _anchor_pinned_frames(self, chunk):
+        """How many leading latent frames this chunk pins (mask < 1) — i.e. the i2v anchor.
+
+        0 means a genuine t2v scene with no anchor image: there is nothing to shift, and
+        sliding anyway would just discard real generated frames. Reading the CHUNK's own
+        mask rather than the template's is deliberate — it reflects what this scene actually
+        got, including per-scene anchors.
+        """
+        try:
+            tensors = self._latent_tensors(chunk)
+            masks = self._latent_masks(chunk, len(tensors))
+            if not masks or masks[0] is None:
+                return 0
+            return self._protected_prefix_frames(masks[0], self._tensor_frames(tensors[0]))
+        except Exception:
+            return 0
+
     def _anchor_shift_split_sigmas(self, sigmas, shift_sigma, restart_sigma):
         """Cut the schedule into (pass 1, pass 2), or return None if it cannot be cut.
 
@@ -5441,6 +5458,12 @@ class FunPackLTXAVSceneChainSampler:
                         _reason = "scene latent could not be read"
                     elif _shift_drop <= 0:
                         _reason = f"anchor_shift_frames={anchor_shift_frames} is under one latent frame"
+                    elif self._anchor_pinned_frames(chunk) <= 0:
+                        # No pinned prefix = a genuine t2v scene (no anchor image attached).
+                        # Shifting here would drop real generated frames for nothing — this is
+                        # the "fake t2v" trick, it needs a real anchor to fake it WITH.
+                        _reason = ("scene has no pinned i2v anchor (t2v scene) — nothing to shift; "
+                                   "attach an anchor image, or leave anchor_shift off")
                     else:
                         _shift_split = self._anchor_shift_split_sigmas(
                             sigmas, anchor_shift_sigma, anchor_shift_restart_sigma)
@@ -5460,10 +5483,19 @@ class FunPackLTXAVSceneChainSampler:
                     sampled = self._sample_chunk(
                         model, sampler, _sig_b, scene_seed + 4242, cfg, scene_positive,
                         scene_negative, _shifted, **_sample_kwargs)
+                    _pinned_n = self._anchor_pinned_frames(chunk)
                     run_mechanisms.append(
                         f"anchor_shift(cut@{_cut_at:g} restart@{_restart_at:g}, "
-                        f"dropped {_dropped} latent frames, tail={anchor_shift_tail}"
+                        f"dropped {_dropped} of {_pinned_n} pinned latent frames, "
+                        f"tail={anchor_shift_tail}"
                         f"{', fresh audio' if anchor_shift_fresh_audio else ''})")
+                    if _dropped < _pinned_n:
+                        # Part of the anchor survives the slide and stays visible in the clip —
+                        # the one outcome this feature exists to prevent, so name the fix.
+                        run_mechanisms.append(
+                            f"anchor_shift WARNING: {_pinned_n - _dropped} anchor latent frame(s) "
+                            f"still in the clip — raise anchor_shift_frames to at least "
+                            f"{_pinned_n * max(1, int(time_scale))}")
                 else:
                     sampled = self._sample_chunk(
                         model, sampler, sigmas, scene_seed, cfg, scene_positive, scene_negative,
diff --git a/tests/test_anchor_shift.py b/tests/test_anchor_shift.py
index ff42173f..d6304678 100644
--- a/tests/test_anchor_shift.py
+++ b/tests/test_anchor_shift.py
@@ -133,3 +133,24 @@ def test_source_latent_is_never_mutated():
     before = latent["samples"].clone()
     _node()._anchor_shift_latent(latent, 3, "extend_last", True)
     assert torch.equal(latent["samples"], before)
+
+
+# ── the t2v guard ───────────────────────────────────────────────────────────
+
+def test_pinned_frames_counts_the_anchor_prefix():
+    n = _node()
+    frames = 6
+    video = torch.zeros(1, 4, frames, 2, 2)
+    mask = torch.ones(1, 4, frames, 2, 2)
+    mask[:, :, :2] = 0.0  # two pinned anchor frames
+    assert n._anchor_pinned_frames({"samples": video, "noise_mask": mask}) == 2
+
+
+def test_pinned_frames_is_zero_for_a_real_t2v_scene():
+    """No anchor image attached — Easy Gen's default. Shifting would drop real content,
+    so the caller must skip: this is the 'fake t2v' trick and it needs an anchor to fake with."""
+    n = _node()
+    video = torch.zeros(1, 4, 6, 2, 2)
+    assert n._anchor_pinned_frames({"samples": video, "noise_mask": torch.ones(1, 4, 6, 2, 2)}) == 0
+    assert n._anchor_pinned_frames({"samples": video}) == 0  # no mask at all
+    assert n._anchor_pinned_frames({"samples": None}) == 0   # unreadable -> refuse, don't raise

From 9ed53c8346db7795224e06ca5fe1ff86b39c0f38 Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Wed, 29 Jul 2026 22:32:33 +0300
Subject: [PATCH 11/29] Fix anchor_shift under-denoising: pass 2 was re-noising
 a mid-trajectory latent
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Reported from the first live run: the idea works (opening reads as t2v,
character details preserved) but the output is full of noise artifacts, as if
under-denoised, with the last steps seemingly skipped. That was a real bug, not
the concept.

comfy's CONST scaling is x = sigma*noise + (1-sigma)*latent_image, and it
treats latent_image as a CLEAN image. Pass 2 was handed the PARTIALLY DENOISED
latent as latent_image, so at a 0.725 cut it entered at
0.725*fresh_noise + 0.275*picture — pass 1's content attenuated to a quarter
and buried under a full dose of new noise, with only the tail steps left to
recover. Exactly the reported symptom.

I cited segmented detailing's stage-2 tail as the precedent for this re-entry,
but that recipe feeds a FINISHED latent, where re-noising is correct. The
precedent does not transfer mid-trajectory. My error.

Fix — the two modes are now actually different things:
- CONTINUE (restart sigma 0, the default): pass 2 resumes from exactly the
  state pass 1 handed over. Passing that state as BOTH noise and latent_image
  collapses the CONST expression to an identity (s*x + (1-s)*x == x), so no
  noise is added at all. Cost still one full schedule.
- REWIND (restart sigma > 0): pass 1 now runs the WHOLE schedule to a finished
  clip first, the shift is applied to that, and pass 2 re-noises it upward and
  denoises down. That is the img2img recipe, and it is valid precisely because
  the input is finished. Costs a full schedule plus the tail.

Also fixed pass 2's progress offset, which restarted at pass 1's, so the bar
appeared to stall short of the end.

Two new tests reproduce the CONST arithmetic directly and assert the identity
holds in continue mode and does not in rewind mode. Their comfy stubs are now
snapshot/restored — the first version leaked into other modules and shifted the
suite off baseline (3 unrelated tests changed result). Back to baseline: 22
pre-existing failures, 272 passing.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 movie_editor/frontend/engine_settings.js |  2 +-
 samplers.py                              | 40 ++++++++---
 tests/test_anchor_shift.py               | 88 ++++++++++++++++++++++--
 3 files changed, 114 insertions(+), 16 deletions(-)

diff --git a/movie_editor/frontend/engine_settings.js b/movie_editor/frontend/engine_settings.js
index fd3ee12c..d251cd44 100644
--- a/movie_editor/frontend/engine_settings.js
+++ b/movie_editor/frontend/engine_settings.js
@@ -233,7 +233,7 @@
     { name: "anchor_shift_frames", label: "Frames to drop", kind: "int", default: 8, min: 8, max: 512, step: 8, dependsOn: "anchor_shift",
       hint: "How much of the front to drop at the shift, in real frames. 8 (one latent frame) removes just the anchor itself; more also removes the settling-in region where the shot is still visibly 'leaving' the reference still. Raise it if the opening still looks like it departed from a photo. The clip doesn't get shorter — whatever is dropped here is regrown at the end by pass 2." },
     { name: "anchor_shift_restart_sigma", label: "Pass 2 restart sigma", kind: "float", default: 0.0, min: 0.0, max: 0.999, step: 0.001, dependsOn: "anchor_shift",
-      hint: "Where pass 2 re-enters. 0 (default) continues from where pass 1 stopped, so the total cost stays one full schedule. Setting it higher than the shift sigma rewinds — pass 2 re-noises the shifted latent back up and re-denoises from there, giving more freedom to rebuild the regrown tail and blend the joint, at the cost of repeating those steps and partly overwriting what pass 1 established. Try it if the seam is visible or the new ending looks thin." },
+      hint: "Picks between the two modes. 0 (default) = CONTINUE: pass 1 stops at the shift sigma and pass 2 resumes from exactly that state with no re-noising — cost stays one full schedule. Anything above 0 = REWIND: pass 1 runs the WHOLE schedule to a finished clip, the shift is applied to that, then pass 2 re-noises it up to this sigma and denoises down. That's the standard img2img recipe and it is only valid on a finished latent, which is why pass 1 has to complete first. Rewind gives much more freedom to rebuild the regrown tail and blend the joint, and costs a full schedule plus the tail. Try it around 0.9 if continue leaves a visible seam or a thin ending." },
     { name: "anchor_shift_tail", label: "Regrown tail starts from", kind: "combo", choices: ["extend_last", "wrap", "empty"], default: "extend_last", dependsOn: "anchor_shift",
       hint: "What fills the freed end after the slide. 'extend_last' (default) repeats the final frame so pass 2 grows the new ending out of something continuous with it. 'wrap' puts the dropped head back at the end — continuous, but it re-shows the reference image at the END of the clip. 'empty' zeroes it and lets pass 2 generate freely — most freedom, most likely to drift from the rest of the shot." },
     { name: "anchor_shift_fresh_audio", label: "Regenerate audio in pass 2", kind: "bool", default: true, dependsOn: "anchor_shift",
diff --git a/samplers.py b/samplers.py
index 92005c7b..b795144c 100644
--- a/samplers.py
+++ b/samplers.py
@@ -2496,7 +2496,7 @@ class FunPackLTXAVSceneChainSampler:
                 }),
                 "anchor_shift_restart_sigma": ("FLOAT", {
                     "default": 0.0, "min": 0.0, "max": 0.999, "step": 0.001,
-                    "tooltip": "Where pass 2 re-enters the schedule. 0 (default) means 'continue from where pass 1 stopped' — the cheapest option, total cost stays one full schedule. Setting it HIGHER than anchor_shift_sigma rewinds: pass 2 re-noises the shifted latent back up to that sigma and re-denoises from there, giving the model more freedom to rebuild the regrown tail and blend the seam, at the cost of repeating those steps (and of partly overwriting what pass 1 established). Try this if the joint is visible or the regrown tail looks thin at the default.",
+                    "tooltip": "Picks between the two modes. 0 (default) = CONTINUE: pass 1 stops at the shift sigma and pass 2 resumes from exactly that state, no re-noising. Total cost stays one full schedule. Any value above 0 = REWIND: pass 1 instead runs the WHOLE schedule to a finished clip, the shift is applied to that, and pass 2 re-noises it up to this sigma and re-denoises down — the standard img2img recipe, which is only valid on a finished latent, which is why pass 1 has to complete first. Rewind gives the model far more freedom to rebuild the regrown tail and blend the joint, and costs a full schedule PLUS the tail. Try rewind (around 0.9) if continue leaves a visible seam or a thin ending.",
                 }),
                 "anchor_shift_tail": (["extend_last", "wrap", "empty"], {
                     "default": "extend_last",
@@ -2951,14 +2951,21 @@ class FunPackLTXAVSceneChainSampler:
     def _sample_chunk(self, model, sampler, sigmas, seed, cfg, positive, negative, latent,
                       pbar=None, step_offset=0, alg_guide_tail_frames=0,
                       alg_guide_blur_strength=2.0, alg_guide_blur_sigma_threshold=0.975,
-                      bounded_attention_enabled=False):
+                      bounded_attention_enabled=False, continue_from_state=False):
         if sampler is None:
             raise ValueError("sampler input is required.")
         if not isinstance(sigmas, torch.Tensor):
             raise ValueError("sigmas input must be a SIGMAS tensor.")
         latent = self._clone_latent(latent)
         samples = latent["samples"]
-        noise = comfy.sample.prepare_noise(samples, int(seed))
+        # continue_from_state: `samples` is ALREADY the noisy x at sigmas[0] (a run resumed
+        # mid-trajectory), not a clean image. comfy's CONST scaling is
+        # x = s*noise + (1-s)*latent_image, which treats latent_image as CLEAN and re-noises
+        # it — on a mid-trajectory latent that scales the picture down by (1-s) and buries it
+        # under a fresh s of noise. Passing the state as BOTH terms makes the expression
+        # collapse to an identity (s*x + (1-s)*x == x), so sampling resumes from exactly the
+        # state we hand it. Only correct when the caller really is mid-trajectory.
+        noise = samples if continue_from_state else comfy.sample.prepare_noise(samples, int(seed))
 
         def _progress_cb(step, _denoised, _x, _total_steps):
             if pbar is not None:
@@ -3062,16 +3069,21 @@ class FunPackLTXAVSceneChainSampler:
             return None  # threshold above the first sigma, or not reached at all
         restart = float(restart_sigma)
         if restart <= 0:
+            # CONTINUE: pass 1 stops at the cut and pass 2 resumes from that exact state.
+            # Pass 2 must NOT re-noise (see _sample_chunk's continue_from_state).
+            first, second, resume = sigmas[:cut + 1], sigmas[cut:], True
             start = cut
         else:
+            # REWIND: pass 2 re-noises to a HIGHER sigma, which is only meaningful on a CLEAN
+            # latent — so pass 1 runs the whole schedule first and hands over a finished clip.
+            # Same shape as segmented detailing's stage-2 tail. Costs a full schedule + tail.
             start = _first_at_or_below(restart)
             if start is None:
                 return None
-        first = sigmas[:cut + 1]
-        second = sigmas[start:]
+            first, second, resume = sigmas, sigmas[start:], False
         if first.numel() < 2 or second.numel() < 2:
             return None
-        return first, second, vals[cut], vals[start]
+        return first, second, vals[cut], vals[start], resume
 
     def _anchor_shift_latent(self, latent, drop, tail_mode, fresh_audio):
         """Slide the video stream left by `drop` latent frames and refill the freed tail.
@@ -5472,20 +5484,26 @@ class FunPackLTXAVSceneChainSampler:
                     if _shift_split is None:
                         run_mechanisms.append(f"anchor_shift(SKIPPED: {_reason})")
                 if _shift_split is not None:
-                    _sig_a, _sig_b, _cut_at, _restart_at = _shift_split
+                    _sig_a, _sig_b, _cut_at, _restart_at, _resume = _shift_split
                     _pass1 = self._sample_chunk(
                         model, sampler, _sig_a, scene_seed, cfg, scene_positive, scene_negative,
                         chunk, **_sample_kwargs)
                     _shifted, _dropped = self._anchor_shift_latent(
                         _pass1, _shift_drop, anchor_shift_tail, anchor_shift_fresh_audio)
-                    # Fresh noise for pass 2: reusing scene_seed's field would re-apply the
-                    # exact noise pass 1 just resolved, against content that has moved.
+                    # Continue mode resumes from the handed-over state (no re-noise, so the
+                    # seed is irrelevant); rewind mode re-noises a finished clip, where fresh
+                    # noise is wanted — reusing scene_seed there would re-apply the exact field
+                    # pass 1 just resolved, against content that has since moved.
+                    _kw2 = dict(_sample_kwargs)
+                    _kw2["step_offset"] = _sample_kwargs["step_offset"] + (_sig_a.numel() - 1)
+                    _kw2["continue_from_state"] = _resume
                     sampled = self._sample_chunk(
                         model, sampler, _sig_b, scene_seed + 4242, cfg, scene_positive,
-                        scene_negative, _shifted, **_sample_kwargs)
+                        scene_negative, _shifted, **_kw2)
                     _pinned_n = self._anchor_pinned_frames(chunk)
                     run_mechanisms.append(
-                        f"anchor_shift(cut@{_cut_at:g} restart@{_restart_at:g}, "
+                        f"anchor_shift({'continue' if _resume else 'rewind'} "
+                        f"cut@{_cut_at:g} restart@{_restart_at:g}, "
                         f"dropped {_dropped} of {_pinned_n} pinned latent frames, "
                         f"tail={anchor_shift_tail}"
                         f"{', fresh audio' if anchor_shift_fresh_audio else ''})")
diff --git a/tests/test_anchor_shift.py b/tests/test_anchor_shift.py
index d6304678..2a595b88 100644
--- a/tests/test_anchor_shift.py
+++ b/tests/test_anchor_shift.py
@@ -14,6 +14,7 @@ import sys
 import types
 from pathlib import Path
 
+import pytest
 import torch
 
 sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
@@ -47,19 +48,30 @@ def _latent(frames=10, audio=True):
 
 # ── schedule splitting ──────────────────────────────────────────────────────
 
-def test_split_cuts_at_the_requested_sigma_and_continues_by_default():
-    first, second, cut_at, restart_at = _node()._anchor_shift_split_sigmas(SCHEDULE, 0.909, 0.0)
+def test_continue_mode_stops_at_the_cut_and_resumes_from_that_state():
+    first, second, cut_at, restart_at, resume = _node()._anchor_shift_split_sigmas(
+        SCHEDULE, 0.909, 0.0)
     # float32: the schedule stores 0.909 as 0.90899997, so compare loosely.
     assert abs(cut_at - 0.909) < 1e-5 and abs(restart_at - 0.909) < 1e-5
     # pass 1 ends ON the cut sigma; pass 2 resumes from it, so no step is run twice.
     assert [round(v, 3) for v in first.tolist()] == [1.0, 0.975, 0.909]
     assert [round(v, 3) for v in second.tolist()] == [0.909, 0.725, 0.422, 0.0]
+    # resume=True is load-bearing: pass 2 receives a MID-TRAJECTORY latent, and comfy's
+    # CONST scaling (x = s*noise + (1-s)*latent) would otherwise treat it as a clean image
+    # and re-noise it — scaling the picture to (1-s) under a fresh s of noise. That is the
+    # bug that made the first live run come out under-denoised.
+    assert resume is True
 
 
-def test_restart_sigma_above_the_cut_rewinds_pass_two():
-    first, second, cut_at, restart_at = _node()._anchor_shift_split_sigmas(SCHEDULE, 0.725, 0.975)
+def test_rewind_mode_runs_pass_one_to_completion_first():
+    """A re-noise to a HIGHER sigma is only meaningful on a clean latent, so rewind mode
+    must hand pass 2 a finished clip — not a mid-trajectory one."""
+    first, second, cut_at, restart_at, resume = _node()._anchor_shift_split_sigmas(
+        SCHEDULE, 0.725, 0.975)
     assert abs(cut_at - 0.725) < 1e-5 and abs(restart_at - 0.975) < 1e-5
+    assert [round(v, 3) for v in first.tolist()] == [1.0, 0.975, 0.909, 0.725, 0.422, 0.0]
     assert [round(v, 3) for v in second.tolist()] == [0.975, 0.909, 0.725, 0.422, 0.0]
+    assert resume is False  # clean input -> re-noising is correct here
 
 
 def test_split_refuses_when_a_pass_would_have_no_steps():
@@ -154,3 +166,71 @@ def test_pinned_frames_is_zero_for_a_real_t2v_scene():
     assert n._anchor_pinned_frames({"samples": video, "noise_mask": torch.ones(1, 4, 6, 2, 2)}) == 0
     assert n._anchor_pinned_frames({"samples": video}) == 0  # no mask at all
     assert n._anchor_pinned_frames({"samples": None}) == 0   # unreadable -> refuse, don't raise
+
+
+# ── the re-noise bug this feature shipped with, locked down ─────────────────
+
+@pytest.fixture
+def capture_sample_custom():
+    """Stub comfy.sample so we can see exactly what noise/latent the sampler receives.
+
+    Snapshot/restore, because these comfy stubs are SHARED module objects across every test
+    module — leaving mutations behind changes other files' results depending on collection
+    order (the same trap test_detailing.py hit with comfy.nested_tensor).
+    """
+    mod = sys.modules["comfy.sample"]
+    comfy_mod = sys.modules["comfy"]
+    saved = (getattr(mod, "prepare_noise", None), getattr(mod, "sample_custom", None),
+             getattr(comfy_mod, "sample", None))
+    seen = {}
+
+    def prepare_noise(samples, seed, *a, **k):
+        return torch.full_like(samples, 7.0)  # unmistakably "fresh noise"
+
+    def sample_custom(model, noise, cfg, sampler, sigmas, pos, neg, latent_image, **kw):
+        seen["noise"] = noise
+        seen["latent_image"] = latent_image
+        return latent_image
+
+    mod.prepare_noise = prepare_noise
+    mod.sample_custom = sample_custom
+    sys.modules["comfy"].sample = mod  # attribute access, not just sys.modules
+    yield seen
+    for name, val in (("prepare_noise", saved[0]), ("sample_custom", saved[1])):
+        if val is None:
+            delattr(mod, name)
+        else:
+            setattr(mod, name, val)
+    if saved[2] is None:
+        delattr(comfy_mod, "sample")
+    else:
+        comfy_mod.sample = saved[2]
+
+
+def _const_noise_scaling(sigma, noise, latent_image):
+    """comfy's CONST rule, verbatim: x = s*noise + (1-s)*latent_image."""
+    return sigma * noise + (1.0 - sigma) * latent_image
+
+
+def test_continue_from_state_makes_const_scaling_an_identity(capture_sample_custom):
+    """The real fix. Pass 2 gets a MID-TRAJECTORY latent; handing it as both terms makes
+    comfy's scaling collapse to x, so sampling resumes exactly where pass 1 stopped."""
+    seen = capture_sample_custom
+    state = torch.randn(1, 4, 5, 2, 2)
+    _node()._sample_chunk(object(), object(), torch.tensor([0.725, 0.422, 0.0]), 1, 1.0,
+                          [], [], {"samples": state}, continue_from_state=True)
+    assert torch.equal(seen["noise"], seen["latent_image"])
+    resumed = _const_noise_scaling(0.725, seen["noise"], seen["latent_image"])
+    assert torch.allclose(resumed, state, atol=1e-6)
+
+
+def test_without_continue_from_state_the_latent_is_renoised(capture_sample_custom):
+    """The other mode, and the shape of the original bug: fresh noise is mixed in and the
+    picture is scaled to (1-sigma). Correct for a CLEAN input, wrong mid-trajectory."""
+    seen = capture_sample_custom
+    clean = torch.randn(1, 4, 5, 2, 2)
+    _node()._sample_chunk(object(), object(), torch.tensor([0.725, 0.422, 0.0]), 1, 1.0,
+                          [], [], {"samples": clean}, continue_from_state=False)
+    assert not torch.equal(seen["noise"], seen["latent_image"])
+    entered = _const_noise_scaling(0.725, seen["noise"], seen["latent_image"])
+    assert not torch.allclose(entered, clean, atol=1e-3)

From f607425ea995d1b3ea77f7a8fac61ff80e532dc9 Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Wed, 29 Jul 2026 22:35:59 +0300
Subject: [PATCH 12/29] anchor_shift: say when rewind mode ignores the shift
 sigma

Rewind mode runs pass 1 over the whole schedule (so the re-noise gets a clean
latent), which means anchor_shift_sigma has no effect there at all. A knob that
silently does nothing reads as broken - the scene report now names it and says
to set restart sigma to 0 if you want the cut point to matter. Noted in both
tooltips too.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 movie_editor/frontend/engine_settings.js |  2 +-
 samplers.py                              | 11 ++++++++++-
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/movie_editor/frontend/engine_settings.js b/movie_editor/frontend/engine_settings.js
index d251cd44..b529dede 100644
--- a/movie_editor/frontend/engine_settings.js
+++ b/movie_editor/frontend/engine_settings.js
@@ -229,7 +229,7 @@
     { name: "anchor_shift", label: "Anchor shift (fake t2v)", kind: "bool", default: false,
       hint: "EXPERIMENTAL: keep the real, untouched i2v anchor — then delete it from the clip. The anchor is a pinned frame at position 0, so it holds character detail, style and composition better than anything that weakens it on the way in (ALG blurs it and loses detail; Best-FaceID tokens approximate it and lose some too), but it is also literally the first frame you see. This runs pass 1 down to the sigma below with the anchor pinned as normal, drops the first frames and slides everything left (clip length unchanged — no extra frames generated), then finishes the schedule with the pin gone. The result is an i2v generation that reads as t2v. Pass 2 re-enters through the model's own noise scaling, which is what keeps the shifted latent on-manifold. Skipped on continuation scenes and on scenes carrying guide frames or JoyAI audio memory, with the reason in the scene report. UNVALIDATED LIVE." },
     { name: "anchor_shift_sigma", label: "Shift at sigma", kind: "float", default: 0.909, min: 0.05, max: 0.999, step: 0.001, dependsOn: "anchor_shift",
-      hint: "The knob this feature exists to let you tune. Pass 1 runs until the schedule first reaches this sigma, then the shift happens. 0.909 is where structure actually starts forming on the distilled schedule (1.0 and 0.975 are near-pure noise and carry almost no signal), so it's the earliest cut where the anchor has plausibly transferred anything — a starting guess, not a measured value. Higher = released sooner and cheaper, but the reference may never have landed. Lower = held longer, but more of pass 1's picture is thrown away by the slide and fewer steps remain to repair it." },
+      hint: "The knob this feature exists to let you tune — in continue mode. (Rewind mode, i.e. any non-zero restart sigma below, runs pass 1 over the whole schedule and ignores this; the scene report says so.) Pass 1 runs until the schedule first reaches this sigma, then the shift happens. 0.909 is where structure actually starts forming on the distilled schedule (1.0 and 0.975 are near-pure noise and carry almost no signal), so it's the earliest cut where the anchor has plausibly transferred anything — a starting guess, not a measured value. Higher = released sooner and cheaper, but the reference may never have landed. Lower = held longer, but more of pass 1's picture is thrown away by the slide and fewer steps remain to repair it." },
     { name: "anchor_shift_frames", label: "Frames to drop", kind: "int", default: 8, min: 8, max: 512, step: 8, dependsOn: "anchor_shift",
       hint: "How much of the front to drop at the shift, in real frames. 8 (one latent frame) removes just the anchor itself; more also removes the settling-in region where the shot is still visibly 'leaving' the reference still. Raise it if the opening still looks like it departed from a photo. The clip doesn't get shorter — whatever is dropped here is regrown at the end by pass 2." },
     { name: "anchor_shift_restart_sigma", label: "Pass 2 restart sigma", kind: "float", default: 0.0, min: 0.0, max: 0.999, step: 0.001, dependsOn: "anchor_shift",
diff --git a/samplers.py b/samplers.py
index b795144c..8007c61b 100644
--- a/samplers.py
+++ b/samplers.py
@@ -2488,7 +2488,7 @@ class FunPackLTXAVSceneChainSampler:
                 }),
                 "anchor_shift_sigma": ("FLOAT", {
                     "default": 0.909, "min": 0.05, "max": 0.999, "step": 0.001,
-                    "tooltip": "Sigma at which pass 1 stops and the shift happens — the knob this whole feature exists to let you tune. Pass 1 runs until the schedule first reaches a sigma at or below this. 0.909 is the step where structure actually starts forming on the LTX distilled schedule (1.0 and 0.975 are the near-pure-noise plateau and carry almost no signal), so it is the earliest cut where the anchor has plausibly transferred anything — but it is a starting guess, not a measured value. Higher = anchor released sooner, cheaper, more likely the reference never really landed. Lower = anchor held longer, more of pass 1's picture is thrown away by the shift and fewer steps remain to repair it. If the schedule never reaches this sigma, the pass is skipped with a note.",
+                    "tooltip": "Sigma at which pass 1 stops and the shift happens — the knob this whole feature exists to let you tune. ONLY used in continue mode (anchor_shift_restart_sigma=0); rewind mode runs pass 1 over the whole schedule and ignores this, which the scene report will tell you. Pass 1 runs until the schedule first reaches a sigma at or below this. 0.909 is the step where structure actually starts forming on the LTX distilled schedule (1.0 and 0.975 are the near-pure-noise plateau and carry almost no signal), so it is the earliest cut where the anchor has plausibly transferred anything — but it is a starting guess, not a measured value. Higher = anchor released sooner, cheaper, more likely the reference never really landed. Lower = anchor held longer, more of pass 1's picture is thrown away by the shift and fewer steps remain to repair it. If the schedule never reaches this sigma, the pass is skipped with a note.",
                 }),
                 "anchor_shift_frames": ("INT", {
                     "default": 8, "min": 8, "max": 512, "step": 8,
@@ -5507,6 +5507,15 @@ class FunPackLTXAVSceneChainSampler:
                         f"dropped {_dropped} of {_pinned_n} pinned latent frames, "
                         f"tail={anchor_shift_tail}"
                         f"{', fresh audio' if anchor_shift_fresh_audio else ''})")
+                    if not _resume:
+                        # In rewind mode pass 1 runs the whole schedule, so anchor_shift_sigma
+                        # never gets used. A knob that silently does nothing reads as broken —
+                        # say so, and say what to set to make it matter again.
+                        run_mechanisms.append(
+                            f"anchor_shift NOTE: rewind mode ignores anchor_shift_sigma"
+                            f"={anchor_shift_sigma:g} (pass 1 runs the full schedule so the "
+                            f"re-noise has a clean latent). Set anchor_shift_restart_sigma=0 "
+                            f"for continue mode, where the shift sigma is the cut point.")
                     if _dropped < _pinned_n:
                         # Part of the anchor survives the slide and stays visible in the clip —
                         # the one outcome this feature exists to prevent, so name the fix.

From a106d3ae2d045b73bd0455d016f6525d11280faa Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Wed, 29 Jul 2026 22:42:36 +0300
Subject: [PATCH 13/29] anchor_shift: record the frames-to-drop finding in both
 tooltips

Live result: 48 frames (6 latent) was needed for a quick-cut prompt to open
strictly on the requested action - the default 8 removes only the anchor and
leaves the settling-in stretch where the shot is still departing the reference
still and nothing happens yet.

Cited in the tooltips as a starting point FOR THIS PIPELINE (768x768x305@30 i2v
chain, quick-cut prompt), not a universal default, and the node default stays
8 - one workflow's tuned value is not evidence for another's.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 movie_editor/frontend/engine_settings.js | 2 +-
 samplers.py                              | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/movie_editor/frontend/engine_settings.js b/movie_editor/frontend/engine_settings.js
index b529dede..5ac0df87 100644
--- a/movie_editor/frontend/engine_settings.js
+++ b/movie_editor/frontend/engine_settings.js
@@ -231,7 +231,7 @@
     { name: "anchor_shift_sigma", label: "Shift at sigma", kind: "float", default: 0.909, min: 0.05, max: 0.999, step: 0.001, dependsOn: "anchor_shift",
       hint: "The knob this feature exists to let you tune — in continue mode. (Rewind mode, i.e. any non-zero restart sigma below, runs pass 1 over the whole schedule and ignores this; the scene report says so.) Pass 1 runs until the schedule first reaches this sigma, then the shift happens. 0.909 is where structure actually starts forming on the distilled schedule (1.0 and 0.975 are near-pure noise and carry almost no signal), so it's the earliest cut where the anchor has plausibly transferred anything — a starting guess, not a measured value. Higher = released sooner and cheaper, but the reference may never have landed. Lower = held longer, but more of pass 1's picture is thrown away by the slide and fewer steps remain to repair it." },
     { name: "anchor_shift_frames", label: "Frames to drop", kind: "int", default: 8, min: 8, max: 512, step: 8, dependsOn: "anchor_shift",
-      hint: "How much of the front to drop at the shift, in real frames. 8 (one latent frame) removes just the anchor itself; more also removes the settling-in region where the shot is still visibly 'leaving' the reference still. Raise it if the opening still looks like it departed from a photo. The clip doesn't get shorter — whatever is dropped here is regrown at the end by pass 2." },
+      hint: "How much of the front to drop at the shift, in real frames. 8 (one latent frame) removes just the anchor itself, which is usually not enough — the anchor is followed by a settling-in stretch where the shot is still leaving the reference still and little is happening, and on a prompt asking for immediate action that dead time is exactly what you want gone. 48 was the value that worked on a 768×768×305@30 chain with a quick-cut prompt; treat that as a starting point for this pipeline rather than a universal default. Raise it if the opening still looks like it departed from a photo. The clip doesn't get shorter — whatever is dropped here is regrown at the end by pass 2." },
     { name: "anchor_shift_restart_sigma", label: "Pass 2 restart sigma", kind: "float", default: 0.0, min: 0.0, max: 0.999, step: 0.001, dependsOn: "anchor_shift",
       hint: "Picks between the two modes. 0 (default) = CONTINUE: pass 1 stops at the shift sigma and pass 2 resumes from exactly that state with no re-noising — cost stays one full schedule. Anything above 0 = REWIND: pass 1 runs the WHOLE schedule to a finished clip, the shift is applied to that, then pass 2 re-noises it up to this sigma and denoises down. That's the standard img2img recipe and it is only valid on a finished latent, which is why pass 1 has to complete first. Rewind gives much more freedom to rebuild the regrown tail and blend the joint, and costs a full schedule plus the tail. Try it around 0.9 if continue leaves a visible seam or a thin ending." },
     { name: "anchor_shift_tail", label: "Regrown tail starts from", kind: "combo", choices: ["extend_last", "wrap", "empty"], default: "extend_last", dependsOn: "anchor_shift",
diff --git a/samplers.py b/samplers.py
index 8007c61b..0bbc3474 100644
--- a/samplers.py
+++ b/samplers.py
@@ -2492,7 +2492,7 @@ class FunPackLTXAVSceneChainSampler:
                 }),
                 "anchor_shift_frames": ("INT", {
                     "default": 8, "min": 8, "max": 512, "step": 8,
-                    "tooltip": "How many frames to drop off the front at the shift, in real frames (converted to latent frames with the VAE's own time scale). One latent frame — 8 real frames at the standard scale — removes just the anchor itself. More also removes the settling-in region right after it, where the clip is still visibly 'leaving' the reference image; raise this if the opening still looks like it is departing from a still rather than already in motion. The clip does not get shorter: whatever is dropped here is regrown at the end by pass 2.",
+                    "tooltip": "How many frames to drop off the front at the shift, in real frames (converted to latent frames with the VAE's own time scale). One latent frame — 8 real frames at the standard scale — removes just the anchor itself, which is usually NOT enough: the anchor is followed by a settling-in stretch where the shot is still leaving the reference still and little is happening yet, and on a prompt that asks for immediate action that dead time is exactly what you want gone (48 was the value that worked on a 768x768x305@30 i2v chain with a quick-cut prompt — a starting point for this pipeline, not a universal default). More also removes the settling-in region right after it, where the clip is still visibly 'leaving' the reference image; raise this if the opening still looks like it is departing from a still rather than already in motion. The clip does not get shorter: whatever is dropped here is regrown at the end by pass 2.",
                 }),
                 "anchor_shift_restart_sigma": ("FLOAT", {
                     "default": 0.0, "min": 0.0, "max": 0.999, "step": 0.001,

From 2b26c89ebb145676097910ca7530878fb739cb86 Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Fri, 31 Jul 2026 12:31:35 +0300
Subject: [PATCH 14/29] =?UTF-8?q?anchor=5Fshift:=20restore=20the=20design?=
 =?UTF-8?q?=20=E2=80=94=20pass=201=20always=20stops=20at=20the=20shift=20s?=
 =?UTF-8?q?igma?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Reported by the user from a scene report: with a restart sigma set, the log said
anchor_shift_sigma was ignored. It was. That is my doing, and it should never have
shipped that way.

The original implementation did what was designed: cut pass 1 at anchor_shift_sigma,
shift, restart pass 2 at anchor_shift_restart_sigma, the two independent. It produced
noise artifacts because pass 2 re-entered through comfy's CONST scaling, which assumes
a CLEAN latent. There were two ways to fix that — write a re-noise that is valid on a
half-denoised latent, or make pass 1 always run to completion so the input is clean.
327f544 took the second. That silently reduced a two-knob design to one knob per mode,
was described in the commit as the modes being "genuinely different" rather than as a
parameter being removed, and left the user sweeping a value that could not do anything.

This does the work that should have been done then.

_anchor_shift_renoise: given x_a mid-trajectory and a target b >= a,

    x_b = alpha*x_a + beta*n,  alpha = (1-b)/(1-a),  beta = sqrt(b^2 - (a*alpha)^2)

alpha reproduces x0's coefficient exactly, beta tops the noise term back up to b, so
the result lands on the manifold the model expects at b. Both old modes are special
cases of the one formula: b == a gives alpha=1, beta=0 (an exact resume) and a == 0
gives comfy's own fresh-noise scaling. beta has a real root only when b >= a, which is
why a restart BELOW the cut is now refused with a message saying why — noise can be
added back, never removed.

Streams wiped by anchor_shift_fresh_audio are not mid-trajectory, so they re-enter at
a=0 and get the full b*n a from-scratch run starts from, not a partial top-up of a
latent that no longer exists.

Continue mode (restart 0, the validated config) is unchanged and still bit-identical:
no re-noise, cost one full schedule. Rewind now costs the cut plus the restart tail
rather than a whole schedule plus the tail.

The scene-report NOTE about an ignored parameter is gone, because nothing is ignored.
Tooltips in samplers.py and engine_settings.js (Editor + Easy Gen share it) rewritten.

Tests: the old test asserting pass 1 runs to completion is replaced by one asserting it
stops at the cut; plus the re-noise identity at b==a, equivalence with comfy's scaling
at a==0, the coefficient/variance invariants on a synthetic latent with known x0 and
eps, reset-stream handling, non-mutation, and the below-the-cut refusal. Suite at
baseline: 22 pre-existing failures, 279 passing.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 movie_editor/frontend/engine_settings.js |   6 +-
 samplers.py                              | 110 +++++++++++++-----
 tests/test_anchor_shift.py               | 138 ++++++++++++++++++++++-
 3 files changed, 216 insertions(+), 38 deletions(-)

diff --git a/movie_editor/frontend/engine_settings.js b/movie_editor/frontend/engine_settings.js
index 5ac0df87..6e646bad 100644
--- a/movie_editor/frontend/engine_settings.js
+++ b/movie_editor/frontend/engine_settings.js
@@ -227,13 +227,13 @@
       deps: [{ name: "segmented_detailing" }, { name: "detail_mode", value: "repair" }],
       hint: "How much noise the crop gets re-noised to before its 3-step refine (0.85 is the official LTX 2.3 recipe's own value). Higher = more freedom to genuinely reconstruct the region (fix bad anatomy), risking drift from the surrounding frame; lower = closer to a plain upscale — looks 'detailed' as interpolation but doesn't actually repair it. If the result looks upscaled but not corrected, raise this. Only used in 'repair' mode." },
     { name: "anchor_shift", label: "Anchor shift (fake t2v)", kind: "bool", default: false,
-      hint: "EXPERIMENTAL: keep the real, untouched i2v anchor — then delete it from the clip. The anchor is a pinned frame at position 0, so it holds character detail, style and composition better than anything that weakens it on the way in (ALG blurs it and loses detail; Best-FaceID tokens approximate it and lose some too), but it is also literally the first frame you see. This runs pass 1 down to the sigma below with the anchor pinned as normal, drops the first frames and slides everything left (clip length unchanged — no extra frames generated), then finishes the schedule with the pin gone. The result is an i2v generation that reads as t2v. Pass 2 re-enters through the model's own noise scaling, which is what keeps the shifted latent on-manifold. Skipped on continuation scenes and on scenes carrying guide frames or JoyAI audio memory, with the reason in the scene report. UNVALIDATED LIVE." },
+      hint: "EXPERIMENTAL: keep the real, untouched i2v anchor — then delete it from the clip. The anchor is a pinned frame at position 0, so it holds character detail, style and composition better than anything that weakens it on the way in (ALG blurs it and loses detail; Best-FaceID tokens approximate it and lose some too), but it is also literally the first frame you see. This runs pass 1 down to the sigma below with the anchor pinned as normal, drops the first frames and slides everything left (clip length unchanged — no extra frames generated), then finishes the schedule with the pin gone. The result is an i2v generation that reads as t2v. Pass 2 always re-enters at the exact latent state for its first sigma, which is what keeps the shifted latent on-manifold. Skipped on continuation scenes and on scenes carrying guide frames or JoyAI audio memory, with the reason in the scene report. Validated live in continue mode." },
     { name: "anchor_shift_sigma", label: "Shift at sigma", kind: "float", default: 0.909, min: 0.05, max: 0.999, step: 0.001, dependsOn: "anchor_shift",
-      hint: "The knob this feature exists to let you tune — in continue mode. (Rewind mode, i.e. any non-zero restart sigma below, runs pass 1 over the whole schedule and ignores this; the scene report says so.) Pass 1 runs until the schedule first reaches this sigma, then the shift happens. 0.909 is where structure actually starts forming on the distilled schedule (1.0 and 0.975 are near-pure noise and carry almost no signal), so it's the earliest cut where the anchor has plausibly transferred anything — a starting guess, not a measured value. Higher = released sooner and cheaper, but the reference may never have landed. Lower = held longer, but more of pass 1's picture is thrown away by the slide and fewer steps remain to repair it." },
+      hint: "The knob this feature exists to let you tune, in both modes. Pass 1 runs until the schedule first reaches this sigma, then the shift happens. 0.909 is where structure actually starts forming on the distilled schedule (1.0 and 0.975 are near-pure noise and carry almost no signal), so it's the earliest cut where the anchor has plausibly transferred anything — a starting guess, not a measured value. Higher = released sooner and cheaper, but the reference may never have landed. Lower = held longer, but more of pass 1's picture is thrown away by the slide and fewer steps remain to repair it." },
     { name: "anchor_shift_frames", label: "Frames to drop", kind: "int", default: 8, min: 8, max: 512, step: 8, dependsOn: "anchor_shift",
       hint: "How much of the front to drop at the shift, in real frames. 8 (one latent frame) removes just the anchor itself, which is usually not enough — the anchor is followed by a settling-in stretch where the shot is still leaving the reference still and little is happening, and on a prompt asking for immediate action that dead time is exactly what you want gone. 48 was the value that worked on a 768×768×305@30 chain with a quick-cut prompt; treat that as a starting point for this pipeline rather than a universal default. Raise it if the opening still looks like it departed from a photo. The clip doesn't get shorter — whatever is dropped here is regrown at the end by pass 2." },
     { name: "anchor_shift_restart_sigma", label: "Pass 2 restart sigma", kind: "float", default: 0.0, min: 0.0, max: 0.999, step: 0.001, dependsOn: "anchor_shift",
-      hint: "Picks between the two modes. 0 (default) = CONTINUE: pass 1 stops at the shift sigma and pass 2 resumes from exactly that state with no re-noising — cost stays one full schedule. Anything above 0 = REWIND: pass 1 runs the WHOLE schedule to a finished clip, the shift is applied to that, then pass 2 re-noises it up to this sigma and denoises down. That's the standard img2img recipe and it is only valid on a finished latent, which is why pass 1 has to complete first. Rewind gives much more freedom to rebuild the regrown tail and blend the joint, and costs a full schedule plus the tail. Try it around 0.9 if continue leaves a visible seam or a thin ending." },
+      hint: "Where pass 2 re-enters the schedule after the shift. Pass 1 always stops at the shift sigma either way — this only decides where the second half picks up. 0 (default) = CONTINUE: resume from exactly the state pass 1 handed over, nothing added, cost stays one full schedule. Above the shift sigma = REWIND: the shifted latent is re-noised from the cut back up to this sigma, then denoised down again — much more freedom to rebuild the regrown tail and blend the joint, at the cost of repeating those steps and partly overwriting what pass 1 established. The re-noise is exact for a half-denoised latent (it rebuilds the state at the higher sigma from what pass 1 produced plus a matched top-up of fresh noise), not the naive img2img re-noise that caused the under-denoising in the first live run. BELOW the shift sigma is refused: noise can be added back, never removed. Try a step or two above the cut if continue leaves a visible seam or a thin ending." },
     { name: "anchor_shift_tail", label: "Regrown tail starts from", kind: "combo", choices: ["extend_last", "wrap", "empty"], default: "extend_last", dependsOn: "anchor_shift",
       hint: "What fills the freed end after the slide. 'extend_last' (default) repeats the final frame so pass 2 grows the new ending out of something continuous with it. 'wrap' puts the dropped head back at the end — continuous, but it re-shows the reference image at the END of the clip. 'empty' zeroes it and lets pass 2 generate freely — most freedom, most likely to drift from the rest of the shot." },
     { name: "anchor_shift_fresh_audio", label: "Regenerate audio in pass 2", kind: "bool", default: true, dependsOn: "anchor_shift",
diff --git a/samplers.py b/samplers.py
index 0bbc3474..872eb6bc 100644
--- a/samplers.py
+++ b/samplers.py
@@ -2484,11 +2484,11 @@ class FunPackLTXAVSceneChainSampler:
                 }),
                 "anchor_shift": ("BOOLEAN", {
                     "default": False,
-                    "tooltip": "EXPERIMENTAL: let the i2v anchor condition the scene, then delete it from the clip. The anchor is a pinned latent frame at position 0 — it holds identity/style/composition all the way down the schedule, and it is also literally the first frame you see, so every i2v scene opens on the exact reference still. This splits the schedule: pass 1 runs down to anchor_shift_sigma with the anchor pinned as usual, then the first anchor_shift_frames frames are DROPPED and everything slides left (clip length unchanged — no extra frames are generated), then pass 2 finishes the schedule on the shifted latent with the pin gone. Pass 2 re-enters through comfy's CONST noise scaling, which puts the shifted latent back on the rectified-flow manifold — the reason this is two passes rather than a roll between steps. The whole experiment is WHERE to cut: above ~0.909 nothing has formed yet, so the anchor gets discarded before it has transferred anything; too low and pass 2 has no steps left to heal the seam. Off by default. UNVALIDATED LIVE.",
+                    "tooltip": "EXPERIMENTAL: let the i2v anchor condition the scene, then delete it from the clip. The anchor is a pinned latent frame at position 0 — it holds identity/style/composition all the way down the schedule, and it is also literally the first frame you see, so every i2v scene opens on the exact reference still. This splits the schedule: pass 1 runs down to anchor_shift_sigma with the anchor pinned as usual, then the first anchor_shift_frames frames are DROPPED and everything slides left (clip length unchanged — no extra frames are generated), then pass 2 finishes the schedule on the shifted latent with the pin gone. Pass 2 always re-enters at the exact latent state for its first sigma — resumed as-is, or re-noised up to anchor_shift_restart_sigma first — which keeps it on the rectified-flow manifold and is the reason this is two passes rather than a roll between steps. The whole experiment is WHERE to cut: above ~0.909 nothing has formed yet, so the anchor gets discarded before it has transferred anything; too low and pass 2 has no steps left to heal the seam. Off by default. Validated live in continue mode.",
                 }),
                 "anchor_shift_sigma": ("FLOAT", {
                     "default": 0.909, "min": 0.05, "max": 0.999, "step": 0.001,
-                    "tooltip": "Sigma at which pass 1 stops and the shift happens — the knob this whole feature exists to let you tune. ONLY used in continue mode (anchor_shift_restart_sigma=0); rewind mode runs pass 1 over the whole schedule and ignores this, which the scene report will tell you. Pass 1 runs until the schedule first reaches a sigma at or below this. 0.909 is the step where structure actually starts forming on the LTX distilled schedule (1.0 and 0.975 are the near-pure-noise plateau and carry almost no signal), so it is the earliest cut where the anchor has plausibly transferred anything — but it is a starting guess, not a measured value. Higher = anchor released sooner, cheaper, more likely the reference never really landed. Lower = anchor held longer, more of pass 1's picture is thrown away by the shift and fewer steps remain to repair it. If the schedule never reaches this sigma, the pass is skipped with a note.",
+                    "tooltip": "Sigma at which pass 1 stops and the shift happens — the knob this whole feature exists to let you tune, and it applies in BOTH modes. Pass 1 runs until the schedule first reaches a sigma at or below this. 0.909 is the step where structure actually starts forming on the LTX distilled schedule (1.0 and 0.975 are the near-pure-noise plateau and carry almost no signal), so it is the earliest cut where the anchor has plausibly transferred anything — but it is a starting guess, not a measured value. Higher = anchor released sooner, cheaper, more likely the reference never really landed. Lower = anchor held longer, more of pass 1's picture is thrown away by the shift and fewer steps remain to repair it. If the schedule never reaches this sigma, the pass is skipped with a note.",
                 }),
                 "anchor_shift_frames": ("INT", {
                     "default": 8, "min": 8, "max": 512, "step": 8,
@@ -2496,7 +2496,7 @@ class FunPackLTXAVSceneChainSampler:
                 }),
                 "anchor_shift_restart_sigma": ("FLOAT", {
                     "default": 0.0, "min": 0.0, "max": 0.999, "step": 0.001,
-                    "tooltip": "Picks between the two modes. 0 (default) = CONTINUE: pass 1 stops at the shift sigma and pass 2 resumes from exactly that state, no re-noising. Total cost stays one full schedule. Any value above 0 = REWIND: pass 1 instead runs the WHOLE schedule to a finished clip, the shift is applied to that, and pass 2 re-noises it up to this sigma and re-denoises down — the standard img2img recipe, which is only valid on a finished latent, which is why pass 1 has to complete first. Rewind gives the model far more freedom to rebuild the regrown tail and blend the joint, and costs a full schedule PLUS the tail. Try rewind (around 0.9) if continue leaves a visible seam or a thin ending.",
+                    "tooltip": "Where pass 2 re-enters the schedule after the shift. Pass 1 always stops at anchor_shift_sigma either way — this only decides where the second half picks up. 0 (default) = CONTINUE: resume from exactly the state pass 1 handed over, nothing added, total cost stays one full schedule. A value ABOVE anchor_shift_sigma = REWIND: the shifted latent is re-noised from the cut back up to this sigma, then denoised down again, giving the model far more freedom to rebuild the regrown tail and blend the joint — at the cost of repeating those steps (and of partly overwriting what pass 1 established). The re-noise is exact for a mid-trajectory latent (it rebuilds x at the higher sigma from the latent it already has plus a matched top-up of fresh noise), NOT the naive img2img re-noise, which assumes a finished image and is what caused the under-denoising in the first live run. A value BELOW anchor_shift_sigma is refused: noise can be added back, never removed. Try rewind (a step or two above the cut) if continue leaves a visible seam or a thin ending.",
                 }),
                 "anchor_shift_tail": (["extend_last", "wrap", "empty"], {
                     "default": "extend_last",
@@ -3047,11 +3047,16 @@ class FunPackLTXAVSceneChainSampler:
     def _anchor_shift_split_sigmas(self, sigmas, shift_sigma, restart_sigma):
         """Cut the schedule into (pass 1, pass 2), or return None if it cannot be cut.
 
-        pass 1 runs from the top down to the first sigma at or below shift_sigma; pass 2
+        pass 1 ALWAYS runs from the top down to the first sigma at or below shift_sigma —
+        that cut is the whole point of the feature and nothing else may override it. pass 2
         starts at the first sigma at or below restart_sigma (restart_sigma <= 0 means
-        "continue from where pass 1 stopped") and runs to the end. Both need at least one
-        real step, so a threshold outside the schedule's range is refused rather than
-        silently producing a zero-step pass.
+        "continue from where pass 1 stopped") and runs to the end. When the restart sits
+        above the cut, the shifted latent is re-noised back up to it (see
+        _anchor_shift_renoise); `resume` says which of the two the caller must do.
+
+        Both passes need at least one real step, so a threshold outside the schedule's
+        range is refused rather than silently producing a zero-step pass. A restart BELOW
+        the cut is refused too — that would mean removing noise, which is not a thing.
         """
         if not isinstance(sigmas, torch.Tensor) or sigmas.numel() < 3:
             return None
@@ -3069,22 +3074,59 @@ class FunPackLTXAVSceneChainSampler:
             return None  # threshold above the first sigma, or not reached at all
         restart = float(restart_sigma)
         if restart <= 0:
-            # CONTINUE: pass 1 stops at the cut and pass 2 resumes from that exact state.
-            # Pass 2 must NOT re-noise (see _sample_chunk's continue_from_state).
-            first, second, resume = sigmas[:cut + 1], sigmas[cut:], True
-            start = cut
+            start = cut  # CONTINUE: pass 2 picks up exactly where pass 1 stopped.
         else:
-            # REWIND: pass 2 re-noises to a HIGHER sigma, which is only meaningful on a CLEAN
-            # latent — so pass 1 runs the whole schedule first and hands over a finished clip.
-            # Same shape as segmented detailing's stage-2 tail. Costs a full schedule + tail.
             start = _first_at_or_below(restart)
-            if start is None:
+            if start is None or start > cut:
+                # start > cut means the restart sigma is LOWER than the cut: pass 2 would
+                # claim the latent is cleaner than it is. Noise can be added back, never
+                # removed, so this is a misconfiguration, not a mode.
                 return None
-            first, second, resume = sigmas, sigmas[start:], False
+        # REWIND (start < cut) hands pass 2 a re-noised copy; CONTINUE (start == cut) hands
+        # over the state untouched. Either way pass 1 stopped at the cut the user asked for.
+        first, second, resume = sigmas[:cut + 1], sigmas[start:], start == cut
         if first.numel() < 2 or second.numel() < 2:
             return None
         return first, second, vals[cut], vals[start], resume
 
+    def _anchor_shift_renoise(self, latent, from_sigma, to_sigma, seed, reset_indices=()):
+        """Move a latent that sits mid-trajectory at `from_sigma` back up to `to_sigma`.
+
+        This model's CONST scaling means a latent at sigma s is x_s = s*eps + (1-s)*x0.
+        Given x_a we cannot recover x0 or eps separately — but we do not need to. A valid
+        x_b for b >= a is a linear mix of what we already have and fresh noise:
+
+            x_b = alpha*x_a + beta*n,  alpha = (1-b)/(1-a),  beta = sqrt(b^2 - (a*alpha)^2)
+
+        alpha reproduces x0's coefficient exactly and beta tops the noise term back up to
+        b, so the result sits on the manifold the model expects at b. Both endpoints fall
+        out of the same formula: b == a gives alpha=1, beta=0 (an exact resume, nothing
+        added) and a == 0 gives alpha=1-b, beta=b, which is comfy's own fresh-noise
+        scaling on a clean latent. beta has a real root only when b >= a — noise can be
+        added back but never removed, which is why the caller refuses a restart below the
+        cut.
+
+        Streams listed in `reset_indices` were wiped to zeros (fresh audio) and are NOT
+        mid-trajectory, so they re-enter at a=0 and get the full b*n a from-scratch run
+        would start from, rather than a partial top-up of a latent that no longer exists.
+        """
+        a, b = float(from_sigma), float(to_sigma)
+        result = self._clone_latent(latent)
+        tensors = self._latent_tensors(result)
+        noise = comfy.sample.prepare_noise(result["samples"], int(seed))
+        noises = list(noise.unbind()) if self._is_nested(noise) else [noise]
+        for i, t in enumerate(tensors):
+            a_i = 0.0 if i in tuple(reset_indices) else a
+            alpha = (1.0 - b) / (1.0 - a_i) if a_i < 1.0 else 0.0
+            beta = math.sqrt(max(0.0, b * b - (a_i * alpha) ** 2))
+            n = noises[i].to(device=t.device, dtype=t.dtype)
+            tensors[i] = t * alpha + n * beta
+        if self._is_nested(result.get("samples")):
+            result["samples"] = comfy.nested_tensor.NestedTensor(tensors)
+        else:
+            result["samples"] = tensors[0]
+        return result
+
     def _anchor_shift_latent(self, latent, drop, tail_mode, fresh_audio):
         """Slide the video stream left by `drop` latent frames and refill the freed tail.
 
@@ -5476,6 +5518,14 @@ class FunPackLTXAVSceneChainSampler:
                         # the "fake t2v" trick, it needs a real anchor to fake it WITH.
                         _reason = ("scene has no pinned i2v anchor (t2v scene) — nothing to shift; "
                                    "attach an anchor image, or leave anchor_shift off")
+                    elif 0 < float(anchor_shift_restart_sigma) < float(anchor_shift_sigma) - 1e-4:
+                        # Pass 2 would claim the latent is cleaner than pass 1 left it.
+                        # The re-noise can add noise back, never remove it.
+                        _reason = (f"anchor_shift_restart_sigma={anchor_shift_restart_sigma:g} is "
+                                   f"below anchor_shift_sigma={anchor_shift_sigma:g} — pass 2 can "
+                                   f"re-noise the shifted latent back UP to a higher sigma, but it "
+                                   f"cannot un-noise it down to a lower one. Use 0 to continue "
+                                   f"straight on from the cut, or a value at or above the cut")
                     else:
                         _shift_split = self._anchor_shift_split_sigmas(
                             sigmas, anchor_shift_sigma, anchor_shift_restart_sigma)
@@ -5490,13 +5540,22 @@ class FunPackLTXAVSceneChainSampler:
                         chunk, **_sample_kwargs)
                     _shifted, _dropped = self._anchor_shift_latent(
                         _pass1, _shift_drop, anchor_shift_tail, anchor_shift_fresh_audio)
-                    # Continue mode resumes from the handed-over state (no re-noise, so the
-                    # seed is irrelevant); rewind mode re-noises a finished clip, where fresh
-                    # noise is wanted — reusing scene_seed there would re-apply the exact field
-                    # pass 1 just resolved, against content that has since moved.
+                    if not _resume:
+                        # REWIND: put the shifted mid-trajectory latent back at the restart
+                        # sigma. A fresh noise field is wanted here — reusing scene_seed would
+                        # re-apply the exact field pass 1 just resolved, against content that
+                        # has since moved.
+                        _reset_streams = ((1,) if (anchor_shift_fresh_audio
+                                                   and len(self._latent_tensors(_shifted)) > 1)
+                                          else ())
+                        _shifted = self._anchor_shift_renoise(
+                            _shifted, _cut_at, _restart_at, scene_seed + 4242, _reset_streams)
+                    # Either way pass 2 is handed the exact x at its first sigma — as the
+                    # untouched hand-over (continue) or as the re-noised one (rewind) — so it
+                    # must never re-noise again. See _sample_chunk's continue_from_state.
                     _kw2 = dict(_sample_kwargs)
                     _kw2["step_offset"] = _sample_kwargs["step_offset"] + (_sig_a.numel() - 1)
-                    _kw2["continue_from_state"] = _resume
+                    _kw2["continue_from_state"] = True
                     sampled = self._sample_chunk(
                         model, sampler, _sig_b, scene_seed + 4242, cfg, scene_positive,
                         scene_negative, _shifted, **_kw2)
@@ -5507,15 +5566,6 @@ class FunPackLTXAVSceneChainSampler:
                         f"dropped {_dropped} of {_pinned_n} pinned latent frames, "
                         f"tail={anchor_shift_tail}"
                         f"{', fresh audio' if anchor_shift_fresh_audio else ''})")
-                    if not _resume:
-                        # In rewind mode pass 1 runs the whole schedule, so anchor_shift_sigma
-                        # never gets used. A knob that silently does nothing reads as broken —
-                        # say so, and say what to set to make it matter again.
-                        run_mechanisms.append(
-                            f"anchor_shift NOTE: rewind mode ignores anchor_shift_sigma"
-                            f"={anchor_shift_sigma:g} (pass 1 runs the full schedule so the "
-                            f"re-noise has a clean latent). Set anchor_shift_restart_sigma=0 "
-                            f"for continue mode, where the shift sigma is the cut point.")
                     if _dropped < _pinned_n:
                         # Part of the anchor survives the slide and stays visible in the clip —
                         # the one outcome this feature exists to prevent, so name the fix.
diff --git a/tests/test_anchor_shift.py b/tests/test_anchor_shift.py
index 2a595b88..3bca6063 100644
--- a/tests/test_anchor_shift.py
+++ b/tests/test_anchor_shift.py
@@ -5,11 +5,17 @@ loses character detail; Best-FaceID overlap tokens approximate it and lose some
 pinned at full strength for pass 1 and then removed from the clip entirely. So the invariants
 worth testing are about the shift itself:
 
+0. Pass 1 stops at anchor_shift_sigma — ALWAYS. That cut is the feature; no other setting
+   may quietly override it (an earlier fix let the restart sigma do exactly that, which
+   made the shift sigma inert without saying so).
 1. The schedule is cut into two passes that each still have a real step, or refused outright.
+1b. A restart above the cut re-noises the half-denoised latent back up to it correctly —
+   rebuilding x at the higher sigma, not re-noising it as if it were a finished image.
 2. The slide drops the head WITHOUT shortening the clip — no extra frames are ever generated.
 3. The pin is dropped with the frame it belonged to (pass 2 must run unpinned).
 4. Audio is reset when asked, since pass 1's audio was formed against frames that moved.
 """
+import math
 import sys
 import types
 from pathlib import Path
@@ -63,15 +69,137 @@ def test_continue_mode_stops_at_the_cut_and_resumes_from_that_state():
     assert resume is True
 
 
-def test_rewind_mode_runs_pass_one_to_completion_first():
-    """A re-noise to a HIGHER sigma is only meaningful on a clean latent, so rewind mode
-    must hand pass 2 a finished clip — not a mid-trajectory one."""
+def test_rewind_mode_still_stops_pass_one_at_the_cut():
+    """The cut sigma is the whole feature — rewind must NOT override it. Pass 1 stops
+    where the user asked, and the restart only decides where pass 2 re-enters."""
     first, second, cut_at, restart_at, resume = _node()._anchor_shift_split_sigmas(
         SCHEDULE, 0.725, 0.975)
     assert abs(cut_at - 0.725) < 1e-5 and abs(restart_at - 0.975) < 1e-5
-    assert [round(v, 3) for v in first.tolist()] == [1.0, 0.975, 0.909, 0.725, 0.422, 0.0]
+    assert [round(v, 3) for v in first.tolist()] == [1.0, 0.975, 0.909, 0.725]
     assert [round(v, 3) for v in second.tolist()] == [0.975, 0.909, 0.725, 0.422, 0.0]
-    assert resume is False  # clean input -> re-noising is correct here
+    # resume=False means the caller must re-noise 0.725 -> 0.975 before pass 2 runs.
+    assert resume is False
+
+
+def test_rewind_refuses_a_restart_below_the_cut():
+    """Pass 2 can be handed a NOISIER latent, never a cleaner one — there is no way to
+    remove noise from the state pass 1 stopped at."""
+    assert _node()._anchor_shift_split_sigmas(SCHEDULE, 0.909, 0.422) is None
+
+
+def test_restart_landing_on_the_cut_is_just_continue():
+    """A restart that snaps to the cut's own step has nothing to re-noise."""
+    _, _, cut_at, restart_at, resume = _node()._anchor_shift_split_sigmas(
+        SCHEDULE, 0.909, 0.909)
+    assert abs(cut_at - restart_at) < 1e-5
+    assert resume is True
+
+
+# ── the mid-trajectory re-noise ─────────────────────────────────────────────
+
+class _FakeNested(list):
+    """Minimal stand-in for comfy's NestedTensor: enough for _is_nested + unbind."""
+    is_nested = True
+
+    def unbind(self):
+        return list(self)
+
+
+@pytest.fixture
+def renoise_stubs():
+    """Deterministic noise (a constant 7.0) plus a usable NestedTensor.
+
+    Snapshot/restore for the same reason the fixture below does it: these comfy stubs are
+    shared module objects, and mutations left behind change other modules' results.
+    """
+    mod = sys.modules["comfy.sample"]
+    comfy_mod = sys.modules["comfy"]
+    nested_mod = sys.modules["comfy.nested_tensor"]
+    saved = (getattr(mod, "prepare_noise", None), getattr(comfy_mod, "sample", None),
+             nested_mod.NestedTensor, getattr(comfy_mod, "nested_tensor", None))
+
+    def prepare_noise(samples, seed, *a, **k):
+        if getattr(samples, "is_nested", False):
+            return _FakeNested([torch.full_like(t, 7.0) for t in samples.unbind()])
+        return torch.full_like(samples, 7.0)
+
+    mod.prepare_noise = prepare_noise
+    comfy_mod.sample = mod
+    comfy_mod.nested_tensor = nested_mod  # attribute access, not just sys.modules
+    nested_mod.NestedTensor = _FakeNested
+    yield
+    if saved[0] is None:
+        delattr(mod, "prepare_noise")
+    else:
+        mod.prepare_noise = saved[0]
+    if saved[1] is None:
+        delattr(comfy_mod, "sample")
+    else:
+        comfy_mod.sample = saved[1]
+    nested_mod.NestedTensor = saved[2]
+    if saved[3] is None:
+        delattr(comfy_mod, "nested_tensor")
+    else:
+        comfy_mod.nested_tensor = saved[3]
+
+
+def test_renoise_to_the_same_sigma_is_an_identity(renoise_stubs):
+    """b == a must add nothing: alpha=1, beta=0. This is what lets continue mode and
+    rewind mode be one formula instead of two special cases."""
+    latent = {"samples": torch.full((1, 4, 6, 2, 2), 3.0)}
+    out = _node()._anchor_shift_renoise(latent, 0.725, 0.725, seed=7)
+    assert torch.allclose(out["samples"], latent["samples"], atol=1e-6)
+
+
+def test_renoise_from_zero_matches_comfy_const_scaling(renoise_stubs):
+    """a == 0 (a finished latent) must reproduce comfy's own x = b*noise + (1-b)*x0, so
+    the formula strictly generalises the img2img re-noise rather than replacing it."""
+    b = 0.975
+    x0 = torch.full((1, 4, 6, 2, 2), 3.0)
+    out = _node()._anchor_shift_renoise({"samples": x0}, 0.0, b, seed=11)
+    expected = _const_noise_scaling(b, torch.full_like(x0, 7.0), x0)
+    assert torch.allclose(out["samples"], expected, atol=1e-6)
+
+
+def test_renoise_upward_rebuilds_the_state_at_the_higher_sigma(renoise_stubs):
+    """The bug this feature shipped with, fixed properly. Pass 1 stops at 0.603 and pass 2
+    restarts at 0.893: x0's coefficient must land on (1-b) EXACTLY and the noise term must
+    total b — anything else is the under-denoising from the first live run coming back."""
+    a, b = 0.603, 0.893
+    x0, eps = torch.full((1, 4, 6, 2, 2), 3.0), torch.full((1, 4, 6, 2, 2), -1.5)
+    x_a = x0 * (1.0 - a) + eps * a          # a genuine mid-trajectory latent
+    out = _node()._anchor_shift_renoise({"samples": x_a}, a, b, seed=3)
+
+    alpha = (1.0 - b) / (1.0 - a)
+    beta = math.sqrt(b * b - (a * alpha) ** 2)
+    assert abs(alpha * (1.0 - a) - (1.0 - b)) < 1e-9   # picture kept at full strength
+    assert abs((alpha * a) ** 2 + beta ** 2 - b * b) < 1e-9  # noise topped back up to b
+    assert torch.allclose(out["samples"], x_a * alpha + 7.0 * beta, atol=1e-6)
+    # And the naive path is measurably NOT this — the whole point of the fix.
+    assert not torch.allclose(out["samples"],
+                              _const_noise_scaling(b, torch.full_like(x_a, 7.0), x_a), atol=1e-3)
+
+
+def test_renoise_starts_a_reset_stream_from_scratch(renoise_stubs):
+    """A stream wiped by fresh_audio is not mid-trajectory — topping it up as if it were
+    would start it quieter than a from-scratch run does. It gets the full b*noise."""
+    b = 0.893
+    latent = {"samples": _FakeNested(
+        [torch.full((1, 4, 6, 2, 2), 2.0), torch.zeros(1, 4, 12)])}
+    out = _node()._anchor_shift_renoise(latent, 0.603, b, seed=5, reset_indices=(1,))
+    video, audio = out["samples"].unbind()
+    assert torch.allclose(audio, torch.full_like(audio, 7.0 * b), atol=1e-6)
+    # ...and the video stream still took the mid-trajectory path, not the a=0 one.
+    alpha = (1.0 - b) / (1.0 - 0.603)
+    expected = 2.0 * alpha + 7.0 * math.sqrt(b * b - (0.603 * alpha) ** 2)
+    assert torch.allclose(video, torch.full_like(video, expected), atol=1e-6)
+
+
+def test_renoise_never_mutates_its_input(renoise_stubs):
+    latent = {"samples": torch.full((1, 4, 6, 2, 2), 3.0)}
+    before = latent["samples"].clone()
+    _node()._anchor_shift_renoise(latent, 0.603, 0.893, seed=1)
+    assert torch.equal(latent["samples"], before)
 
 
 def test_split_refuses_when_a_pass_would_have_no_steps():

From 5aac3cc5c1a151f427d00ad9d10120869c0c1550 Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Fri, 31 Jul 2026 12:37:18 +0300
Subject: [PATCH 15/29] Easy Gen: re-attach to a running generation after a
 page reload
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Easy Gen had no equivalent of the Cutting Room's reconnect-after-reload: reloading
mid-run left Generate re-enabled with no Interrupt and no progress, while the run
carried on server-side.

Nothing was missing on the backend. Easy Gen queues through the Editor's own
/generate route, so its prompts already carry the editor client_id + funpack run
identity, already come back from GET /api/active, and api.js already exposed
active(). Easy Gen simply never asked.

app.js gains reattachRunning(), run after the project is restored on boot:
- Run targets the loaded project -> full re-attach through the existing
  preview.watch(), so the result still lands in the preview when it finishes.
- Run targets something else (typically a montage queued from the Cutting Room)
  -> preview.monitor(), a new queue watcher over /api/active that shows progress
  and Interrupt without claiming the output. It deliberately does NOT switch
  projects out from under the user to take ownership of a foreign run.
- Loops while further runs are queued behind the running one, so Generate stays
  blocked until the queue drains.

Also fixes a live-run bug found on the way: render() ran on every store notify
(health poll every 15s, every prompt keystroke) and unconditionally set
generateBtn.disabled = !project — re-enabling Generate underneath a generation
that was still going. Both paths now go through one setGenerating() flag, which
render() respects, and a project switch mid-run no longer tears down the poll.

preview.js: watch() takes an optional `note` for the initial label so a re-attach
says "Reconnected after reload" instead of "Starting…"; the Interrupt wiring is
shared between watch() and monitor() as _armStopButton().

Verified in the local ComfyUI: page boots clean (only ComfyUI's own pre-existing
console errors), /api/active is polled on boot, monitor() stays pending with an
armed Interrupt while a job reports running and resolves + hides when it leaves
the queue, and Generate survives a store notify. The full-reattach branch reuses
the already-validated preview.watch() path but could not be exercised end to end
locally, since a real run needs the rental GPU.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 easy_gen/frontend/app.js     | 80 +++++++++++++++++++++++++++++-------
 easy_gen/frontend/preview.js | 70 +++++++++++++++++++++++++------
 2 files changed, 124 insertions(+), 26 deletions(-)

diff --git a/easy_gen/frontend/app.js b/easy_gen/frontend/app.js
index 2c2b114e..36a7d8ea 100644
--- a/easy_gen/frontend/app.js
+++ b/easy_gen/frontend/app.js
@@ -1,8 +1,7 @@
 // Easy Gen entrypoint: wires the big-preview / prompt / upload / generate bar
 // to the shared easy_store.js + preview.js, and opens the "FunPack Easy Gen"
-// project picker on boot. No re-attach-on-reload support yet (the Editor's
-// /api/active flow) — a reload while a run is in flight loses the progress
-// view, though the run itself still completes server-side.
+// project picker on boot. Reloading during a run re-attaches to it via the
+// Editor's /api/active flow — see reattachRunning() below.
 (function () {
   const S = window.Store;
   const API = window.MovieEditorAPI;
@@ -45,11 +44,21 @@
   }
   preview.setOnClearUpload(removeUpload);
 
+  // True whenever a run of ours is in flight — a fresh Generate OR one re-attached after a
+  // reload. render() runs on every store notify (health poll, keystroke), so without this
+  // it would re-enable Generate underneath a running generation.
+  let generating = false;
+  function setGenerating(on) {
+    generating = on;
+    generateBtn.disabled = on || !S.get().project;
+    generateBtn.textContent = on ? "Generating…" : "Generate";
+  }
+
   let lastProjectId = null;
   function render(st) {
     const p = st.project;
     nameEl.textContent = p ? p.name : "No project";
-    generateBtn.disabled = !p;
+    generateBtn.disabled = generating || !p;
     uploadBtn.disabled = !p;
     galleryBtn.disabled = !p;
     saveBtn.disabled = !p;
@@ -66,9 +75,13 @@
     const pid = p ? p.id : null;
     if (pid !== lastProjectId) {
       lastProjectId = pid;
-      preview.stopPolling();
-      preview.showEmpty();
-      generateBtn.textContent = "Generate";
+      // Not while a run is in flight: the generation is still going server-side, and
+      // tearing down its poll here would orphan it exactly like a reload used to.
+      if (!generating) {
+        preview.stopPolling();
+        preview.showEmpty();
+        generateBtn.textContent = "Generate";
+      }
     }
   }
   S.subscribe(render);
@@ -124,19 +137,17 @@
       alert("Type a prompt first.");
       return;
     }
-    generateBtn.disabled = true;
-    generateBtn.textContent = "Generating…";
+    setGenerating(true);
     try {
       await S.save();
       const resetSession = S.takeResetSessionFlag();
       const res = await API.generate(st.project.id, null, null, resetSession, EASY_MODE_OVERRIDES);
       preview.watch(st.project.id, res.prompt_id, {
-        onDone: () => { generateBtn.disabled = false; generateBtn.textContent = "Generate"; },
+        onDone: () => setGenerating(false),
       });
     } catch (e) {
       preview.showError("Generate failed: " + (e.message || e));
-      generateBtn.disabled = false;
-      generateBtn.textContent = "Generate";
+      setGenerating(false);
     }
   };
 
@@ -177,6 +188,42 @@
     }
   };
 
+  // Re-attach to a generation that was already running when the page (re)loaded. Easy Gen
+  // queues through the Editor's own /generate route, so its prompts are already stamped
+  // with the editor client_id + run identity and come back from /api/active — nothing was
+  // missing server-side, Easy Gen simply never asked. Same shape as the Cutting Room's
+  // store.js resumeRunningGeneration, minus the per-scene recording it has no UI for.
+  async function reattachRunning() {
+    let act = null;
+    try { act = await API.active(); } catch (_) { return; }
+    let last = null;
+    // Loop: a montage queued from the Cutting Room can have further runs behind the one
+    // that happens to be executing now, and Generate should stay blocked until they drain.
+    while (act && act.running && act.prompt_id && act.prompt_id !== last) {
+      last = act.prompt_id;
+      setGenerating(true);
+      const st = S.get();
+      const queued = act.pending > 0 ? ` · ${act.pending} more queued` : "";
+      if (st.project && act.pid && st.project.id === act.pid) {
+        // Ours, and the project it targets is loaded — full re-attach, result included.
+        await new Promise((resolve) => {
+          preview.watch(act.pid, act.prompt_id, {
+            onDone: () => resolve(),
+            note: `Reconnected after reload${queued}`,
+          });
+        });
+      } else {
+        // Started against a different project (typically from the Cutting Room). Do NOT
+        // switch projects out from under the user to claim it — just watch the queue so
+        // Generate stays blocked and Interrupt is offered while the GPU is busy.
+        await preview.monitor(
+          act.prompt_id, `A generation is running elsewhere${queued}`);
+      }
+      try { act = await API.active(); } catch (_) { act = null; }
+    }
+    setGenerating(false);
+  }
+
   async function boot() {
     S.refreshHealth();
     S.loadLibraries();
@@ -189,10 +236,15 @@
     });
 
     const lastId = localStorage.getItem(LAST_PROJECT_KEY);
+    let loaded = false;
     if (lastId) {
-      try { await S.loadProject(lastId); return; } catch (_) { /* fall through to picker */ }
+      try { await S.loadProject(lastId); loaded = true; } catch (_) { /* fall through to picker */ }
     }
-    window.ProjectMenu.open({ dismissable: false });
+    if (!loaded) window.ProjectMenu.open({ dismissable: false });
+    // After the project is in place, so a run targeting it re-attaches fully (result and
+    // all) instead of falling back to the queue-watch path. Not awaited — it runs for as
+    // long as the generation does.
+    reattachRunning();
   }
 
   boot();
diff --git a/easy_gen/frontend/preview.js b/easy_gen/frontend/preview.js
index 3dd97fa6..00b462b0 100644
--- a/easy_gen/frontend/preview.js
+++ b/easy_gen/frontend/preview.js
@@ -139,32 +139,77 @@
       draw();
     }
 
-    async function watch(projectId, promptId, { onDone } = {}) {
-      stopPolling();
-      errorMsg = null;
-      progressWrap.hidden = false;
-      label.textContent = "Starting…";
-      bar.style.width = "0%";
-      // An interrupted job lands in ComfyUI's history as status_str "error" with no media —
-      // indistinguishable from a real failure at the API level. Remember that the user asked
-      // for it so the poll below reports "stopped", not "Generation failed".
-      let interrupted = false;
+    // Wire the Interrupt button for whatever run is being followed. Returns a getter for
+    // the "the user asked for this" flag, since an interrupted job is indistinguishable
+    // from a failed one at the API level and both callers below need to tell them apart.
+    function _armStopButton(onFlag) {
       stopBtn.disabled = false;
       stopBtn.textContent = "■ Interrupt";
       stopBtn.onclick = async () => {
-        interrupted = true;
+        onFlag(true);
         stopBtn.disabled = true;
         stopBtn.textContent = "Interrupting…";
         label.textContent = "Interrupting…";
         try { await API.interrupt(); }
         catch (e) {
           // The run may well still be going — say so instead of leaving a dead button.
-          interrupted = false;
+          onFlag(false);
           stopBtn.disabled = false;
           stopBtn.textContent = "■ Interrupt";
           label.textContent = "Could not interrupt: " + (e.message || e);
         }
       };
+    }
+
+    // Follow a run we cannot map to the loaded project — one queued from the Cutting Room,
+    // or from Easy Gen under a different project before a reload. There is no history to
+    // poll for a result here, so this just watches ComfyUI's queue via /api/active: enough
+    // to keep Generate blocked and offer Interrupt while the GPU is busy.
+    function monitor(promptId, note) {
+      return new Promise((resolve) => {
+        stopPolling();
+        errorMsg = null;
+        progressWrap.hidden = false;
+        label.textContent = note || "A generation is running…";
+        bar.style.width = "0%";
+        let interrupted = false;
+        _armStopButton((v) => { interrupted = v; });
+        const tick = async () => {
+          let act = null;
+          try { act = await API.active(); }
+          catch (_) { pollTimer = setTimeout(tick, 2000); return; }  // transient — keep watching
+          if (!act || !act.running || act.prompt_id !== promptId) {
+            stopPolling();
+            progressWrap.hidden = true;
+            resolve();
+            return;
+          }
+          if (!interrupted) {
+            try {
+              const pr = await API.progress();
+              if (pr.max > 0) {
+                bar.style.width = Math.min(100, Math.round((pr.value / pr.max) * 100)) + "%";
+                label.textContent = `${note || "A generation is running"} · ${pr.value}/${pr.max}`;
+              }
+            } catch (_) { /* transient */ }
+          }
+          pollTimer = setTimeout(tick, 2000);
+        };
+        tick();
+      });
+    }
+
+    async function watch(projectId, promptId, { onDone, note } = {}) {
+      stopPolling();
+      errorMsg = null;
+      progressWrap.hidden = false;
+      label.textContent = note || "Starting…";
+      bar.style.width = "0%";
+      // An interrupted job lands in ComfyUI's history as status_str "error" with no media —
+      // indistinguishable from a real failure at the API level. Remember that the user asked
+      // for it so the poll below reports "stopped", not "Generation failed".
+      let interrupted = false;
+      _armStopButton((v) => { interrupted = v; });
 
       progressTimer = setInterval(async () => {
         if (interrupted) return; // don't paint "Sampling…" over "Interrupting…"
@@ -221,6 +266,7 @@
       showEmpty,
       showError,
       watch,
+      monitor,
       stopPolling,
     };
   }

From 4c2a6b6b54872d02e8f0cda511098433804fced1 Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Fri, 31 Jul 2026 12:59:39 +0300
Subject: [PATCH 16/29] anchor_shift: the sampler must see the real schedule,
 not its own half of it
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Raised by the user: "it should read the actual sampler schedule." They were right,
and this is a bigger deal than anchor_shift.

Both FunPack samplers derive their phase boundaries from len(sigmas) — the tensor
they are handed. anchor_shift runs a scene as two sample_custom calls over slices of
one schedule, so each half re-derived every phase INSIDE the slice:

  _sample_const_rf_full (Hybrid Euler 2S, and the LTXAV path of it)
    - quality phase: late_start = pct of the SLICE. On the user's 9-step schedule at
      high_quality_pct 0.35 the quality phase starts at sigma 0.603; split at 0.482 it
      starts at 0.812 in pass 1 and 0.482 in pass 2.
    - motion-pulse anchors keyed by step index within the slice
    - eta decay + velocity-bias ratio measured against the slice's first sigma
    - the euler->Heun correction ramp restarted per call
  sample_funpack_distilled_flow
    - final-correction window: the last N steps OF THE SLICE, so pass 1 ran a "final"
      Heun correction in the middle of the trajectory
    - AB2 ramp w = i/(total-1) restarted from 0 in pass 2
    - velocity-bias sigma ratio against the slice's first sigma

So turning anchor_shift on silently re-timed the sampler's own machinery in both
halves. Present since 015f274 and a far better explanation for a visible joint or a
thin ending than anything in the shift itself.

Fix: _schedule_view(sigmas, schedule_context) -> (real schedule, step offset). The
chain sampler passes {"sigmas": <the scene's schedule>, "offset": <slice start>} via
extra_options (the same chunk-scoped mechanism the alg_guide_* options already use,
always written even as None so it cannot leak into a later chunk). Both samplers take
the kwarg; every phase-relative quantity now reads the schedule and every step index
is step_abs = i + offset. No context = a normal single call = sigmas IS the schedule,
offset 0, byte-identical behaviour.

_anchor_shift_split_sigmas also returns pass 2's index into the schedule, and its
docstring now states the boundary rule the way the user framed it: walk the schedule,
the last pre-shift step is the one whose NEXT sigma has crossed the threshold. On
1.000 0.955 0.893 0.812 0.715 0.603 0.482 0.241 0.121 0.0 with shift 0.482 and restart
0.812 that gives pass 1 = 1.000..0.482 and pass 2 = 0.812..0.0, which is now asserted
directly as a test on that schedule.

Not changed, deliberately: sample_funpack_hybrid_euler_2s's own non-CONST loop (LTXAV
always takes the RF port, so no anchor_shift run reaches it) and segmented detailing's
stage-2 tail (a separate refine pass over a finished latent with its own schedule by
design, not a slice of one).

Suite at baseline: 22 pre-existing failures, 283 passing (+4).

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 samplers.py                | 115 ++++++++++++++++++++++++++++---------
 tests/test_anchor_shift.py |  54 ++++++++++++++++-
 2 files changed, 140 insertions(+), 29 deletions(-)

diff --git a/samplers.py b/samplers.py
index 872eb6bc..8ed1efa5 100644
--- a/samplers.py
+++ b/samplers.py
@@ -340,6 +340,24 @@ def _velocity_bias_key(refinement_key, target, x):
     return (key, f"{float(target):.2f}", shape)
 
 
+def _schedule_view(sigmas, schedule_context):
+    """The real schedule behind a possibly-partial `sigmas`, plus this run's step offset.
+
+    anchor_shift samples a scene as two sample_custom calls over slices of one schedule.
+    A sampler that measures its phases from `len(sigmas)` therefore re-derives them inside
+    each slice — the final-correction window reopens at the end of pass 1, the AB2 ramp
+    restarts, the velocity-bias ratio is taken against the slice's own first sigma. The
+    caller passes the whole schedule and where this slice starts in it; absent (any normal
+    single-call run) `sigmas` IS the whole schedule and the offset is 0.
+    """
+    if isinstance(schedule_context, dict):
+        full = schedule_context.get("sigmas")
+        if isinstance(full, torch.Tensor) and int(full.numel()) >= 2:
+            offset = max(0, int(schedule_context.get("offset", 0) or 0))
+            return full, offset
+    return sigmas, 0
+
+
 def _sigma_ratio(sigmas, sigma):
     try:
         start = float(sigmas[0].item())
@@ -1109,7 +1127,8 @@ def _sample_const_rf_full(model, x, sigmas, extra_args, callback, disable,
                           velocity_refinement_key,
                           rescue_mode, rescue_threshold, rescue_strength, rescue_prompt_sig,
                           quality_sharpness=0.0, velocity_bias_source="mean",
-                          normalize_strength=0.0, normalize_start_sigma=0.9):
+                          normalize_strength=0.0, normalize_start_sigma=0.9,
+                          schedule_context=None):
     """Full-feature rectified-flow sampler for CONST models (LTXAV).
 
     Rectified-flow-correct port of the hybrid sampler so its features actually run on
@@ -1140,9 +1159,14 @@ def _sample_const_rf_full(model, x, sigmas, extra_args, callback, disable,
     correction_blend = max(0.0, min(1.0, float(correction_blend)))
     eta_final = max(0.0, min(float(eta), float(eta_final)))
 
+    # See _schedule_view: `sigmas` may be one half of an anchor_shift split, and the quality
+    # phase / motion-pulse anchors below are positions in the SCHEDULE, not in this call.
+    sched, step_offset = _schedule_view(sigmas, schedule_context)
+    sched_steps = max(1, int(len(sched)) - 1)
+
     if not motion_pulse_steps:
         _, _, motion_pulse_steps, motion_pulse_noise = _prepare_dynamic_sigmas(
-            sigmas, high_quality_pct, motion_pulse_mode, motion_pulse_start_pct,
+            sched, high_quality_pct, motion_pulse_mode, motion_pulse_start_pct,
             motion_pulse_count, motion_pulse_spacing_pct, motion_pulse_strength)
     motion_pulse_noise = max(0.0, float(motion_pulse_noise or 0.0))
     motion_step_noise = {
@@ -1150,14 +1174,13 @@ def _sample_const_rf_full(model, x, sigmas, extra_args, callback, disable,
         for item in (motion_pulse_steps or []) if isinstance(item, dict)
     }
 
-    late_start = _get_late_start_index(total_steps, high_quality_pct)
-    quality_sigma_start = float(sigmas[late_start].item()) if late_start < sigmas.shape[0] else None
-    num_quality_steps = total_steps - late_start
+    late_start = _get_late_start_index(sched_steps, high_quality_pct)
+    quality_sigma_start = float(sched[late_start].item()) if late_start < sched.shape[0] else None
+    num_quality_steps = sched_steps - late_start
 
     s_in = x.new_ones([x.shape[0]])
     prev_denoised = None
     prev_h = None
-    quality_step_index = 0
     _kvlock_state = {}
 
     # Audio-safe sampling: on a packed LTXAV latent, keep ancestral noise + steering on the
@@ -1178,11 +1201,12 @@ def _sample_const_rf_full(model, x, sigmas, extra_args, callback, disable,
     for i in comfy.utils.model_trange(total_steps, disable=disable):
         sigma = sigmas[i]
         sigma_next = sigmas[i + 1]
+        step_abs = i + step_offset  # position in the REAL schedule, not in this call's slice
         in_quality = quality_sigma_start is not None and float(sigma.item()) <= quality_sigma_start
-        velocity_target = _velocity_bias_target(sigmas, sigma)
+        velocity_target = _velocity_bias_target(sched, sigma)
 
         if not in_quality:
-            pulse = motion_step_noise.get(int(i), 0.0)
+            pulse = motion_step_noise.get(int(step_abs), 0.0)
             if pulse > 0.0:
                 x = _video_only(_apply_motion_pulse(x, sigma, sigma_next, pulse, noise_sampler), x, video_mask)
                 prev_denoised = None
@@ -1191,7 +1215,7 @@ def _sample_const_rf_full(model, x, sigmas, extra_args, callback, disable,
         if _velocity_bias_enabled(velocity_bias_mode, "apply"):
             x_pre = x
             x = _apply_velocity_bias(x, velocity_refinement_key, velocity_target, velocity_bias_strength,
-                                     sigma_ratio=_sigma_ratio(sigmas, sigma),
+                                     sigma_ratio=_sigma_ratio(sched, sigma),
                                      prompt_sig=rescue_prompt_sig, source=velocity_bias_source)
             x = _video_only(x, x_pre, video_mask)
 
@@ -1245,7 +1269,10 @@ def _sample_const_rf_full(model, x, sigmas, extra_args, callback, disable,
             if num_quality_steps <= 1:
                 effective_blend = correction_blend
             else:
-                effective_blend = 0.0 if quality_step_index < (num_quality_steps // 2) else correction_blend
+                # Which quality step this is IN THE SCHEDULE — a per-call counter would
+                # restart the euler->Heun ramp inside each half of an anchor_shift split.
+                q_idx = max(0, step_abs - late_start)
+                effective_blend = 0.0 if q_idx < (num_quality_steps // 2) else correction_blend
             dt = sigma_next - sigma
             d1 = k_diffusion_sampling.to_d(x, sigma, denoised_eff)
             if effective_blend > 0.0:
@@ -1261,11 +1288,10 @@ def _sample_const_rf_full(model, x, sigmas, extra_args, callback, disable,
             # Heun changed x with a corrected direction; invalidate AB2 history.
             prev_denoised = None
             prev_h = None
-            quality_step_index += 1
         else:
             # Early phase: ancestral RF euler (matches sample_euler_ancestral_RF), with
             # eta decay toward the quality boundary, using the AB2 denoised estimate.
-            effective_eta = _effective_eta(eta, eta_final, sigmas, sigma)
+            effective_eta = _effective_eta(eta, eta_final, sched, sigma)
             # Deterministic euler-RF step to sigma_next (this is what audio rides — no
             # ancestral re-noising). For single-stream video (mask None) it is only used
             # as the eta==0 fallback; the full ancestral result is kept for video.
@@ -1310,7 +1336,8 @@ def sample_funpack_hybrid_euler_2s(model, x, sigmas, extra_args=None, callback=N
                                    rescue_prompt_sig=None,
                                    eta_final=1.0,
                                    normalize_strength=0.0,
-                                   normalize_start_sigma=0.9):
+                                   normalize_start_sigma=0.9,
+                                   schedule_context=None):
     """
     Hybrid sampler:
     - Early schedule: Euler ancestral with order-2 denoised extrapolation for
@@ -1387,6 +1414,7 @@ def sample_funpack_hybrid_euler_2s(model, x, sigmas, extra_args=None, callback=N
             velocity_bias_source=velocity_bias_source,
             normalize_strength=normalize_strength,
             normalize_start_sigma=normalize_start_sigma,
+            schedule_context=schedule_context,
         )
 
     extra_args = {} if extra_args is None else extra_args
@@ -1758,7 +1786,7 @@ def sample_funpack_distilled_flow(model, x, sigmas, extra_args=None, callback=No
                                    alg_guide_tail_frames=0,
                                    alg_guide_blur_strength=2.0, alg_guide_blur_sigma_threshold=0.975,
                                    mg_enabled=False, mg_strength=0.5, mg_decay=0.5, mg_sigma_threshold=0.975,
-                                   quality_sharpness=0.0):
+                                   quality_sharpness=0.0, schedule_context=None):
     """
     ODE sampler for distilled few-step video models (e.g. LTX2.3 distilled LoRA).
 
@@ -1808,10 +1836,18 @@ def sample_funpack_distilled_flow(model, x, sigmas, extra_args=None, callback=No
     if total_steps <= 0:
         return x
 
+    # `sigmas` is not always the schedule the user configured: anchor_shift runs a scene as
+    # two sample_custom calls, so this can be a FRAGMENT. Everything phase-relative below —
+    # where the final-correction window opens, how far along the AB2 ramp is, what the
+    # velocity-bias sigma ratio is measured against — has to be read off the REAL schedule,
+    # or enabling anchor_shift silently re-times all of it inside each half.
+    sched, step_offset = _schedule_view(sigmas, schedule_context)
+    sched_steps = max(1, int(len(sched)) - 1)
+
     order = max(1, min(2, int(order)))
     s_noise = max(0.0, min(0.5, float(s_noise)))
-    final_correction_steps = max(0, min(total_steps // 2, int(final_correction_steps)))
-    correction_start_idx = total_steps - final_correction_steps
+    final_correction_steps = max(0, min(sched_steps // 2, int(final_correction_steps)))
+    correction_start_idx = sched_steps - final_correction_steps
 
     _RESCUE_LOG["warned_no_memory"] = False
     _RESCUE_LOG["warned_no_prompt_match"] = False
@@ -1918,7 +1954,9 @@ def sample_funpack_distilled_flow(model, x, sigmas, extra_args=None, callback=No
         for i in comfy.utils.model_trange(total_steps, disable=disable):
             sigma = sigmas[i]
             sigma_next = sigmas[i + 1]
-            velocity_target = _velocity_bias_target(sigmas, sigma)
+            # Position in the REAL schedule, not in this call's slice of it.
+            step_abs = i + step_offset
+            velocity_target = _velocity_bias_target(sched, sigma)
 
             if alg_active:
                 model.latent_image = alg_latents[(
@@ -1929,7 +1967,7 @@ def sample_funpack_distilled_flow(model, x, sigmas, extra_args=None, callback=No
             if _velocity_bias_enabled(velocity_bias_mode, "apply"):
                 x_pre = x
                 x = _apply_velocity_bias(x, velocity_refinement_key, velocity_target, velocity_bias_strength,
-                                         sigma_ratio=_sigma_ratio(sigmas, sigma),
+                                         sigma_ratio=_sigma_ratio(sched, sigma),
                                          prompt_sig=rescue_prompt_sig, source=velocity_bias_source)
                 x = _video_only(x, x_pre, video_mask)
 
@@ -1947,7 +1985,7 @@ def sample_funpack_distilled_flow(model, x, sigmas, extra_args=None, callback=No
 
             # Restore high-frequency detail during the final Heun-correction steps (free,
             # video-only) — same unsharp mechanism as the Hybrid Euler 2S sampler.
-            if i >= correction_start_idx:
+            if step_abs >= correction_start_idx:
                 denoised = _video_only(_apply_quality_sharpness(denoised, prev_denoised, quality_sharpness), denoised, video_mask)
 
             # Video-only latent normalization (opt-in, anti-overbake) — stacks on top of the ODE.
@@ -1976,8 +2014,8 @@ def sample_funpack_distilled_flow(model, x, sigmas, extra_args=None, callback=No
             # the schedule. Early/high-sigma steps stay near 1st-order euler (the denoised estimate
             # is rough there and full AB2 overshoots); late/detail steps get full AB2. Reuses the
             # already-computed AB2 estimate, so no extra model evals. No-op at order=1.
-            if ab2_ramp and total_steps > 1:
-                w = i / (total_steps - 1)  # 0 at first step -> 1 at last
+            if ab2_ramp and sched_steps > 1:
+                w = step_abs / (sched_steps - 1)  # 0 at first step -> 1 at last
                 denoised_eff = denoised + (denoised_eff - denoised) * w
 
             # Audio rides plain 1st-order euler: keep the (ramped) AB2 estimate for video,
@@ -1995,7 +2033,7 @@ def sample_funpack_distilled_flow(model, x, sigmas, extra_args=None, callback=No
 
             dt = sigma_next - sigma  # negative: sigmas decrease
 
-            if i >= correction_start_idx:
+            if step_abs >= correction_start_idx:
                 # Heun predictor-corrector.
                 # Predictor: Euler step using the (multistep-corrected) denoised.
                 d1 = k_diffusion_sampling.to_d(x, sigma, denoised_eff)
@@ -2951,7 +2989,8 @@ class FunPackLTXAVSceneChainSampler:
     def _sample_chunk(self, model, sampler, sigmas, seed, cfg, positive, negative, latent,
                       pbar=None, step_offset=0, alg_guide_tail_frames=0,
                       alg_guide_blur_strength=2.0, alg_guide_blur_sigma_threshold=0.975,
-                      bounded_attention_enabled=False, continue_from_state=False):
+                      bounded_attention_enabled=False, continue_from_state=False,
+                      schedule_context=None):
         if sampler is None:
             raise ValueError("sampler input is required.")
         if not isinstance(sigmas, torch.Tensor):
@@ -2982,6 +3021,13 @@ class FunPackLTXAVSceneChainSampler:
             extra_options["alg_guide_tail_frames"] = int(alg_guide_tail_frames)
             extra_options["alg_guide_blur_strength"] = float(alg_guide_blur_strength)
             extra_options["alg_guide_blur_sigma_threshold"] = float(alg_guide_blur_sigma_threshold)
+        # anchor_shift runs a scene as two calls over slices of one schedule. Tell the sampler
+        # what the real schedule is (and where this slice sits in it) so its phase boundaries
+        # stay where the user's schedule put them instead of being re-derived per slice — see
+        # _schedule_view. Always written, even as None, so it can never leak into a later chunk.
+        if isinstance(extra_options, dict) and sampler.sampler_function in (
+                sample_funpack_distilled_flow, sample_funpack_hybrid_euler_2s):
+            extra_options["schedule_context"] = schedule_context
 
         # EXPERIMENTAL Bounded Attention: model-level attention hooks (sampler-agnostic, unlike
         # the toggles above which only work on Distilled Flow), so install/remove here rather
@@ -3057,6 +3103,16 @@ class FunPackLTXAVSceneChainSampler:
         Both passes need at least one real step, so a threshold outside the schedule's
         range is refused rather than silently producing a zero-step pass. A restart BELOW
         the cut is refused too — that would mean removing noise, which is not a thing.
+
+        Everything here is read off the ACTUAL schedule, never off the typed floats: walk
+        the sigmas and the last pre-shift step is the one whose NEXT sigma has crossed the
+        threshold. On a 1.000, 0.955, 0.893, 0.812, 0.715, 0.603, 0.482, 0.241, 0.121, 0.0
+        schedule with shift 0.482, steps at 1.000 and 0.955 both have a next sigma still
+        above it and proceed; the step at 0.603 has next=0.482, so it is the last one and
+        the shift happens after it. `_first_at_or_below` is that walk in closed form — the
+        first index at or below the threshold IS the sigma the last pre-shift step lands on.
+        Returned cut/restart values are the schedule's own float32 entries, so the sigma
+        pass 2 re-enters at is exactly the one _anchor_shift_renoise rebuilds the state for.
         """
         if not isinstance(sigmas, torch.Tensor) or sigmas.numel() < 3:
             return None
@@ -3087,7 +3143,9 @@ class FunPackLTXAVSceneChainSampler:
         first, second, resume = sigmas[:cut + 1], sigmas[start:], start == cut
         if first.numel() < 2 or second.numel() < 2:
             return None
-        return first, second, vals[cut], vals[start], resume
+        # `start` goes back to the caller too: it is pass 2's offset into the real schedule,
+        # which the sampler needs to keep its phase boundaries where the schedule put them.
+        return first, second, vals[cut], vals[start], resume, start
 
     def _anchor_shift_renoise(self, latent, from_sigma, to_sigma, seed, reset_indices=()):
         """Move a latent that sits mid-trajectory at `from_sigma` back up to `to_sigma`.
@@ -5534,10 +5592,14 @@ class FunPackLTXAVSceneChainSampler:
                     if _shift_split is None:
                         run_mechanisms.append(f"anchor_shift(SKIPPED: {_reason})")
                 if _shift_split is not None:
-                    _sig_a, _sig_b, _cut_at, _restart_at, _resume = _shift_split
+                    _sig_a, _sig_b, _cut_at, _restart_at, _resume, _restart_idx = _shift_split
+                    # Both passes are slices of THIS schedule. Hand the sampler the real thing
+                    # plus where each slice starts, so the quality phase, final-correction
+                    # window, AB2 ramp, pulse anchors and eta decay stay where the schedule
+                    # puts them instead of being re-derived inside each half.
                     _pass1 = self._sample_chunk(
                         model, sampler, _sig_a, scene_seed, cfg, scene_positive, scene_negative,
-                        chunk, **_sample_kwargs)
+                        chunk, schedule_context={"sigmas": sigmas, "offset": 0}, **_sample_kwargs)
                     _shifted, _dropped = self._anchor_shift_latent(
                         _pass1, _shift_drop, anchor_shift_tail, anchor_shift_fresh_audio)
                     if not _resume:
@@ -5556,6 +5618,7 @@ class FunPackLTXAVSceneChainSampler:
                     _kw2 = dict(_sample_kwargs)
                     _kw2["step_offset"] = _sample_kwargs["step_offset"] + (_sig_a.numel() - 1)
                     _kw2["continue_from_state"] = True
+                    _kw2["schedule_context"] = {"sigmas": sigmas, "offset": _restart_idx}
                     sampled = self._sample_chunk(
                         model, sampler, _sig_b, scene_seed + 4242, cfg, scene_positive,
                         scene_negative, _shifted, **_kw2)
diff --git a/tests/test_anchor_shift.py b/tests/test_anchor_shift.py
index 3bca6063..c0a185e0 100644
--- a/tests/test_anchor_shift.py
+++ b/tests/test_anchor_shift.py
@@ -55,7 +55,7 @@ def _latent(frames=10, audio=True):
 # ── schedule splitting ──────────────────────────────────────────────────────
 
 def test_continue_mode_stops_at_the_cut_and_resumes_from_that_state():
-    first, second, cut_at, restart_at, resume = _node()._anchor_shift_split_sigmas(
+    first, second, cut_at, restart_at, resume, start_idx = _node()._anchor_shift_split_sigmas(
         SCHEDULE, 0.909, 0.0)
     # float32: the schedule stores 0.909 as 0.90899997, so compare loosely.
     assert abs(cut_at - 0.909) < 1e-5 and abs(restart_at - 0.909) < 1e-5
@@ -72,7 +72,7 @@ def test_continue_mode_stops_at_the_cut_and_resumes_from_that_state():
 def test_rewind_mode_still_stops_pass_one_at_the_cut():
     """The cut sigma is the whole feature — rewind must NOT override it. Pass 1 stops
     where the user asked, and the restart only decides where pass 2 re-enters."""
-    first, second, cut_at, restart_at, resume = _node()._anchor_shift_split_sigmas(
+    first, second, cut_at, restart_at, resume, start_idx = _node()._anchor_shift_split_sigmas(
         SCHEDULE, 0.725, 0.975)
     assert abs(cut_at - 0.725) < 1e-5 and abs(restart_at - 0.975) < 1e-5
     assert [round(v, 3) for v in first.tolist()] == [1.0, 0.975, 0.909, 0.725]
@@ -89,12 +89,60 @@ def test_rewind_refuses_a_restart_below_the_cut():
 
 def test_restart_landing_on_the_cut_is_just_continue():
     """A restart that snaps to the cut's own step has nothing to re-noise."""
-    _, _, cut_at, restart_at, resume = _node()._anchor_shift_split_sigmas(
+    _, _, cut_at, restart_at, resume, _ = _node()._anchor_shift_split_sigmas(
         SCHEDULE, 0.909, 0.909)
     assert abs(cut_at - restart_at) < 1e-5
     assert resume is True
 
 
+# ── the sampler must still see the REAL schedule ────────────────────────────
+
+# The user's own 9-step schedule, used here because the boundary walk has to be right on
+# the schedule they actually run, not on the toy one above.
+USER_SCHEDULE = torch.tensor(
+    [1.0, 0.955, 0.893, 0.812, 0.715, 0.603, 0.482, 0.241, 0.121, 0.0])
+
+
+def test_cut_is_the_step_whose_next_sigma_crosses_the_threshold():
+    """Walk the real schedule: the last pre-shift step is the one whose NEXT sigma has
+    crossed the shift point. At shift 0.482 the steps at 1.000 and 0.955 both have a next
+    sigma still above it and proceed; the step at 0.603 has next=0.482, so it is the last."""
+    first, second, cut_at, restart_at, resume, start_idx = _node()._anchor_shift_split_sigmas(
+        USER_SCHEDULE, 0.482, 0.812)
+    assert [round(v, 3) for v in first.tolist()] == [1.0, 0.955, 0.893, 0.812, 0.715, 0.603, 0.482]
+    assert abs(cut_at - 0.482) < 1e-5
+    # Pass 2 re-enters at 0.812, which is index 3 of the real schedule.
+    assert start_idx == 3
+    assert abs(restart_at - 0.812) < 1e-5
+    assert [round(v, 3) for v in second.tolist()] == [0.812, 0.715, 0.603, 0.482, 0.241, 0.121, 0.0]
+    assert resume is False
+
+
+def test_schedule_view_hands_the_sampler_the_whole_schedule():
+    """Without this the sampler measures its phases from the SLICE: the final-correction
+    window reopens at the end of pass 1, the AB2 ramp restarts, and the velocity-bias
+    ratio is taken against the slice's own first sigma instead of the schedule's."""
+    slice_ = USER_SCHEDULE[3:]
+    sched, offset = samplers._schedule_view(
+        slice_, {"sigmas": USER_SCHEDULE, "offset": 3})
+    assert sched is USER_SCHEDULE and offset == 3
+    # Concretely: 9 real steps, not the 6 the slice would have claimed.
+    assert len(sched) - 1 == 9 and len(slice_) - 1 == 6
+
+
+def test_schedule_view_falls_back_to_the_sigmas_it_was_given():
+    """Every normal single-call run passes no context — `sigmas` IS the whole schedule."""
+    for ctx in (None, {}, {"sigmas": None}, {"sigmas": torch.tensor([1.0])}, "nonsense"):
+        sched, offset = samplers._schedule_view(USER_SCHEDULE, ctx)
+        assert sched is USER_SCHEDULE and offset == 0
+
+
+def test_schedule_view_never_returns_a_negative_offset():
+    sched, offset = samplers._schedule_view(
+        USER_SCHEDULE, {"sigmas": USER_SCHEDULE, "offset": -5})
+    assert offset == 0
+
+
 # ── the mid-trajectory re-noise ─────────────────────────────────────────────
 
 class _FakeNested(list):

From 9f7e8bb3c68b420a0291bf16a73c4e99115f98d9 Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Fri, 31 Jul 2026 13:15:01 +0300
Subject: [PATCH 17/29] =?UTF-8?q?anchor=5Fshift:=20add=20tail=3Dcrop=20?=
 =?UTF-8?q?=E2=80=94=20no=20regrown=20tail,=20the=20clip=20just=20ends=20e?=
 =?UTF-8?q?arlier?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

User's idea, as an OPTION (default stays extend_last). The three existing tail modes
all refill the freed end so the clip keeps its length, which means pass 2 has to invent
an ending and blend a joint — the source of the "thin ending" and of most of the reason
to reach for a rewind restart. 'crop' regrows nothing: the scene ends anchor_shift_frames
earlier and every surviving frame was generated as part of one continuous shot.

Checked the model side before assuming this was free, since a bad latent size would
mismatch rather than degrade:
- LTXAV's video patchifier is SymmetricPatchifier(1) -> temporal patch size 1, so there
  is no divisibility rule on video latent frames.
- The streams reach the transformer as independent tensors (separate_audio_and_video_
  latents just unbinds the list); no video:audio ratio is enforced there.
- comfy re-packs per sample_custom call and re-derives latent_shapes, and the denoise
  masks off them (comfy/samplers.py outer_sample), so nothing is baked in from
  scene-build time and a shorter latent needs no conditioning rebuild.
- VAE decode is (f-1)*time_scale+1 for any f >= 1.
So no size is rejected. What IS real is proportion: audio timings come from the audio
stream's own index and video's from its own RoPE, so cropping the two by different
amounts of TIME desyncs the clip silently — no error, just drifting sound. Each extra
stream's KEPT length is therefore derived from the new video length directly rather than
by subtracting a separately-rounded drop, so rounding cannot leave them describing clips
of different durations. fresh_audio zeroes after the crop, at the new length.

Downstream needed nothing: _prepend_soft_continuation already clamps to the previous
scene's real length and _derived_overlap clamps to the stream, so a shorter scene flows
through the chain as-is.

The scene report now states the cropped length in latent frames and in real frames,
because a scene coming out shorter than the length that was set must never be something
the user has to infer from the output.

Tests: crop shortens instead of refilling and the surviving frames are the untouched
originals; audio/video stay in proportion (including four rates that do not divide
evenly); fresh_audio resets at the cropped length; the other three modes still keep the
clip length. Suite at baseline: 22 pre-existing failures, 288 passing (+5).

Verified live in the running app: the Engine ▸ Experimental dropdown offers
extend_last/wrap/empty/crop, default unchanged, hint present.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 movie_editor/frontend/engine_settings.js |  4 +-
 samplers.py                              | 72 +++++++++++++++++++-----
 tests/test_anchor_shift.py               | 57 +++++++++++++++++++
 3 files changed, 118 insertions(+), 15 deletions(-)

diff --git a/movie_editor/frontend/engine_settings.js b/movie_editor/frontend/engine_settings.js
index 6e646bad..896f55bc 100644
--- a/movie_editor/frontend/engine_settings.js
+++ b/movie_editor/frontend/engine_settings.js
@@ -234,8 +234,8 @@
       hint: "How much of the front to drop at the shift, in real frames. 8 (one latent frame) removes just the anchor itself, which is usually not enough — the anchor is followed by a settling-in stretch where the shot is still leaving the reference still and little is happening, and on a prompt asking for immediate action that dead time is exactly what you want gone. 48 was the value that worked on a 768×768×305@30 chain with a quick-cut prompt; treat that as a starting point for this pipeline rather than a universal default. Raise it if the opening still looks like it departed from a photo. The clip doesn't get shorter — whatever is dropped here is regrown at the end by pass 2." },
     { name: "anchor_shift_restart_sigma", label: "Pass 2 restart sigma", kind: "float", default: 0.0, min: 0.0, max: 0.999, step: 0.001, dependsOn: "anchor_shift",
       hint: "Where pass 2 re-enters the schedule after the shift. Pass 1 always stops at the shift sigma either way — this only decides where the second half picks up. 0 (default) = CONTINUE: resume from exactly the state pass 1 handed over, nothing added, cost stays one full schedule. Above the shift sigma = REWIND: the shifted latent is re-noised from the cut back up to this sigma, then denoised down again — much more freedom to rebuild the regrown tail and blend the joint, at the cost of repeating those steps and partly overwriting what pass 1 established. The re-noise is exact for a half-denoised latent (it rebuilds the state at the higher sigma from what pass 1 produced plus a matched top-up of fresh noise), not the naive img2img re-noise that caused the under-denoising in the first live run. BELOW the shift sigma is refused: noise can be added back, never removed. Try a step or two above the cut if continue leaves a visible seam or a thin ending." },
-    { name: "anchor_shift_tail", label: "Regrown tail starts from", kind: "combo", choices: ["extend_last", "wrap", "empty"], default: "extend_last", dependsOn: "anchor_shift",
-      hint: "What fills the freed end after the slide. 'extend_last' (default) repeats the final frame so pass 2 grows the new ending out of something continuous with it. 'wrap' puts the dropped head back at the end — continuous, but it re-shows the reference image at the END of the clip. 'empty' zeroes it and lets pass 2 generate freely — most freedom, most likely to drift from the rest of the shot." },
+    { name: "anchor_shift_tail", label: "Regrown tail starts from", kind: "combo", choices: ["extend_last", "wrap", "empty", "crop"], default: "extend_last", dependsOn: "anchor_shift",
+      hint: "What fills the freed end after the slide. 'extend_last' (default) repeats the final frame so pass 2 grows the new ending out of something continuous with it. 'wrap' puts the dropped head back at the end — continuous, but it re-shows the reference image at the END of the clip. 'empty' zeroes it and lets pass 2 generate freely — most freedom, most likely to drift from the rest of the shot. 'crop' regrows NOTHING: the scene simply ends 'Frames to drop' earlier and comes out SHORTER than the length you set. It is the only mode with no invented ending and no joint to blend — every surviving frame was generated as part of one continuous shot — so it removes the thin-ending failure the other three can produce, and makes a rewind restart much less necessary. Audio is cropped to match. Use it when the shot matters more than the exact duration; avoid it when a scene has to hit a specific length. The scene report states the new length." },
     { name: "anchor_shift_fresh_audio", label: "Regenerate audio in pass 2", kind: "bool", default: true, dependsOn: "anchor_shift",
       hint: "Reset the audio to an empty latent before pass 2 so it's written fresh against the shifted picture. On by default because pass 1's audio was formed against frames that no longer sit at those positions. Turn off only to A/B whether the carried audio actually sounds better." },
     { name: "context_windows", label: "Context windows (long scenes)", kind: "bool", default: false,
diff --git a/samplers.py b/samplers.py
index 8ed1efa5..dda9d885 100644
--- a/samplers.py
+++ b/samplers.py
@@ -2536,9 +2536,9 @@ class FunPackLTXAVSceneChainSampler:
                     "default": 0.0, "min": 0.0, "max": 0.999, "step": 0.001,
                     "tooltip": "Where pass 2 re-enters the schedule after the shift. Pass 1 always stops at anchor_shift_sigma either way — this only decides where the second half picks up. 0 (default) = CONTINUE: resume from exactly the state pass 1 handed over, nothing added, total cost stays one full schedule. A value ABOVE anchor_shift_sigma = REWIND: the shifted latent is re-noised from the cut back up to this sigma, then denoised down again, giving the model far more freedom to rebuild the regrown tail and blend the joint — at the cost of repeating those steps (and of partly overwriting what pass 1 established). The re-noise is exact for a mid-trajectory latent (it rebuilds x at the higher sigma from the latent it already has plus a matched top-up of fresh noise), NOT the naive img2img re-noise, which assumes a finished image and is what caused the under-denoising in the first live run. A value BELOW anchor_shift_sigma is refused: noise can be added back, never removed. Try rewind (a step or two above the cut) if continue leaves a visible seam or a thin ending.",
                 }),
-                "anchor_shift_tail": (["extend_last", "wrap", "empty"], {
+                "anchor_shift_tail": (["extend_last", "wrap", "empty", "crop"], {
                     "default": "extend_last",
-                    "tooltip": "What the freed tail starts from after the slide. 'extend_last' (default) repeats the final frame, so pass 2 grows the new ending out of content that is already continuous with it. 'wrap' puts the dropped head back at the end (Mobius) — cheap and continuous, but it re-shows the reference image at the END of the clip, which is usually not what you want. 'empty' zeros the region and lets pass 2's noise scaling generate it from scratch — most freedom, most likely to drift from the rest of the shot.",
+                    "tooltip": "What the freed tail starts from after the slide. 'extend_last' (default) repeats the final frame, so pass 2 grows the new ending out of content that is already continuous with it. 'wrap' puts the dropped head back at the end (Mobius) — cheap and continuous, but it re-shows the reference image at the END of the clip, which is usually not what you want. 'empty' zeros the region and lets pass 2's noise scaling generate it from scratch — most freedom, most likely to drift from the rest of the shot. 'crop' regrows NOTHING: the clip simply ends anchor_shift_frames earlier, so the scene comes out shorter than the length you asked for. That is the only mode with no invented ending and no joint to blend — every frame that survives was generated as part of one continuous shot — so it removes the 'thin ending' failure the other three can produce, and it makes the extra freedom of a rewind restart much less necessary. Audio is cropped by the matching amount. Pick it when the shot mattering more than the exact duration is fine (the montage just gets a shorter clip); avoid it when a scene has to hit an exact length.",
                 }),
                 "anchor_shift_fresh_audio": ("BOOLEAN", {
                     "default": True,
@@ -3188,9 +3188,12 @@ class FunPackLTXAVSceneChainSampler:
     def _anchor_shift_latent(self, latent, drop, tail_mode, fresh_audio):
         """Slide the video stream left by `drop` latent frames and refill the freed tail.
 
-        The head frames (anchor + settling-in region) are dropped, not cropped: the clip
-        keeps its full length, so no extra frames are ever generated to pay for this. The
-        freed tail is what pass 2 will grow into; `tail_mode` picks what it starts from.
+        The head frames (anchor + settling-in region) are dropped. In the three refilling
+        modes the clip keeps its full length, so no extra frames are ever generated to pay
+        for this, and `tail_mode` picks what the freed tail starts from. In "crop" there is
+        no tail at all: the clip is simply that much shorter, which is the only mode where
+        pass 2 never has to invent an ending or blend a joint.
+
         Audio is optionally reset to an empty latent so pass 2 writes it fresh against the
         shifted picture instead of inheriting pass 1's audio, which was scored against
         frames that no longer exist at those positions.
@@ -3203,13 +3206,42 @@ class FunPackLTXAVSceneChainSampler:
         if drop <= 0:
             return result, 0
         head, body = video[:, :, :drop], video[:, :, drop:]
-        if tail_mode == "wrap":
-            tail = head  # Mobius: the dropped head reappears at the end
-        elif tail_mode == "extend_last":
-            tail = body[:, :, -1:].repeat(1, 1, drop, 1, 1)
-        else:  # "empty": zeros, so pass 2's noise scaling starts that region from noise
-            tail = torch.zeros_like(head)
-        tensors[0] = torch.cat([body, tail], dim=2)
+        if tail_mode == "crop":
+            # No regrown tail — the clip just gets shorter.
+            #
+            # Nothing downstream constrains the new size: LTXAV's video patchifier has
+            # temporal patch size 1 (SymmetricPatchifier(1) -> no divisibility rule on
+            # latent frames), the streams reach the transformer as independent tensors with
+            # no enforced video:audio ratio, and comfy re-packs and re-derives latent_shapes
+            # (and the denoise masks off them) from whatever latent it is handed on the next
+            # sample_custom call — so a shorter latent needs nothing rebuilt.
+            #
+            # What DOES matter is proportion. Audio timings come from the audio stream's own
+            # index and video's from its own RoPE, so cropping the two by different amounts
+            # of TIME desynchronises them silently — no error, just sound that drifts. Each
+            # extra stream's kept length is therefore derived from the new VIDEO length
+            # directly, not by subtracting a separately-rounded drop, so rounding cannot
+            # leave the streams describing clips of different durations.
+            tensors[0] = body
+            kept = frames - drop
+            for _idx in range(1, len(tensors)):
+                _t = tensors[_idx]
+                if _t is None:
+                    continue
+                _n = self._tensor_frames(_t)
+                _keep = max(1, min(_n, int(round(_n * kept / max(1, frames)))))
+                if _keep < _n:
+                    tensors[_idx] = _t[:, :, _n - _keep:]
+        else:
+            if tail_mode == "wrap":
+                tail = head  # Mobius: the dropped head reappears at the end
+            elif tail_mode == "extend_last":
+                tail = body[:, :, -1:].repeat(1, 1, drop, 1, 1)
+            else:  # "empty": zeros, so pass 2's noise scaling starts that region from noise
+                tail = torch.zeros_like(head)
+            tensors[0] = torch.cat([body, tail], dim=2)
+        # After any cropping: the reset writes zeros at whatever length the stream now has,
+        # which is what defines the clip's audio duration.
         if fresh_audio and len(tensors) > 1 and tensors[1] is not None:
             tensors[1] = torch.zeros_like(tensors[1])
         if self._is_nested(result.get("samples")):
@@ -5623,11 +5655,25 @@ class FunPackLTXAVSceneChainSampler:
                         model, sampler, _sig_b, scene_seed + 4242, cfg, scene_positive,
                         scene_negative, _shifted, **_kw2)
                     _pinned_n = self._anchor_pinned_frames(chunk)
+                    # tail=crop makes the scene SHORTER than the length that was asked for.
+                    # That is the mode's whole point, but it must never be something the user
+                    # has to infer from the output — say it in the report, in latent frames
+                    # and in the real frames they set.
+                    _tail_note = ""
+                    if anchor_shift_tail == "crop":
+                        try:
+                            _before = self._tensor_frames(self._latent_tensors(_pass1)[0])
+                            _after = self._tensor_frames(self._latent_tensors(sampled)[0])
+                            _tail_note = (f", CROPPED to {_after} of {_before} latent frames "
+                                          f"(~{int(anchor_shift_frames)} real frames shorter — "
+                                          f"no tail regrown)")
+                        except Exception:
+                            _tail_note = ", CROPPED (no tail regrown)"
                     run_mechanisms.append(
                         f"anchor_shift({'continue' if _resume else 'rewind'} "
                         f"cut@{_cut_at:g} restart@{_restart_at:g}, "
                         f"dropped {_dropped} of {_pinned_n} pinned latent frames, "
-                        f"tail={anchor_shift_tail}"
+                        f"tail={anchor_shift_tail}{_tail_note}"
                         f"{', fresh audio' if anchor_shift_fresh_audio else ''})")
                     if _dropped < _pinned_n:
                         # Part of the anchor survives the slide and stays visible in the clip —
diff --git a/tests/test_anchor_shift.py b/tests/test_anchor_shift.py
index c0a185e0..c92b8cdc 100644
--- a/tests/test_anchor_shift.py
+++ b/tests/test_anchor_shift.py
@@ -323,6 +323,63 @@ def test_source_latent_is_never_mutated():
     assert torch.equal(latent["samples"], before)
 
 
+# ── tail=crop: no regrown tail, the clip just gets shorter ──────────────────
+
+def _av_latent(video_frames=10, audio_frames=20):
+    """A packed-style AV latent: video [B,C,F,H,W] + audio [B,C,T] at its own rate."""
+    video = torch.arange(video_frames, dtype=torch.float32).view(
+        1, 1, video_frames, 1, 1).repeat(1, 4, 1, 2, 2)
+    audio = torch.arange(audio_frames, dtype=torch.float32).view(1, 1, audio_frames).repeat(1, 4, 1)
+    return {"samples": _FakeNested([video, audio]), "noise_mask": torch.zeros_like(video)}
+
+
+def test_crop_shortens_the_clip_instead_of_regrowing_a_tail(renoise_stubs):
+    shifted, dropped = _node()._anchor_shift_latent(_latent(frames=10), 3, "crop", False)
+    assert dropped == 3
+    # 10 - 3, not 10: nothing is invented at the end, which is the whole point of the mode.
+    assert shifted["samples"].shape[2] == 7
+    # And what survives is the ORIGINAL frames 3..9, untouched — no blend, no joint.
+    assert [int(v) for v in shifted["samples"][0, 0, :, 0, 0]] == [3, 4, 5, 6, 7, 8, 9]
+
+
+def test_crop_keeps_audio_and_video_describing_the_same_duration(renoise_stubs):
+    """Audio timing comes from the audio stream's own index and video's from its own RoPE,
+    so cropping them by different amounts of TIME desyncs the clip silently — no error,
+    just drifting sound. The kept lengths must stay in proportion."""
+    shifted, _ = _node()._anchor_shift_latent(_av_latent(10, 20), 3, "crop", False)
+    video, audio = shifted["samples"].unbind()
+    assert video.shape[2] == 7 and audio.shape[2] == 14      # 7/10 == 14/20
+    # Cropped from the HEAD, matching the video slide — the tail is what survives.
+    assert [int(v) for v in audio[0, 0]] == list(range(6, 20))
+
+
+def test_crop_keeps_proportion_when_the_rate_does_not_divide_evenly(renoise_stubs):
+    """The rounding trap: deriving audio's KEPT length from the new video length keeps the
+    two in proportion; subtracting a separately-rounded drop can leave them a frame apart."""
+    for v_frames, a_frames, drop in ((10, 15, 3), (9, 14, 4), (13, 7, 5), (10, 21, 7)):
+        shifted, _ = _node()._anchor_shift_latent(_av_latent(v_frames, a_frames), drop, "crop", False)
+        video, audio = shifted["samples"].unbind()
+        assert audio.shape[2] == max(1, round(a_frames * video.shape[2] / v_frames))
+        assert audio.shape[2] >= 1 and video.shape[2] >= 1
+
+
+def test_crop_still_resets_audio_when_asked_at_the_cropped_length(renoise_stubs):
+    """fresh_audio zeroes the stream AFTER the crop, so the reset length is the new
+    duration — zeroing first would leave the clip's audio length describing the old one."""
+    shifted, _ = _node()._anchor_shift_latent(_av_latent(10, 20), 4, "crop", True)
+    video, audio = shifted["samples"].unbind()
+    assert video.shape[2] == 6 and audio.shape[2] == 12
+    assert torch.count_nonzero(audio) == 0
+
+
+def test_the_other_tail_modes_still_keep_the_clip_length(renoise_stubs):
+    """crop is an OPTION — the three refilling modes must be untouched by it."""
+    for mode in ("extend_last", "wrap", "empty"):
+        shifted, _ = _node()._anchor_shift_latent(_av_latent(10, 20), 3, mode, False)
+        video, audio = shifted["samples"].unbind()
+        assert video.shape[2] == 10 and audio.shape[2] == 20, mode
+
+
 # ── the t2v guard ───────────────────────────────────────────────────────────
 
 def test_pinned_frames_counts_the_anchor_prefix():

From 71e001afff6df127dff73790d6604f92f2c67a0b Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Fri, 31 Jul 2026 13:25:56 +0300
Subject: [PATCH 18/29] anchor_shift: sigma 0 = no second pass, just cut the
 head off the finished clip
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Reported by the user: setting the shift sigma to 1 or 0 with restart 0 got them
nowhere, and what they wanted was "generate me a full video and don't make the 2nd
pass, just cut off the beginning".

That was a gap, not a crash. Both extremes fell through to the splitter, which
correctly refused (a cut at the first sigma leaves pass 1 no step; a cut at the last
leaves pass 2 none) and reported a skip — so anchor_shift silently did nothing and
the skip reason did not name the thing they were actually after.

anchor_shift_sigma=0 now means it: a cut at sigma 0 IS the end of the schedule, so
pass 1 is the entire run and there is nothing left to denoise. The scene samples
exactly as if anchor_shift were off — anchor pinned at full strength the whole way,
which is the point — and the slide is applied to the FINISHED latent. Zero extra
sampling: the cheapest form of this feature by a wide margin, and with tail=crop it
is plainly "generate the video, then delete the opening". Widget min lowered 0.05 -> 0.

Two things are refused rather than half-worked, each naming its fix:
- tail=extend_last / empty, because with no second pass a refilled tail is never
  denoised — extend_last would freeze the last frame for anchor_shift_frames and
  empty would leave an empty latent on screen. crop and wrap are pure rearrangements
  of finished content, so both are allowed.
- a non-zero restart sigma, which has nothing to restart.
And anchor_shift_fresh_audio is forced off in this mode (reported, not silent):
resetting the audio with nothing left to regenerate it would just produce a silent
clip.

The old "schedule never reaches ..." skip reason now points at sigma=0 as the way to
run the whole schedule and only cut the head, so the next person hitting the extreme
is told what to set.

Suite at baseline: 22 pre-existing failures, 289 passing.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 movie_editor/frontend/engine_settings.js |  4 +-
 samplers.py                              | 71 ++++++++++++++++++++++--
 tests/test_anchor_shift.py               |  9 +++
 3 files changed, 78 insertions(+), 6 deletions(-)

diff --git a/movie_editor/frontend/engine_settings.js b/movie_editor/frontend/engine_settings.js
index 896f55bc..5bb5c300 100644
--- a/movie_editor/frontend/engine_settings.js
+++ b/movie_editor/frontend/engine_settings.js
@@ -228,8 +228,8 @@
       hint: "How much noise the crop gets re-noised to before its 3-step refine (0.85 is the official LTX 2.3 recipe's own value). Higher = more freedom to genuinely reconstruct the region (fix bad anatomy), risking drift from the surrounding frame; lower = closer to a plain upscale — looks 'detailed' as interpolation but doesn't actually repair it. If the result looks upscaled but not corrected, raise this. Only used in 'repair' mode." },
     { name: "anchor_shift", label: "Anchor shift (fake t2v)", kind: "bool", default: false,
       hint: "EXPERIMENTAL: keep the real, untouched i2v anchor — then delete it from the clip. The anchor is a pinned frame at position 0, so it holds character detail, style and composition better than anything that weakens it on the way in (ALG blurs it and loses detail; Best-FaceID tokens approximate it and lose some too), but it is also literally the first frame you see. This runs pass 1 down to the sigma below with the anchor pinned as normal, drops the first frames and slides everything left (clip length unchanged — no extra frames generated), then finishes the schedule with the pin gone. The result is an i2v generation that reads as t2v. Pass 2 always re-enters at the exact latent state for its first sigma, which is what keeps the shifted latent on-manifold. Skipped on continuation scenes and on scenes carrying guide frames or JoyAI audio memory, with the reason in the scene report. Validated live in continue mode." },
-    { name: "anchor_shift_sigma", label: "Shift at sigma", kind: "float", default: 0.909, min: 0.05, max: 0.999, step: 0.001, dependsOn: "anchor_shift",
-      hint: "The knob this feature exists to let you tune, in both modes. Pass 1 runs until the schedule first reaches this sigma, then the shift happens. 0.909 is where structure actually starts forming on the distilled schedule (1.0 and 0.975 are near-pure noise and carry almost no signal), so it's the earliest cut where the anchor has plausibly transferred anything — a starting guess, not a measured value. Higher = released sooner and cheaper, but the reference may never have landed. Lower = held longer, but more of pass 1's picture is thrown away by the slide and fewer steps remain to repair it." },
+    { name: "anchor_shift_sigma", label: "Shift at sigma", kind: "float", default: 0.909, min: 0.0, max: 0.999, step: 0.001, dependsOn: "anchor_shift",
+      hint: "The knob this feature exists to let you tune, in both modes. SET IT TO 0 for no second pass at all: the whole schedule runs exactly as if anchor shift were off (anchor pinned at full strength the whole way), and the head is then cut off the finished clip — zero extra sampling, and with 'Regrown tail starts from' = crop it is simply 'generate the video, then delete the opening'. At 0 the tail must be crop or wrap (nothing would denoise a refilled tail) and 'Regenerate audio in pass 2' is ignored. Above 0, pass 1 runs until the schedule first reaches this sigma, then the shift happens. 0.909 is where structure actually starts forming on the distilled schedule (1.0 and 0.975 are near-pure noise and carry almost no signal), so it's the earliest cut where the anchor has plausibly transferred anything — a starting guess, not a measured value. Higher = released sooner and cheaper, but the reference may never have landed. Lower = held longer, but more of pass 1's picture is thrown away by the slide and fewer steps remain to repair it." },
     { name: "anchor_shift_frames", label: "Frames to drop", kind: "int", default: 8, min: 8, max: 512, step: 8, dependsOn: "anchor_shift",
       hint: "How much of the front to drop at the shift, in real frames. 8 (one latent frame) removes just the anchor itself, which is usually not enough — the anchor is followed by a settling-in stretch where the shot is still leaving the reference still and little is happening, and on a prompt asking for immediate action that dead time is exactly what you want gone. 48 was the value that worked on a 768×768×305@30 chain with a quick-cut prompt; treat that as a starting point for this pipeline rather than a universal default. Raise it if the opening still looks like it departed from a photo. The clip doesn't get shorter — whatever is dropped here is regrown at the end by pass 2." },
     { name: "anchor_shift_restart_sigma", label: "Pass 2 restart sigma", kind: "float", default: 0.0, min: 0.0, max: 0.999, step: 0.001, dependsOn: "anchor_shift",
diff --git a/samplers.py b/samplers.py
index dda9d885..83feda18 100644
--- a/samplers.py
+++ b/samplers.py
@@ -2525,8 +2525,8 @@ class FunPackLTXAVSceneChainSampler:
                     "tooltip": "EXPERIMENTAL: let the i2v anchor condition the scene, then delete it from the clip. The anchor is a pinned latent frame at position 0 — it holds identity/style/composition all the way down the schedule, and it is also literally the first frame you see, so every i2v scene opens on the exact reference still. This splits the schedule: pass 1 runs down to anchor_shift_sigma with the anchor pinned as usual, then the first anchor_shift_frames frames are DROPPED and everything slides left (clip length unchanged — no extra frames are generated), then pass 2 finishes the schedule on the shifted latent with the pin gone. Pass 2 always re-enters at the exact latent state for its first sigma — resumed as-is, or re-noised up to anchor_shift_restart_sigma first — which keeps it on the rectified-flow manifold and is the reason this is two passes rather than a roll between steps. The whole experiment is WHERE to cut: above ~0.909 nothing has formed yet, so the anchor gets discarded before it has transferred anything; too low and pass 2 has no steps left to heal the seam. Off by default. Validated live in continue mode.",
                 }),
                 "anchor_shift_sigma": ("FLOAT", {
-                    "default": 0.909, "min": 0.05, "max": 0.999, "step": 0.001,
-                    "tooltip": "Sigma at which pass 1 stops and the shift happens — the knob this whole feature exists to let you tune, and it applies in BOTH modes. Pass 1 runs until the schedule first reaches a sigma at or below this. 0.909 is the step where structure actually starts forming on the LTX distilled schedule (1.0 and 0.975 are the near-pure-noise plateau and carry almost no signal), so it is the earliest cut where the anchor has plausibly transferred anything — but it is a starting guess, not a measured value. Higher = anchor released sooner, cheaper, more likely the reference never really landed. Lower = anchor held longer, more of pass 1's picture is thrown away by the shift and fewer steps remain to repair it. If the schedule never reaches this sigma, the pass is skipped with a note.",
+                    "default": 0.909, "min": 0.0, "max": 0.999, "step": 0.001,
+                    "tooltip": "Sigma at which pass 1 stops and the shift happens — the knob this whole feature exists to let you tune, and it applies in BOTH modes. SET IT TO 0 for no second pass at all: the whole schedule runs exactly as if anchor_shift were off (anchor pinned at full strength throughout), and the head is then cut off the finished clip. That is the cheapest form of this by far — zero extra sampling — and it pairs with anchor_shift_tail=crop as plain 'generate the video, then delete the opening'. It needs tail=crop or wrap, since with no second pass a refilled tail would never be denoised, and anchor_shift_fresh_audio is ignored (nothing would rewrite the audio). Above 0, pass 1 runs until the schedule first reaches a sigma at or below this. 0.909 is the step where structure actually starts forming on the LTX distilled schedule (1.0 and 0.975 are the near-pure-noise plateau and carry almost no signal), so it is the earliest cut where the anchor has plausibly transferred anything — but it is a starting guess, not a measured value. Higher = anchor released sooner, cheaper, more likely the reference never really landed. Lower = anchor held longer, more of pass 1's picture is thrown away by the shift and fewer steps remain to repair it. If the schedule never reaches this sigma, the pass is skipped with a note.",
                 }),
                 "anchor_shift_frames": ("INT", {
                     "default": 8, "min": 8, "max": 512, "step": 8,
@@ -5586,6 +5586,7 @@ class FunPackLTXAVSceneChainSampler:
                 # delete it from the clip instead of weakening it (ALG blurs the anchor and
                 # loses character detail; overlap tokens approximate it and lose some too).
                 _shift_split = None
+                _shift_post_only = False   # sigma 0: whole schedule, then shift, no pass 2
                 if anchor_shift:
                     _shift_drop = self._expected_latent_frames(
                         int(anchor_shift_frames) + 1, time_scale) - 1
@@ -5608,6 +5609,28 @@ class FunPackLTXAVSceneChainSampler:
                         # the "fake t2v" trick, it needs a real anchor to fake it WITH.
                         _reason = ("scene has no pinned i2v anchor (t2v scene) — nothing to shift; "
                                    "attach an anchor image, or leave anchor_shift off")
+                    elif float(anchor_shift_sigma) <= 0.0:
+                        # NO SECOND PASS: "generate the whole video normally, then just cut the
+                        # beginning off." A cut at sigma 0 IS the end of the schedule, so pass 1
+                        # is the entire run and there is nothing left to denoise — the shift
+                        # becomes a post-process on the finished latent and costs nothing at all.
+                        if float(anchor_shift_restart_sigma) > 0:
+                            _reason = (f"anchor_shift_sigma=0 means no second pass at all (the "
+                                       f"whole schedule runs, then the head is cut), so there is "
+                                       f"nothing for anchor_shift_restart_sigma="
+                                       f"{anchor_shift_restart_sigma:g} to restart. Set it to 0, "
+                                       f"or raise anchor_shift_sigma above 0 to cut mid-schedule")
+                        elif anchor_shift_tail in ("extend_last", "empty"):
+                            # Nothing runs after the slide, so a refilled tail is never denoised:
+                            # extend_last would freeze the last frame for anchor_shift_frames and
+                            # empty would leave an empty latent on screen. crop and wrap are pure
+                            # rearrangements of already-finished content, so they are fine.
+                            _reason = (f"anchor_shift_tail={anchor_shift_tail} needs a second pass "
+                                       f"to regrow the tail, and anchor_shift_sigma=0 means there "
+                                       f"is none — the refilled tail would never be denoised. Use "
+                                       f"'crop' (clip just ends earlier) or 'wrap'")
+                        else:
+                            _shift_post_only = True
                     elif 0 < float(anchor_shift_restart_sigma) < float(anchor_shift_sigma) - 1e-4:
                         # Pass 2 would claim the latent is cleaner than pass 1 left it.
                         # The re-noise can add noise back, never remove it.
@@ -5620,8 +5643,10 @@ class FunPackLTXAVSceneChainSampler:
                         _shift_split = self._anchor_shift_split_sigmas(
                             sigmas, anchor_shift_sigma, anchor_shift_restart_sigma)
                         _reason = (f"schedule never reaches anchor_shift_sigma="
-                                   f"{anchor_shift_sigma} with a step left on both sides")
-                    if _shift_split is None:
+                                   f"{anchor_shift_sigma} with a step left on both sides — the cut "
+                                   f"needs a real step on each side of it. Use anchor_shift_sigma=0 "
+                                   f"to run the whole schedule and only cut the head off instead")
+                    if _shift_split is None and not _shift_post_only:
                         run_mechanisms.append(f"anchor_shift(SKIPPED: {_reason})")
                 if _shift_split is not None:
                     _sig_a, _sig_b, _cut_at, _restart_at, _resume, _restart_idx = _shift_split
@@ -5682,6 +5707,44 @@ class FunPackLTXAVSceneChainSampler:
                             f"anchor_shift WARNING: {_pinned_n - _dropped} anchor latent frame(s) "
                             f"still in the clip — raise anchor_shift_frames to at least "
                             f"{_pinned_n * max(1, int(time_scale))}")
+                elif _shift_post_only:
+                    # No second pass: sample the scene exactly as if anchor_shift were off — the
+                    # anchor stays pinned for the whole schedule, which is the point (full-strength
+                    # identity transfer) — then slide the head off the FINISHED latent. Zero extra
+                    # sampling, so this is the cheapest form of the trick by a wide margin.
+                    _full = self._sample_chunk(
+                        model, sampler, sigmas, scene_seed, cfg, scene_positive, scene_negative,
+                        chunk, **_sample_kwargs)
+                    # fresh_audio is forced OFF here: it resets the audio for pass 2 to rewrite,
+                    # and with no pass 2 the reset would just leave the clip silent.
+                    sampled, _dropped = self._anchor_shift_latent(
+                        _full, _shift_drop, anchor_shift_tail, False)
+                    _pinned_n = self._anchor_pinned_frames(chunk)
+                    _tail_note = ""
+                    if anchor_shift_tail == "crop":
+                        try:
+                            _before = self._tensor_frames(self._latent_tensors(_full)[0])
+                            _after = self._tensor_frames(self._latent_tensors(sampled)[0])
+                            _tail_note = (f", CROPPED to {_after} of {_before} latent frames "
+                                          f"(~{int(anchor_shift_frames)} real frames shorter)")
+                        except Exception:
+                            _tail_note = ", CROPPED"
+                    run_mechanisms.append(
+                        f"anchor_shift(no second pass — full schedule then head cut, "
+                        f"dropped {_dropped} of {_pinned_n} pinned latent frames, "
+                        f"tail={anchor_shift_tail}{_tail_note})")
+                    if anchor_shift_fresh_audio:
+                        # The audio was written against the finished picture and nothing will
+                        # rewrite it, so a reset here would just leave the clip silent.
+                        run_mechanisms.append(
+                            "anchor_shift NOTE: anchor_shift_fresh_audio is ignored with no second "
+                            "pass — resetting the audio with nothing left to regenerate it would "
+                            "produce a silent clip, so pass 1's audio is kept.")
+                    if _dropped < _pinned_n:
+                        run_mechanisms.append(
+                            f"anchor_shift WARNING: {_pinned_n - _dropped} anchor latent frame(s) "
+                            f"still in the clip — raise anchor_shift_frames to at least "
+                            f"{_pinned_n * max(1, int(time_scale))}")
                 else:
                     sampled = self._sample_chunk(
                         model, sampler, sigmas, scene_seed, cfg, scene_positive, scene_negative,
diff --git a/tests/test_anchor_shift.py b/tests/test_anchor_shift.py
index c92b8cdc..053fc252 100644
--- a/tests/test_anchor_shift.py
+++ b/tests/test_anchor_shift.py
@@ -81,6 +81,15 @@ def test_rewind_mode_still_stops_pass_one_at_the_cut():
     assert resume is False
 
 
+def test_sigma_zero_is_refused_as_a_split_because_it_is_the_no_second_pass_mode():
+    """anchor_shift_sigma=0 must not produce a split — the cut IS the end of the schedule,
+    so there is no pass 2. The caller handles it as a post-process on the finished latent
+    ('generate the whole video, then cut the head off'); the splitter just declines."""
+    assert _node()._anchor_shift_split_sigmas(USER_SCHEDULE, 0.0, 0.0) is None
+    # The other end is genuinely unusable: a cut at the first sigma leaves pass 1 no step.
+    assert _node()._anchor_shift_split_sigmas(USER_SCHEDULE, 1.0, 0.0) is None
+
+
 def test_rewind_refuses_a_restart_below_the_cut():
     """Pass 2 can be handed a NOISIER latent, never a cleaner one — there is no way to
     remove noise from the state pass 1 stopped at."""

From b7fa3756f16f219a9a49f9fc62ac374b7639906f Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Fri, 31 Jul 2026 13:31:07 +0300
Subject: [PATCH 19/29] Chain Sampler: general "Enable second pass", with an
 optional separate schedule
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

anchor_shift built the two-pass machinery — stop the schedule, hand the state over,
re-enter exactly (_sample_chunk continue_from_state, _renoise_to_sigma, _schedule_view).
The user's point: that is generally useful, not anchor-specific. This exposes it on its
own, and keeps the two features independent as they asked: reaching the second_pass
branch means anchor_shift did not act on this scene, so they can never nest.

  second_pass                 stop partway and finish in a second pass
  second_pass_sigma           where pass 1 stops (walked against the real schedule)
  second_pass_restart_sigma   where pass 2 re-enters; 0 = carry straight on
  second_pass_sigmas          OPTIONAL SIGMAS socket: pass 2 runs THAT schedule instead

At restart 0 with no second schedule the split is behaviour-neutral by construction —
pass 2 resumes from the exact handed-over state, nothing added, and 5+4 steps on a
9-step schedule is still 9. It earns its keep when the second half is made different:
re-entering higher (the model reworks what it committed to) or finishing on a different
schedule entirely, so the tail can have its own step count, spacing or shift.

Two things a split gets silently wrong if you let it, both handled:
- The i2v anchor. _sample_chunk drops noise_mask from what it returns, so pass 2 would
  run UNPINNED and re-denoise the reference frame. anchor_shift wants exactly that;
  a plain second pass must not. _restore_pinned_prefix puts the mask back AND restores
  the pinned frames from the original chunk, since a rewind re-noise adds noise
  everywhere including frames that are meant to be frozen.
- The sampler's own phases. Pass 2's schedule_context is the alternate schedule at
  offset 0 when one is connected, or the main schedule at the slice offset when not —
  so quality steps / final-correction window / AB2 ramp are measured against whichever
  schedule pass 2 is actually running.

Every refusal names its fix (cut outside the schedule, entry below the cut, a
single-sigma SIGMAS input that is not a schedule) and lands in the scene report as
second_pass(SKIPPED: ...) — never a silent no-op.

Editor + Easy Gen get the three widgets under Engine > Experimental. The SIGMAS socket
is node-graph only for now: the Editor's fixed graph takes sigmas from ("studio", 5) and
has no second scheduler node, so exposing it there is a graph-topology change I have not
made unilaterally.

Latent/pixel-space pass-2 operations (sharpen, downscale->rescale, upscale) are next,
as opt-in options with nothing on by default.

New tests/test_second_pass.py: 10 tests over the split, the separate schedule, the
refusals and the pin. Suite at baseline: 22 pre-existing failures, 299 passing.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 movie_editor/frontend/engine_settings.js |   8 +-
 samplers.py                              | 180 ++++++++++++++++++++++-
 tests/test_anchor_shift.py               |  10 +-
 tests/test_second_pass.py                | 154 +++++++++++++++++++
 4 files changed, 338 insertions(+), 14 deletions(-)
 create mode 100644 tests/test_second_pass.py

diff --git a/movie_editor/frontend/engine_settings.js b/movie_editor/frontend/engine_settings.js
index 5bb5c300..0bbb8e00 100644
--- a/movie_editor/frontend/engine_settings.js
+++ b/movie_editor/frontend/engine_settings.js
@@ -238,6 +238,12 @@
       hint: "What fills the freed end after the slide. 'extend_last' (default) repeats the final frame so pass 2 grows the new ending out of something continuous with it. 'wrap' puts the dropped head back at the end — continuous, but it re-shows the reference image at the END of the clip. 'empty' zeroes it and lets pass 2 generate freely — most freedom, most likely to drift from the rest of the shot. 'crop' regrows NOTHING: the scene simply ends 'Frames to drop' earlier and comes out SHORTER than the length you set. It is the only mode with no invented ending and no joint to blend — every surviving frame was generated as part of one continuous shot — so it removes the thin-ending failure the other three can produce, and makes a rewind restart much less necessary. Audio is cropped to match. Use it when the shot matters more than the exact duration; avoid it when a scene has to hit a specific length. The scene report states the new length." },
     { name: "anchor_shift_fresh_audio", label: "Regenerate audio in pass 2", kind: "bool", default: true, dependsOn: "anchor_shift",
       hint: "Reset the audio to an empty latent before pass 2 so it's written fresh against the shifted picture. On by default because pass 1's audio was formed against frames that no longer sit at those positions. Turn off only to A/B whether the carried audio actually sounds better." },
+    { name: "second_pass", label: "Enable second pass", kind: "bool", default: false,
+      hint: "EXPERIMENTAL: stop the schedule partway and finish the scene in a second sampling pass. Separate from Anchor shift, which runs its own two passes — when that acts on a scene this is skipped with a note. On its own, at restart sigma 0, the split is behaviour-neutral: pass 2 resumes from exactly the state pass 1 handed over, nothing added, same step count, same output. It earns its keep when the second half is made DIFFERENT — re-entering higher up the schedule so the model reworks what it has. The i2v anchor stays pinned across the split, so the scene doesn't drift off its reference image. Cost is exactly the extra steps you add: at restart 0 it's free. UNVALIDATED LIVE." },
+    { name: "second_pass_sigma", label: "Second pass starts at sigma", kind: "float", default: 0.603, min: 0.001, max: 0.999, step: 0.001, dependsOn: "second_pass",
+      hint: "Where pass 1 stops. The schedule is walked and the last pass-1 step is the one whose next sigma has crossed this value, so the cut always lands on a real step in your schedule — only sigmas actually in the schedule are reachable, and a value outside its range is refused with a reason rather than ignored." },
+    { name: "second_pass_restart_sigma", label: "Pass 2 re-enters at sigma", kind: "float", default: 0.0, min: 0.0, max: 0.999, step: 0.001, dependsOn: "second_pass",
+      hint: "0 (default) = carry straight on from the cut: nothing is added and the total cost is unchanged. A value ABOVE the cut rewinds — the half-denoised latent is rebuilt at that higher sigma (exact for a mid-trajectory latent, not the naive img2img re-noise) and those steps run again, letting the model rework structure it already committed to, at the cost of repeating them. Below the cut is refused: noise can be added back, never removed." },
     { name: "context_windows", label: "Context windows (long scenes)", kind: "bool", default: false,
       hint: "EXPERIMENTAL: denoise a scene that's LONGER than the model's comfortable window as overlapping windows instead of one giant pass — ComfyUI core's own mechanism, audio-aware on LTX (it maps each video window to its audio window and re-slices anchors, guides and JoyAI memory per window). Engages only on scenes longer than the window length below; shorter scenes are untouched and pay nothing. Cost at the defaults (145/40) is about 1.45× the per-frame work, since each window re-does its 40-frame overlap — offset by attention getting cheaper the longer the scene is (quadratic in one pass, near-flat when windowed). Roughly break-even around 200 frames, a net win past ~300. Needs ComfyUI v0.29.0 or newer; on older builds it's skipped with a note in the scene report. UNVALIDATED LIVE." },
     { name: "context_window_length", label: "Window length (frames)", kind: "int", default: 145, min: 9, max: 2049, step: 8, dependsOn: "context_windows",
@@ -377,7 +383,7 @@
     chain_timing: ["frame_overlap", "transition_duration", "use_same_seed"],
     chain_guidance: ["cfg", "embed_guidance", "embed_guidance_source", "embed_guidance_strength", "score_slider", "score_slider_strength", "taste_nearest_prompt", "output_guidance", "output_guidance_strength", "dynashift", "dynashift_strength", "dynashift_threshold"],
     chain_decode: ["decode_noise_scale", "decode_timestep", "decode_tile_size"],
-    chain_experimental: ["anchor_shift", "anchor_shift_sigma", "anchor_shift_frames", "anchor_shift_restart_sigma", "anchor_shift_tail", "anchor_shift_fresh_audio", "context_windows", "context_window_length", "context_window_overlap", "context_window_schedule", "context_window_fuse", "context_window_freenoise", "context_window_retain_first", "plateau_cache", "plateau_cache_threshold", "segmented_detailing", "detail_targets", "detail_strength", "detail_threshold", "detail_max_area", "detail_mode", "detail_denoise", "mid_scene_guide", "mid_scene_guide_strength", "joyai_memory", "joyai_memory_size", "joyai_fix_frames", "joyai_frame_select", "joyai_memory_strength", "joyai_audio_memory", "v2a_grad_scale", "alg_blur_guides", "alg_guide_blur_strength", "alg_guide_blur_sigma_threshold", "bounded_attention_enabled", "identity_transfer_enabled", "source_id", "phase_scale", "id_strength", "arcface_mode", "debug_log"],
+    chain_experimental: ["anchor_shift", "anchor_shift_sigma", "anchor_shift_frames", "anchor_shift_restart_sigma", "anchor_shift_tail", "anchor_shift_fresh_audio", "second_pass", "second_pass_sigma", "second_pass_restart_sigma", "context_windows", "context_window_length", "context_window_overlap", "context_window_schedule", "context_window_fuse", "context_window_freenoise", "context_window_retain_first", "plateau_cache", "plateau_cache_threshold", "segmented_detailing", "detail_targets", "detail_strength", "detail_threshold", "detail_max_area", "detail_mode", "detail_denoise", "mid_scene_guide", "mid_scene_guide_strength", "joyai_memory", "joyai_memory_size", "joyai_fix_frames", "joyai_frame_select", "joyai_memory_strength", "joyai_audio_memory", "v2a_grad_scale", "alg_blur_guides", "alg_guide_blur_strength", "alg_guide_blur_sigma_threshold", "bounded_attention_enabled", "identity_transfer_enabled", "source_id", "phase_scale", "id_strength", "arcface_mode", "debug_log"],
   };
 
   function countChainView(p, id) {
diff --git a/samplers.py b/samplers.py
index 83feda18..d91bcb47 100644
--- a/samplers.py
+++ b/samplers.py
@@ -2572,6 +2572,25 @@ class FunPackLTXAVSceneChainSampler:
                     "default": False,
                     "tooltip": "Pin latent frame 0 (the i2v anchor) into EVERY window, in both the conditioning and the noise latent, instead of only the first window. Helps when later windows drift away from the reference image. Off by default because on a CONTINUATION scene frame 0 is the carried tail of the previous scene, not the anchor — pinning it there re-shows the same content in every window and can read as the scene going static. Turn it on if later windows lose the reference; turn it off if the scene stops moving.",
                 }),
+                # NOTE: append-only — keep new sampler widgets at the END of this block so the
+                # builder's positional reference-workflow mapping (extract_widgets) stays aligned.
+                "second_pass": ("BOOLEAN", {
+                    "default": False,
+                    "tooltip": "EXPERIMENTAL: stop the schedule partway and finish the scene in a SECOND sampling pass. Independent of anchor_shift (which runs its own two passes — when anchor_shift acts on a scene this is skipped, with a note). On its own the split is behaviour-neutral at second_pass_restart_sigma=0: pass 2 resumes from exactly the state pass 1 handed over, no noise added, same total step count, so the output matches a single pass. It becomes useful when the second half is made DIFFERENT — re-entering higher up the schedule (second_pass_restart_sigma) to let the model rework what it has, or finishing on a different schedule entirely (the second_pass_sigmas input). The i2v anchor stays pinned across the split, so the scene does not drift off its reference. Cost is exactly the extra steps you add: at restart 0 with no second schedule it is free; re-entering higher costs the replayed steps. Off by default. UNVALIDATED LIVE.",
+                }),
+                "second_pass_sigma": ("FLOAT", {
+                    "default": 0.603, "min": 0.001, "max": 0.999, "step": 0.001,
+                    "tooltip": "Where pass 1 stops. The schedule is walked and the last pass-1 step is the one whose NEXT sigma has crossed this value, so the cut always lands on a real schedule step — only the sigmas actually in your schedule are reachable. Both halves need at least one step, so a value outside the schedule's range is refused with a reason rather than silently ignored.",
+                }),
+                "second_pass_restart_sigma": ("FLOAT", {
+                    "default": 0.0, "min": 0.0, "max": 0.999, "step": 0.001,
+                    "tooltip": "Where pass 2 re-enters, when no second_pass_sigmas schedule is connected. 0 (default) = carry straight on from the cut: nothing is added, total cost unchanged. A value ABOVE second_pass_sigma rewinds — the half-denoised latent is rebuilt at that higher sigma (exact for a mid-trajectory latent, not the naive img2img re-noise) and those steps run again, letting the model rework structure it has already committed to, at the cost of repeating them. BELOW the cut is refused: noise can be added back, never removed. Ignored when second_pass_sigmas is connected, since that schedule's own first sigma is the entry point.",
+                }),
+                # A connection socket, never a widget — safe at the end, and it must stay after
+                # every widget above (see the widgets_values note at the top of this block).
+                "second_pass_sigmas": ("SIGMAS", {
+                    "tooltip": "Optional SEPARATE schedule for pass 2. Wire any scheduler here and pass 2 runs that schedule end to end instead of continuing along the main one — so the second half can have a different step count, spacing or shift from the first (e.g. a short, fine tail schedule over a coarse first pass). Its FIRST sigma is where pass 2 re-enters, so it must start at or above second_pass_sigma (the state can be re-noised back up, never un-noised down); second_pass_restart_sigma is ignored when this is connected. The sampler is told this schedule is pass 2's real schedule, so its own phases (quality steps, final-correction window, AB2 ramp) are measured against it rather than against the main one.",
+                }),
             },
             "hidden": {
                 "unique_id": "UNIQUE_ID",
@@ -3098,7 +3117,7 @@ class FunPackLTXAVSceneChainSampler:
         starts at the first sigma at or below restart_sigma (restart_sigma <= 0 means
         "continue from where pass 1 stopped") and runs to the end. When the restart sits
         above the cut, the shifted latent is re-noised back up to it (see
-        _anchor_shift_renoise); `resume` says which of the two the caller must do.
+        _renoise_to_sigma); `resume` says which of the two the caller must do.
 
         Both passes need at least one real step, so a threshold outside the schedule's
         range is refused rather than silently producing a zero-step pass. A restart BELOW
@@ -3112,7 +3131,7 @@ class FunPackLTXAVSceneChainSampler:
         the shift happens after it. `_first_at_or_below` is that walk in closed form — the
         first index at or below the threshold IS the sigma the last pre-shift step lands on.
         Returned cut/restart values are the schedule's own float32 entries, so the sigma
-        pass 2 re-enters at is exactly the one _anchor_shift_renoise rebuilds the state for.
+        pass 2 re-enters at is exactly the one _renoise_to_sigma rebuilds the state for.
         """
         if not isinstance(sigmas, torch.Tensor) or sigmas.numel() < 3:
             return None
@@ -3147,7 +3166,101 @@ class FunPackLTXAVSceneChainSampler:
         # which the sampler needs to keep its phase boundaries where the schedule put them.
         return first, second, vals[cut], vals[start], resume, start
 
-    def _anchor_shift_renoise(self, latent, from_sigma, to_sigma, seed, reset_indices=()):
+    def _second_pass_plan(self, sigmas, cut_sigma, restart_sigma, alt_sigmas=None):
+        """Plan a general two-pass run, optionally finishing on a DIFFERENT schedule.
+
+        Returns (plan, reason). `plan` is None when the request cannot be honoured, and
+        `reason` then says why and what to change — never a silent no-op.
+
+        plan = (pass1_sigmas, pass2_sigmas, cut_at, entry_at, resume, pass2_context)
+
+        Pass 1 always runs the top of `sigmas` down to the first sigma at or below
+        `cut_sigma` (same walk as anchor_shift: the last pre-cut step is the one whose NEXT
+        sigma crosses the threshold). Pass 2 is either a slice of the same schedule starting
+        at `restart_sigma` (0 = continue straight on from the cut), or — when `alt_sigmas` is
+        connected — that schedule in its entirety, entered at its own first sigma.
+
+        Either way pass 2 re-enters at a sigma at or above the cut, because _renoise_to_sigma
+        can add noise back but never remove it. `pass2_context` is what the sampler must be
+        told its real schedule is: the main schedule with an offset when pass 2 is a slice of
+        it, or the alternate schedule at offset 0 when pass 2 IS that whole schedule.
+        """
+        if not isinstance(sigmas, torch.Tensor) or sigmas.numel() < 3:
+            return None, "the main schedule needs at least 3 sigmas to be split"
+        vals = [float(v) for v in sigmas.tolist()]
+        eps = 1e-4  # SIGMAS are float32; see _anchor_shift_split_sigmas for why this matters
+
+        def _first_at_or_below(seq, s):
+            return next((i for i, v in enumerate(seq) if v <= s + eps), None)
+
+        cut = _first_at_or_below(vals, float(cut_sigma))
+        if cut is None or cut < 1:
+            return None, (f"second_pass_sigma={float(cut_sigma):g} is not reached by the schedule "
+                          f"with a step left before it — pass 1 would have no step to run")
+        first = sigmas[:cut + 1]
+        if first.numel() < 2:
+            return None, "pass 1 would have no step"
+        cut_at = vals[cut]
+
+        if isinstance(alt_sigmas, torch.Tensor) and alt_sigmas.numel() >= 2:
+            # Pass 2 runs its OWN schedule end to end. Its first sigma is where it re-enters,
+            # so that is what the state has to be rebuilt at.
+            second = alt_sigmas
+            entry_at = float(alt_sigmas[0].item())
+            ctx = {"sigmas": alt_sigmas, "offset": 0}
+            if entry_at < cut_at - eps:
+                return None, (f"second_pass_sigmas starts at {entry_at:g}, below "
+                              f"second_pass_sigma={cut_at:g} — pass 2 can be handed a noisier "
+                              f"latent than pass 1 left, never a cleaner one. Start the second "
+                              f"schedule at or above the cut, or lower second_pass_sigma")
+        else:
+            restart = float(restart_sigma)
+            if restart <= 0:
+                start = cut
+            else:
+                start = _first_at_or_below(vals, restart)
+                if start is None or start > cut:
+                    return None, (f"second_pass_restart_sigma={restart:g} is below "
+                                  f"second_pass_sigma={cut_at:g} — pass 2 can be handed a noisier "
+                                  f"latent than pass 1 left, never a cleaner one. Use 0 to carry "
+                                  f"straight on from the cut, or a value at or above it")
+            second = sigmas[start:]
+            entry_at = vals[start]
+            ctx = {"sigmas": sigmas, "offset": start}
+        if second.numel() < 2:
+            return None, "pass 2 would have no step"
+        return (first, second, cut_at, entry_at, abs(entry_at - cut_at) <= eps, ctx), None
+
+    def _restore_pinned_prefix(self, state, chunk):
+        """Put the i2v pin back on a latent that is about to be handed to a second pass.
+
+        _sample_chunk drops noise_mask from what it returns, so without this a second pass
+        would run UNPINNED and re-denoise the anchor frame, letting the reference drift —
+        the opposite of anchor_shift, which deletes the pin on purpose. The pinned region's
+        values are copied back from the original chunk as well, because a rewind re-noise
+        adds noise everywhere, including to frames that are supposed to be frozen.
+        """
+        mask = chunk.get("noise_mask")
+        pinned = self._anchor_pinned_frames(chunk)
+        if mask is None or pinned <= 0:
+            return state
+        result = self._clone_latent(state)
+        try:
+            src = self._latent_tensors(chunk)[0]
+            dst = self._latent_tensors(result)
+            if self._tensor_frames(dst[0]) >= pinned and self._tensor_frames(src) >= pinned:
+                dst[0][:, :, :pinned] = src[:, :, :pinned].to(
+                    device=dst[0].device, dtype=dst[0].dtype)
+                if self._is_nested(result.get("samples")):
+                    result["samples"] = comfy.nested_tensor.NestedTensor(dst)
+                else:
+                    result["samples"] = dst[0]
+        except Exception:
+            return state
+        result["noise_mask"] = self._clone_value(mask)
+        return result
+
+    def _renoise_to_sigma(self, latent, from_sigma, to_sigma, seed, reset_indices=()):
         """Move a latent that sits mid-trajectory at `from_sigma` back up to `to_sigma`.
 
         This model's CONST scaling means a latent at sigma s is x_s = s*eps + (1-s)*x0.
@@ -5102,6 +5215,8 @@ class FunPackLTXAVSceneChainSampler:
                anchor_shift=False, anchor_shift_sigma=0.909, anchor_shift_frames=8,
                anchor_shift_restart_sigma=0.0, anchor_shift_tail="extend_last",
                anchor_shift_fresh_audio=True,
+               second_pass=False, second_pass_sigma=0.603,
+               second_pass_restart_sigma=0.0, second_pass_sigmas=None,
                unique_id=None, prompt=None):
         if not isinstance(positive, list) or not positive:
             raise ValueError("positive conditioning must contain at least one scene entry.")
@@ -5171,6 +5286,9 @@ class FunPackLTXAVSceneChainSampler:
                 anchor_shift_restart_sigma=anchor_shift_restart_sigma,
                 anchor_shift_tail=anchor_shift_tail,
                 anchor_shift_fresh_audio=anchor_shift_fresh_audio,
+                second_pass=second_pass, second_pass_sigma=second_pass_sigma,
+                second_pass_restart_sigma=second_pass_restart_sigma,
+                second_pass_sigmas=second_pass_sigmas,
             )
 
         max_scene_count = max(1, int(max_scenes))
@@ -5667,7 +5785,7 @@ class FunPackLTXAVSceneChainSampler:
                         _reset_streams = ((1,) if (anchor_shift_fresh_audio
                                                    and len(self._latent_tensors(_shifted)) > 1)
                                           else ())
-                        _shifted = self._anchor_shift_renoise(
+                        _shifted = self._renoise_to_sigma(
                             _shifted, _cut_at, _restart_at, scene_seed + 4242, _reset_streams)
                     # Either way pass 2 is handed the exact x at its first sigma — as the
                     # untouched hand-over (continue) or as the re-noised one (rewind) — so it
@@ -5746,9 +5864,50 @@ class FunPackLTXAVSceneChainSampler:
                             f"still in the clip — raise anchor_shift_frames to at least "
                             f"{_pinned_n * max(1, int(time_scale))}")
                 else:
-                    sampled = self._sample_chunk(
-                        model, sampler, sigmas, scene_seed, cfg, scene_positive, scene_negative,
-                        chunk, **_sample_kwargs)
+                    # General second pass. Reaching this branch means anchor_shift did not act
+                    # on this scene (it is either off, or was skipped with a reason above), so
+                    # the two features never nest — they stay independent by construction.
+                    _sp_plan = None
+                    if second_pass:
+                        _sp_plan, _sp_reason = self._second_pass_plan(
+                            sigmas, second_pass_sigma, second_pass_restart_sigma,
+                            second_pass_sigmas)
+                        if _sp_plan is None:
+                            run_mechanisms.append(f"second_pass(SKIPPED: {_sp_reason})")
+                    if _sp_plan is not None:
+                        _sp_a, _sp_b, _sp_cut, _sp_entry, _sp_resume, _sp_ctx = _sp_plan
+                        _sp_p1 = self._sample_chunk(
+                            model, sampler, _sp_a, scene_seed, cfg, scene_positive,
+                            scene_negative, chunk,
+                            schedule_context={"sigmas": sigmas, "offset": 0}, **_sample_kwargs)
+                        _sp_state = _sp_p1
+                        if not _sp_resume:
+                            # Rebuild the state at the higher entry sigma. Fresh field: reusing
+                            # scene_seed would re-apply the exact noise pass 1 just resolved.
+                            _sp_state = self._renoise_to_sigma(
+                                _sp_p1, _sp_cut, _sp_entry, scene_seed + 4242)
+                        # Unlike anchor_shift, a plain second pass must KEEP the i2v anchor
+                        # pinned — otherwise pass 2 re-denoises the reference frame and the
+                        # scene drifts away from the image it was supposed to start from.
+                        _sp_state = self._restore_pinned_prefix(_sp_state, chunk)
+                        _sp_kw = dict(_sample_kwargs)
+                        _sp_kw["step_offset"] = _sample_kwargs["step_offset"] + (_sp_a.numel() - 1)
+                        _sp_kw["continue_from_state"] = True
+                        _sp_kw["schedule_context"] = _sp_ctx
+                        sampled = self._sample_chunk(
+                            model, sampler, _sp_b, scene_seed + 4242, cfg, scene_positive,
+                            scene_negative, _sp_state, **_sp_kw)
+                        _sp_alt = (isinstance(second_pass_sigmas, torch.Tensor)
+                                   and second_pass_sigmas.numel() >= 2)
+                        run_mechanisms.append(
+                            f"second_pass({'continue' if _sp_resume else 'rewind'} "
+                            f"cut@{_sp_cut:g} entry@{_sp_entry:g}, "
+                            f"{_sp_a.numel() - 1}+{_sp_b.numel() - 1} steps"
+                            f"{', own schedule' if _sp_alt else ''})")
+                    else:
+                        sampled = self._sample_chunk(
+                            model, sampler, sigmas, scene_seed, cfg, scene_positive,
+                            scene_negative, chunk, **_sample_kwargs)
                 _scene_sample_s = _time.perf_counter() - _t_sample0
                 _phase_sampling += _scene_sample_s
                 if _plateau_stats is not None:
@@ -6088,7 +6247,9 @@ class FunPackLTXAVSceneChainSampler:
                             context_window_retain_first=False,
                             anchor_shift=False, anchor_shift_sigma=0.909, anchor_shift_frames=8,
                             anchor_shift_restart_sigma=0.0, anchor_shift_tail="extend_last",
-                            anchor_shift_fresh_audio=True):
+                            anchor_shift_fresh_audio=True,
+                            second_pass=False, second_pass_sigma=0.603,
+                            second_pass_restart_sigma=0.0, second_pass_sigmas=None):
         """Sample one chain per Studio-packed variant entry (seed + index), persisting each result
         (latent + preview + per-entry cond + manifest) under ComfyUI temp for rating in Studio.
         Reuses sample() per entry with only the seed changed, so each entry is a clean generation."""
@@ -6153,6 +6314,9 @@ class FunPackLTXAVSceneChainSampler:
                 anchor_shift_restart_sigma=anchor_shift_restart_sigma,
                 anchor_shift_tail=anchor_shift_tail,
                 anchor_shift_fresh_audio=anchor_shift_fresh_audio,
+                second_pass=second_pass, second_pass_sigma=second_pass_sigma,
+                second_pass_restart_sigma=second_pass_restart_sigma,
+                second_pass_sigmas=second_pass_sigmas,
                 unique_id=None, prompt=None,
             )
             last = out
diff --git a/tests/test_anchor_shift.py b/tests/test_anchor_shift.py
index 053fc252..0042ee54 100644
--- a/tests/test_anchor_shift.py
+++ b/tests/test_anchor_shift.py
@@ -204,7 +204,7 @@ def test_renoise_to_the_same_sigma_is_an_identity(renoise_stubs):
     """b == a must add nothing: alpha=1, beta=0. This is what lets continue mode and
     rewind mode be one formula instead of two special cases."""
     latent = {"samples": torch.full((1, 4, 6, 2, 2), 3.0)}
-    out = _node()._anchor_shift_renoise(latent, 0.725, 0.725, seed=7)
+    out = _node()._renoise_to_sigma(latent, 0.725, 0.725, seed=7)
     assert torch.allclose(out["samples"], latent["samples"], atol=1e-6)
 
 
@@ -213,7 +213,7 @@ def test_renoise_from_zero_matches_comfy_const_scaling(renoise_stubs):
     the formula strictly generalises the img2img re-noise rather than replacing it."""
     b = 0.975
     x0 = torch.full((1, 4, 6, 2, 2), 3.0)
-    out = _node()._anchor_shift_renoise({"samples": x0}, 0.0, b, seed=11)
+    out = _node()._renoise_to_sigma({"samples": x0}, 0.0, b, seed=11)
     expected = _const_noise_scaling(b, torch.full_like(x0, 7.0), x0)
     assert torch.allclose(out["samples"], expected, atol=1e-6)
 
@@ -225,7 +225,7 @@ def test_renoise_upward_rebuilds_the_state_at_the_higher_sigma(renoise_stubs):
     a, b = 0.603, 0.893
     x0, eps = torch.full((1, 4, 6, 2, 2), 3.0), torch.full((1, 4, 6, 2, 2), -1.5)
     x_a = x0 * (1.0 - a) + eps * a          # a genuine mid-trajectory latent
-    out = _node()._anchor_shift_renoise({"samples": x_a}, a, b, seed=3)
+    out = _node()._renoise_to_sigma({"samples": x_a}, a, b, seed=3)
 
     alpha = (1.0 - b) / (1.0 - a)
     beta = math.sqrt(b * b - (a * alpha) ** 2)
@@ -243,7 +243,7 @@ def test_renoise_starts_a_reset_stream_from_scratch(renoise_stubs):
     b = 0.893
     latent = {"samples": _FakeNested(
         [torch.full((1, 4, 6, 2, 2), 2.0), torch.zeros(1, 4, 12)])}
-    out = _node()._anchor_shift_renoise(latent, 0.603, b, seed=5, reset_indices=(1,))
+    out = _node()._renoise_to_sigma(latent, 0.603, b, seed=5, reset_indices=(1,))
     video, audio = out["samples"].unbind()
     assert torch.allclose(audio, torch.full_like(audio, 7.0 * b), atol=1e-6)
     # ...and the video stream still took the mid-trajectory path, not the a=0 one.
@@ -255,7 +255,7 @@ def test_renoise_starts_a_reset_stream_from_scratch(renoise_stubs):
 def test_renoise_never_mutates_its_input(renoise_stubs):
     latent = {"samples": torch.full((1, 4, 6, 2, 2), 3.0)}
     before = latent["samples"].clone()
-    _node()._anchor_shift_renoise(latent, 0.603, 0.893, seed=1)
+    _node()._renoise_to_sigma(latent, 0.603, 0.893, seed=1)
     assert torch.equal(latent["samples"], before)
 
 
diff --git a/tests/test_second_pass.py b/tests/test_second_pass.py
new file mode 100644
index 00000000..031f3b0b
--- /dev/null
+++ b/tests/test_second_pass.py
@@ -0,0 +1,154 @@
+"""second_pass — a general two-pass split on the Chain Sampler, independent of anchor_shift.
+
+anchor_shift built the machinery (stop the schedule, hand the state over, re-enter exactly);
+this exposes it on its own so a scene can be finished differently from how it was started.
+The invariants that matter here are the ones a split can silently get wrong:
+
+1. Pass 1 stops on a REAL step of the user's schedule, found by walking it.
+2. Pass 2 re-enters at or above the cut — never below, because noise can be added back but
+   never removed (the same rule anchor_shift's rewind lives by).
+3. A connected second schedule replaces pass 2 wholesale, and its own first sigma becomes
+   the entry point, so the sampler's phases are measured against IT and not the main one.
+4. Nothing is ever a silent no-op: every refusal comes back with a reason naming the fix.
+5. The i2v anchor stays PINNED across the split — the opposite of anchor_shift, which
+   deletes the pin on purpose. Without this pass 2 re-denoises the reference frame.
+"""
+import sys
+import types
+from pathlib import Path
+
+import torch
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+for _name in (
+    "comfy", "comfy.k_diffusion", "comfy.k_diffusion.sampling",
+    "comfy.model_sampling", "comfy.nested_tensor", "comfy.sample",
+    "comfy.samplers", "comfy.utils",
+):
+    sys.modules.setdefault(_name, types.ModuleType(_name))
+sys.modules["comfy.nested_tensor"].NestedTensor = object
+
+import samplers  # noqa: E402
+
+
+# The user's own 9-step schedule.
+SCHEDULE = torch.tensor([1.0, 0.955, 0.893, 0.812, 0.715, 0.603, 0.482, 0.241, 0.121, 0.0])
+
+
+def _node():
+    return samplers.FunPackLTXAVSceneChainSampler()
+
+
+def _plan(cut, restart=0.0, alt=None):
+    return _node()._second_pass_plan(SCHEDULE, cut, restart, alt)
+
+
+# ── the split ───────────────────────────────────────────────────────────────
+
+def test_continue_splits_the_schedule_without_adding_a_step():
+    """restart 0 is behaviour-neutral: the two halves are the whole schedule, cut once, and
+    pass 2 resumes from the exact handed-over state (resume=True -> no re-noise)."""
+    plan, reason = _plan(0.603)
+    assert reason is None
+    first, second, cut_at, entry_at, resume, ctx = plan
+    assert [round(v, 3) for v in first.tolist()] == [1.0, 0.955, 0.893, 0.812, 0.715, 0.603]
+    assert [round(v, 3) for v in second.tolist()] == [0.603, 0.482, 0.241, 0.121, 0.0]
+    assert abs(cut_at - 0.603) < 1e-5 and abs(entry_at - 0.603) < 1e-5
+    assert resume is True
+    # No step is run twice: 5 + 4 == the schedule's own 9.
+    assert (first.numel() - 1) + (second.numel() - 1) == SCHEDULE.numel() - 1
+    # Pass 2's phases must still be measured against the whole schedule.
+    assert ctx["sigmas"] is SCHEDULE and ctx["offset"] == 5
+
+
+def test_rewind_re_enters_higher_and_replays_those_steps():
+    plan, reason = _plan(0.482, restart=0.812)
+    assert reason is None
+    first, second, cut_at, entry_at, resume, ctx = plan
+    assert [round(v, 3) for v in first.tolist()] == [1.0, 0.955, 0.893, 0.812, 0.715, 0.603, 0.482]
+    assert [round(v, 3) for v in second.tolist()] == [0.812, 0.715, 0.603, 0.482, 0.241, 0.121, 0.0]
+    assert resume is False          # the caller must rebuild the state at 0.812 first
+    assert ctx["offset"] == 3
+
+
+def test_restart_below_the_cut_is_refused_with_the_fix_named():
+    plan, reason = _plan(0.812, restart=0.482)
+    assert plan is None
+    assert "never a cleaner one" in reason and "second_pass_restart_sigma" in reason
+
+
+def test_a_cut_outside_the_schedule_is_refused_not_ignored():
+    for cut in (1.0, 0.9999, 0.0005):
+        plan, reason = _plan(cut)
+        assert plan is None and reason, cut
+
+
+# ── a separate schedule for pass 2 ──────────────────────────────────────────
+
+def test_a_connected_schedule_replaces_pass_two_wholesale():
+    """The point of the feature: the second half can have its own step count and spacing.
+    Its first sigma is the entry point, and the sampler must be told THAT is its schedule —
+    otherwise it measures its quality phase and correction window against the main one."""
+    alt = torch.tensor([0.715, 0.5, 0.3, 0.15, 0.0])
+    plan, reason = _plan(0.603, restart=0.0, alt=alt)
+    assert reason is None
+    first, second, cut_at, entry_at, resume, ctx = plan
+    assert second is alt
+    assert abs(entry_at - 0.715) < 1e-5      # the alt schedule's own first sigma
+    assert resume is False                   # 0.603 -> 0.715 needs the state rebuilt
+    assert ctx["sigmas"] is alt and ctx["offset"] == 0
+    # ...and pass 1 is unaffected by it.
+    assert [round(v, 3) for v in first.tolist()] == [1.0, 0.955, 0.893, 0.812, 0.715, 0.603]
+
+
+def test_a_connected_schedule_starting_at_the_cut_is_an_exact_handover():
+    alt = torch.tensor([0.603, 0.4, 0.2, 0.0])
+    plan, reason = _plan(0.603, alt=alt)
+    assert reason is None and plan[4] is True     # resume -> nothing added
+
+
+def test_a_connected_schedule_starting_below_the_cut_is_refused():
+    alt = torch.tensor([0.3, 0.15, 0.0])
+    plan, reason = _plan(0.603, alt=alt)
+    assert plan is None
+    assert "second_pass_sigmas starts at" in reason
+
+
+def test_a_degenerate_connected_schedule_falls_back_to_the_restart_sigma():
+    """A single-sigma (or empty) SIGMAS input is not a schedule — it must not be treated as
+    one, and the restart sigma still governs."""
+    for alt in (None, torch.tensor([0.5]), torch.tensor([])):
+        plan, reason = _plan(0.603, restart=0.812, alt=alt)
+        assert reason is None
+        assert plan[1].tolist()[0] == SCHEDULE[3].item()   # a slice of the MAIN schedule
+
+
+# ── the pin survives the split ──────────────────────────────────────────────
+
+def test_the_i2v_anchor_is_re_pinned_for_pass_two():
+    """_sample_chunk drops noise_mask from what it returns, so without this pass 2 runs
+    unpinned and re-denoises the reference frame. anchor_shift wants that; this does not."""
+    frames = 6
+    clean = torch.arange(frames, dtype=torch.float32).view(1, 1, frames, 1, 1).repeat(1, 4, 1, 2, 2)
+    mask = torch.ones_like(clean)
+    mask[:, :, :1] = 0.0                       # one pinned anchor frame
+    chunk = {"samples": clean, "noise_mask": mask}
+    # A "state" where the anchor frame has been polluted (as a rewind re-noise would).
+    state = {"samples": torch.full_like(clean, -99.0)}
+
+    out = _node()._restore_pinned_prefix(state, chunk)
+    assert out.get("noise_mask") is not None
+    # The pinned frame is back to the clean anchor...
+    assert torch.equal(out["samples"][:, :, :1], clean[:, :, :1])
+    # ...and nothing else was touched.
+    assert torch.equal(out["samples"][:, :, 1:], state["samples"][:, :, 1:])
+
+
+def test_restore_is_a_no_op_on_a_t2v_scene():
+    """No pinned prefix = no anchor to protect; the state must come back untouched."""
+    clean = torch.zeros(1, 4, 6, 2, 2)
+    state = {"samples": torch.full_like(clean, 3.0)}
+    for chunk in ({"samples": clean, "noise_mask": torch.ones_like(clean)},
+                  {"samples": clean}):
+        assert _node()._restore_pinned_prefix(state, chunk) is state

From 16045e086c80197351875e05d20adf48a5e39658 Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Fri, 31 Jul 2026 13:35:29 +0300
Subject: [PATCH 20/29] second_pass: optional latent operations between the
 passes (none by default)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Per the user's reminder that these are OPTIONS, not defaults: second_pass_op is a
combo defaulting to "none", and nothing runs unless it is picked. The expensive one
is therefore not a tax on anything — it costs what it costs only when chosen.

- "sharpen": one forward of Lightricks' trained 2x LatentUpsampler, resampled straight
  back to the original size. No video-model calls, so a fraction of a step; pass 2 then
  re-denoises the sharpened latent, which is what makes it stick. Adds detail consistent
  with what is there and CANNOT fix wrong structure — the same limit segmented
  detailing's sharpen mode documents.
- "upscale_2x": same upsampler, result KEPT at 2x, so pass 2 runs at 4x the pixels and
  the scene decodes at double resolution. 3-5x the second half's cost.

Reuses detailing.py's _run_upsampler / _downscale_to and its lazily-loaded upsampler
(same model, same detail_upsampler knob, "auto" downloads the official file) rather
than adding a second copy of any of it.

Ordering that matters: the op runs BEFORE the rewind re-noise, because sharpening a
latent that has just had noise added back sharpens the noise.

Two failure modes handled rather than left implicit:
- upscale_2x changes the latent resolution, so the chunk's i2v anchor and mask are the
  wrong size. Rescaling them would be inventing an anchor, so the pin is dropped and
  the scene report SAYS the pass runs unpinned and may drift from the reference image.
- A missing or throwing upsampler degrades to "second pass, no operation" with the
  reason, instead of killing a whole montage over an optional sharpen.

Found while writing the tests: an unrecognised op name was validated only AFTER the
upsampler forward had already run, so a typo paid full price and then reported the
wrong reason. Name is checked first now.

Editor + Easy Gen get the combo under Engine > Experimental; verified live that it
renders with none/sharpen/upscale_2x and defaults to none. Suite at baseline: 22
pre-existing failures, 306 passing.

Not built: downscale-then-rescale (DeepShrink-shaped). It is not a between-passes op —
pass 1 itself has to run at reduced resolution, which means downscaling the chunk, its
mask and the anchor before pass 1, so it needs its own insertion point rather than
this hook.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 movie_editor/frontend/engine_settings.js |   4 +-
 samplers.py                              | 108 +++++++++++++++++++++--
 tests/test_second_pass.py                |  82 ++++++++++++++++-
 3 files changed, 187 insertions(+), 7 deletions(-)

diff --git a/movie_editor/frontend/engine_settings.js b/movie_editor/frontend/engine_settings.js
index 0bbb8e00..76bd8cc0 100644
--- a/movie_editor/frontend/engine_settings.js
+++ b/movie_editor/frontend/engine_settings.js
@@ -244,6 +244,8 @@
       hint: "Where pass 1 stops. The schedule is walked and the last pass-1 step is the one whose next sigma has crossed this value, so the cut always lands on a real step in your schedule — only sigmas actually in the schedule are reachable, and a value outside its range is refused with a reason rather than ignored." },
     { name: "second_pass_restart_sigma", label: "Pass 2 re-enters at sigma", kind: "float", default: 0.0, min: 0.0, max: 0.999, step: 0.001, dependsOn: "second_pass",
       hint: "0 (default) = carry straight on from the cut: nothing is added and the total cost is unchanged. A value ABOVE the cut rewinds — the half-denoised latent is rebuilt at that higher sigma (exact for a mid-trajectory latent, not the naive img2img re-noise) and those steps run again, letting the model rework structure it already committed to, at the cost of repeating them. Below the cut is refused: noise can be added back, never removed." },
+    { name: "second_pass_op", label: "Between-pass operation", kind: "combo", choices: ["none", "sharpen", "upscale_2x"], default: "none", dependsOn: "second_pass",
+      hint: "OPTIONAL operation applied to the latent between the two passes — 'none' by default, nothing runs unless you pick one. 'sharpen': one forward of Lightricks' trained 2x latent upsampler, resampled straight back to the original size. No video-model calls, so it costs a fraction of a step; pass 2 then re-denoises the sharpened latent, which is what makes it stick. It adds detail consistent with what's already there and CANNOT fix wrong structure (an extra finger stays an extra finger, just sharper). 'upscale_2x': the same upsampler, but kept at 2x — pass 2 runs at four times the pixels and the scene decodes at double resolution. That's 3-5x the cost of the second half, and it drops the i2v pin (the anchor and its mask are the old size, and rescaling them would be inventing an anchor), so the scene can drift from the reference image; the scene report says when that happens. Both use the same upsampler file as segmented detailing. Video only — audio is never reshaped." },
     { name: "context_windows", label: "Context windows (long scenes)", kind: "bool", default: false,
       hint: "EXPERIMENTAL: denoise a scene that's LONGER than the model's comfortable window as overlapping windows instead of one giant pass — ComfyUI core's own mechanism, audio-aware on LTX (it maps each video window to its audio window and re-slices anchors, guides and JoyAI memory per window). Engages only on scenes longer than the window length below; shorter scenes are untouched and pay nothing. Cost at the defaults (145/40) is about 1.45× the per-frame work, since each window re-does its 40-frame overlap — offset by attention getting cheaper the longer the scene is (quadratic in one pass, near-flat when windowed). Roughly break-even around 200 frames, a net win past ~300. Needs ComfyUI v0.29.0 or newer; on older builds it's skipped with a note in the scene report. UNVALIDATED LIVE." },
     { name: "context_window_length", label: "Window length (frames)", kind: "int", default: 145, min: 9, max: 2049, step: 8, dependsOn: "context_windows",
@@ -383,7 +385,7 @@
     chain_timing: ["frame_overlap", "transition_duration", "use_same_seed"],
     chain_guidance: ["cfg", "embed_guidance", "embed_guidance_source", "embed_guidance_strength", "score_slider", "score_slider_strength", "taste_nearest_prompt", "output_guidance", "output_guidance_strength", "dynashift", "dynashift_strength", "dynashift_threshold"],
     chain_decode: ["decode_noise_scale", "decode_timestep", "decode_tile_size"],
-    chain_experimental: ["anchor_shift", "anchor_shift_sigma", "anchor_shift_frames", "anchor_shift_restart_sigma", "anchor_shift_tail", "anchor_shift_fresh_audio", "second_pass", "second_pass_sigma", "second_pass_restart_sigma", "context_windows", "context_window_length", "context_window_overlap", "context_window_schedule", "context_window_fuse", "context_window_freenoise", "context_window_retain_first", "plateau_cache", "plateau_cache_threshold", "segmented_detailing", "detail_targets", "detail_strength", "detail_threshold", "detail_max_area", "detail_mode", "detail_denoise", "mid_scene_guide", "mid_scene_guide_strength", "joyai_memory", "joyai_memory_size", "joyai_fix_frames", "joyai_frame_select", "joyai_memory_strength", "joyai_audio_memory", "v2a_grad_scale", "alg_blur_guides", "alg_guide_blur_strength", "alg_guide_blur_sigma_threshold", "bounded_attention_enabled", "identity_transfer_enabled", "source_id", "phase_scale", "id_strength", "arcface_mode", "debug_log"],
+    chain_experimental: ["anchor_shift", "anchor_shift_sigma", "anchor_shift_frames", "anchor_shift_restart_sigma", "anchor_shift_tail", "anchor_shift_fresh_audio", "second_pass", "second_pass_sigma", "second_pass_restart_sigma", "second_pass_op", "context_windows", "context_window_length", "context_window_overlap", "context_window_schedule", "context_window_fuse", "context_window_freenoise", "context_window_retain_first", "plateau_cache", "plateau_cache_threshold", "segmented_detailing", "detail_targets", "detail_strength", "detail_threshold", "detail_max_area", "detail_mode", "detail_denoise", "mid_scene_guide", "mid_scene_guide_strength", "joyai_memory", "joyai_memory_size", "joyai_fix_frames", "joyai_frame_select", "joyai_memory_strength", "joyai_audio_memory", "v2a_grad_scale", "alg_blur_guides", "alg_guide_blur_strength", "alg_guide_blur_sigma_threshold", "bounded_attention_enabled", "identity_transfer_enabled", "source_id", "phase_scale", "id_strength", "arcface_mode", "debug_log"],
   };
 
   function countChainView(p, id) {
diff --git a/samplers.py b/samplers.py
index d91bcb47..2780aa3b 100644
--- a/samplers.py
+++ b/samplers.py
@@ -2586,6 +2586,10 @@ class FunPackLTXAVSceneChainSampler:
                     "default": 0.0, "min": 0.0, "max": 0.999, "step": 0.001,
                     "tooltip": "Where pass 2 re-enters, when no second_pass_sigmas schedule is connected. 0 (default) = carry straight on from the cut: nothing is added, total cost unchanged. A value ABOVE second_pass_sigma rewinds — the half-denoised latent is rebuilt at that higher sigma (exact for a mid-trajectory latent, not the naive img2img re-noise) and those steps run again, letting the model rework structure it has already committed to, at the cost of repeating them. BELOW the cut is refused: noise can be added back, never removed. Ignored when second_pass_sigmas is connected, since that schedule's own first sigma is the entry point.",
                 }),
+                "second_pass_op": (["none", "sharpen", "upscale_2x"], {
+                    "default": "none",
+                    "tooltip": "OPTIONAL latent-space operation applied between the two passes — 'none' by default, nothing runs unless you pick one. 'sharpen': one forward of Lightricks' trained 2x latent upsampler, resampled straight back to the original size. No video-model calls at all, so it costs a fraction of a step; pass 2 then re-denoises the sharpened latent, which is what makes it stick. It adds detail consistent with what is already there and CANNOT fix structure that is wrong (an extra finger stays an extra finger, just sharper) — the same limit segmented detailing's sharpen mode documents. 'upscale_2x': the same upsampler, but the result is KEPT at 2x, so pass 2 runs at four times the pixels and the scene decodes at double resolution. That is 3-5x the sampling cost of the second half and it drops the i2v pin (the anchor and its mask are the old size, and rescaling them would be inventing an anchor) — the scene report says so when it happens. Both use the same upsampler file as segmented detailing (detail_upsampler, 'auto' downloads the official one on first use). Video stream only; audio is never reshaped.",
+                }),
                 # A connection socket, never a widget — safe at the end, and it must stay after
                 # every widget above (see the widgets_values note at the top of this block).
                 "second_pass_sigmas": ("SIGMAS", {
@@ -3231,6 +3235,61 @@ class FunPackLTXAVSceneChainSampler:
             return None, "pass 2 would have no step"
         return (first, second, cut_at, entry_at, abs(entry_at - cut_at) <= eps, ctx), None
 
+    def _second_pass_operate(self, latent, op, upsampler, vae):
+        """Apply the chosen latent-space operation between the two passes.
+
+        All of these are OPTIONS — "none" is the default and the whole feature is opt-in.
+        Everything here touches the VIDEO stream only: the audio stream sits alongside it in
+        the same nested latent and has no spatial axes to scale, and reshaping it is exactly
+        the class of change that has corrupted audio before.
+
+        - "sharpen": Lightricks' trained 2x LatentUpsampler forward, then area-downscale back
+          to the original size. No video-model calls at all, so it costs a fraction of one
+          step. It adds detail consistent with what is already there; it cannot fix structure
+          that is wrong (the same limit segmented detailing's 'sharpen' mode documents).
+          Pass 2 then re-denoises the sharpened latent, which is what makes it stick.
+        - "upscale_2x": the same upsampler, but the result is KEPT at 2x. Pass 2 therefore
+          runs at four times the pixels, and the scene decodes at double resolution. This is
+          the expensive one by a wide margin — it is here because it was asked for, not
+          because it is a good default.
+
+        Returns (latent, note). The latent is returned unchanged with a note when the op
+        cannot run, so a missing upsampler degrades to "second pass, no operation" rather
+        than failing the whole render.
+        """
+        if op in (None, "none", ""):
+            return latent, None
+        # Validate the name BEFORE touching the upsampler: an unrecognised op should cost
+        # nothing and say so, not pay for a full upsampler forward and then be discarded.
+        if op not in ("sharpen", "upscale_2x"):
+            return latent, f"second_pass_op={op} skipped: unknown operation"
+        if upsampler is None:
+            return latent, f"second_pass_op={op} skipped: no latent upsampler could be loaded"
+        try:
+            from . import detailing as _d
+        except ImportError:  # loaded as a top-level module (tests, direct import)
+            import detailing as _d
+        result = self._clone_latent(latent)
+        tensors = self._latent_tensors(result)
+        video = tensors[0]
+        h, w = int(video.shape[-2]), int(video.shape[-1])
+        try:
+            up = _d._run_upsampler(upsampler, video, vae)
+        except Exception as exc:  # noqa: BLE001
+            return latent, f"second_pass_op={op} skipped: upsampler failed ({exc})"
+        if op == "sharpen":
+            tensors[0] = _d._downscale_to(up, h, w)
+            note = f"second_pass_op(sharpen: 2x upsampler pass, resampled back to {h}x{w})"
+        else:  # "upscale_2x"
+            tensors[0] = up
+            note = (f"second_pass_op(upscale_2x: {h}x{w} -> {up.shape[-2]}x{up.shape[-1]} — "
+                    f"pass 2 runs at {(up.shape[-2] * up.shape[-1]) // max(1, h * w)}x the pixels)")
+        if self._is_nested(result.get("samples")):
+            result["samples"] = comfy.nested_tensor.NestedTensor(tensors)
+        else:
+            result["samples"] = tensors[0]
+        return result, note
+
     def _restore_pinned_prefix(self, state, chunk):
         """Put the i2v pin back on a latent that is about to be handed to a second pass.
 
@@ -3244,6 +3303,14 @@ class FunPackLTXAVSceneChainSampler:
         pinned = self._anchor_pinned_frames(chunk)
         if mask is None or pinned <= 0:
             return state
+        try:
+            # A resolution-changing second_pass_op (upscale_2x) leaves the chunk's anchor and
+            # mask the wrong size. Rescaling them here would be inventing an anchor; the
+            # caller reports the lost pin instead.
+            if self._latent_tensors(state)[0].shape[-2:] != self._latent_tensors(chunk)[0].shape[-2:]:
+                return state
+        except Exception:
+            return state
         result = self._clone_latent(state)
         try:
             src = self._latent_tensors(chunk)[0]
@@ -5216,7 +5283,7 @@ class FunPackLTXAVSceneChainSampler:
                anchor_shift_restart_sigma=0.0, anchor_shift_tail="extend_last",
                anchor_shift_fresh_audio=True,
                second_pass=False, second_pass_sigma=0.603,
-               second_pass_restart_sigma=0.0, second_pass_sigmas=None,
+               second_pass_restart_sigma=0.0, second_pass_op="none", second_pass_sigmas=None,
                unique_id=None, prompt=None):
         if not isinstance(positive, list) or not positive:
             raise ValueError("positive conditioning must contain at least one scene entry.")
@@ -5288,7 +5355,7 @@ class FunPackLTXAVSceneChainSampler:
                 anchor_shift_fresh_audio=anchor_shift_fresh_audio,
                 second_pass=second_pass, second_pass_sigma=second_pass_sigma,
                 second_pass_restart_sigma=second_pass_restart_sigma,
-                second_pass_sigmas=second_pass_sigmas,
+                second_pass_op=second_pass_op, second_pass_sigmas=second_pass_sigmas,
             )
 
         max_scene_count = max(1, int(max_scenes))
@@ -5881,15 +5948,45 @@ class FunPackLTXAVSceneChainSampler:
                             scene_negative, chunk,
                             schedule_context={"sigmas": sigmas, "offset": 0}, **_sample_kwargs)
                         _sp_state = _sp_p1
+                        if second_pass_op not in (None, "none", ""):
+                            # Operate BEFORE the re-noise: sharpening a latent that has just had
+                            # noise added back would sharpen the noise. Shares segmented
+                            # detailing's lazily-loaded upsampler — same model, same knob.
+                            if _detail_upsampler_model is None and _detail_disabled_reason is None:
+                                try:
+                                    try:
+                                        from . import detailing as _det
+                                    except ImportError:
+                                        import detailing as _det
+                                    _r = _det.resolve_upsampler_name(detail_upsampler)
+                                    _detail_upsampler_model = _det.load_latent_upsampler(_r)
+                                except Exception as _exc:  # noqa: BLE001
+                                    _detail_disabled_reason = str(_exc)
+                            _sp_state, _op_note = self._second_pass_operate(
+                                _sp_state, second_pass_op, _detail_upsampler_model, vae)
+                            if _op_note:
+                                run_mechanisms.append(_op_note)
+                            elif _detail_disabled_reason:
+                                run_mechanisms.append(
+                                    f"second_pass_op={second_pass_op} skipped: upsampler "
+                                    f"unavailable ({_detail_disabled_reason})")
                         if not _sp_resume:
                             # Rebuild the state at the higher entry sigma. Fresh field: reusing
                             # scene_seed would re-apply the exact noise pass 1 just resolved.
                             _sp_state = self._renoise_to_sigma(
-                                _sp_p1, _sp_cut, _sp_entry, scene_seed + 4242)
+                                _sp_state, _sp_cut, _sp_entry, scene_seed + 4242)
                         # Unlike anchor_shift, a plain second pass must KEEP the i2v anchor
                         # pinned — otherwise pass 2 re-denoises the reference frame and the
                         # scene drifts away from the image it was supposed to start from.
+                        _sp_before = _sp_state
                         _sp_state = self._restore_pinned_prefix(_sp_state, chunk)
+                        if (_sp_state is _sp_before and self._anchor_pinned_frames(chunk) > 0):
+                            # Only happens when the op changed the resolution — say so, because
+                            # an unpinned pass 2 can drift off the reference image.
+                            run_mechanisms.append(
+                                "second_pass NOTE: the i2v anchor could not stay pinned for pass 2 "
+                                "because second_pass_op changed the latent resolution — pass 2 runs "
+                                "unpinned and may drift from the reference image.")
                         _sp_kw = dict(_sample_kwargs)
                         _sp_kw["step_offset"] = _sample_kwargs["step_offset"] + (_sp_a.numel() - 1)
                         _sp_kw["continue_from_state"] = True
@@ -6249,7 +6346,8 @@ class FunPackLTXAVSceneChainSampler:
                             anchor_shift_restart_sigma=0.0, anchor_shift_tail="extend_last",
                             anchor_shift_fresh_audio=True,
                             second_pass=False, second_pass_sigma=0.603,
-                            second_pass_restart_sigma=0.0, second_pass_sigmas=None):
+                            second_pass_restart_sigma=0.0, second_pass_op="none",
+                            second_pass_sigmas=None):
         """Sample one chain per Studio-packed variant entry (seed + index), persisting each result
         (latent + preview + per-entry cond + manifest) under ComfyUI temp for rating in Studio.
         Reuses sample() per entry with only the seed changed, so each entry is a clean generation."""
@@ -6316,7 +6414,7 @@ class FunPackLTXAVSceneChainSampler:
                 anchor_shift_fresh_audio=anchor_shift_fresh_audio,
                 second_pass=second_pass, second_pass_sigma=second_pass_sigma,
                 second_pass_restart_sigma=second_pass_restart_sigma,
-                second_pass_sigmas=second_pass_sigmas,
+                second_pass_op=second_pass_op, second_pass_sigmas=second_pass_sigmas,
                 unique_id=None, prompt=None,
             )
             last = out
diff --git a/tests/test_second_pass.py b/tests/test_second_pass.py
index 031f3b0b..10a5bd7b 100644
--- a/tests/test_second_pass.py
+++ b/tests/test_second_pass.py
@@ -24,10 +24,14 @@ sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
 for _name in (
     "comfy", "comfy.k_diffusion", "comfy.k_diffusion.sampling",
     "comfy.model_sampling", "comfy.nested_tensor", "comfy.sample",
-    "comfy.samplers", "comfy.utils",
+    "comfy.samplers", "comfy.utils", "comfy.model_management",
 ):
     sys.modules.setdefault(_name, types.ModuleType(_name))
 sys.modules["comfy.nested_tensor"].NestedTensor = object
+# _run_upsampler (detailing.py) moves tensors to the torch device and reads the VAE's
+# per-channel statistics; on CPU with vae=None both are no-ops, which is what we want here.
+sys.modules["comfy.model_management"].get_torch_device = lambda: torch.device("cpu")
+sys.modules["comfy"].model_management = sys.modules["comfy.model_management"]
 
 import samplers  # noqa: E402
 
@@ -152,3 +156,79 @@ def test_restore_is_a_no_op_on_a_t2v_scene():
     for chunk in ({"samples": clean, "noise_mask": torch.ones_like(clean)},
                   {"samples": clean}):
         assert _node()._restore_pinned_prefix(state, chunk) is state
+
+
+# ── the optional between-pass operations ────────────────────────────────────
+
+class _FakeUpsampler:
+    """Stands in for Lightricks' LatentUpsampler: 2x nearest on the spatial axes."""
+    def __call__(self, x):
+        return x.repeat_interleave(2, dim=-1).repeat_interleave(2, dim=-2)
+
+    def parameters(self):
+        yield torch.zeros(1)
+
+    def to(self, *a, **k):
+        return self
+
+    def cpu(self):
+        return self
+
+
+def _video(f=4, h=8, w=8, fill=2.0):
+    return {"samples": torch.full((1, 4, f, h, w), fill)}
+
+
+def test_no_operation_is_the_default_and_returns_the_same_object():
+    """The whole feature is opt-in: 'none' must not clone, resample or touch anything."""
+    lat = _video()
+    for op in ("none", None, ""):
+        out, note = _node()._second_pass_operate(lat, op, _FakeUpsampler(), None)
+        assert out is lat and note is None
+
+
+def test_sharpen_comes_back_at_the_original_size():
+    """sharpen is upsampler -> downscale: the latent pass 2 receives must be the SAME shape,
+    or it is silently an upscale and costs four times as much."""
+    out, note = _node()._second_pass_operate(_video(h=8, w=8), "sharpen", _FakeUpsampler(), None)
+    assert out["samples"].shape == (1, 4, 4, 8, 8)
+    assert "sharpen" in note
+
+
+def test_upscale_2x_keeps_the_larger_latent():
+    out, note = _node()._second_pass_operate(_video(h=8, w=8), "upscale_2x", _FakeUpsampler(), None)
+    assert out["samples"].shape == (1, 4, 4, 16, 16)
+    assert "4x the pixels" in note
+
+
+def test_a_missing_upsampler_degrades_instead_of_failing_the_render():
+    """A whole montage must not die because one optional sharpen could not load its model."""
+    lat = _video()
+    out, note = _node()._second_pass_operate(lat, "sharpen", None, None)
+    assert out is lat and "no latent upsampler" in note
+
+
+def test_an_upsampler_that_throws_degrades_too():
+    class _Boom(_FakeUpsampler):
+        def __call__(self, x):
+            raise RuntimeError("out of memory")
+    lat = _video()
+    out, note = _node()._second_pass_operate(lat, "sharpen", _Boom(), None)
+    assert out is lat and "upsampler failed" in note
+
+
+def test_an_unknown_operation_is_reported_not_guessed():
+    lat = _video()
+    out, note = _node()._second_pass_operate(lat, "enhance", _FakeUpsampler(), None)
+    assert out is lat and "unknown operation" in note
+
+
+def test_the_pin_is_dropped_when_the_operation_changed_the_resolution():
+    """upscale_2x leaves the chunk's anchor and mask the wrong size. Rescaling them would be
+    inventing an anchor, so the pin is dropped — and the caller reports it."""
+    clean = torch.zeros(1, 4, 4, 8, 8)
+    mask = torch.ones_like(clean)
+    mask[:, :, :1] = 0.0
+    chunk = {"samples": clean, "noise_mask": mask}
+    upscaled = {"samples": torch.zeros(1, 4, 4, 16, 16)}
+    assert _node()._restore_pinned_prefix(upscaled, chunk) is upscaled

From 8d0e7ffaa370b38ada29ad4b6b8c17756ad271af Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Fri, 31 Jul 2026 13:42:37 +0300
Subject: [PATCH 21/29] second_pass: expose the pass-2 schedule in the Editor,
 move it out of Experimental
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Three corrections from the user, all right.

1. The pass-2 schedule needed no graph-topology change at all — I was wrong to leave
   it out. Studio has ALWAYS emitted a second schedule: _build_samplers builds both
   samplers_cfg["high"] and ["low"], and low_pass_sigmas is output 7. The Editor simply
   never wired it (sampler_panel.js even says so: "outputs 6+7 are not connected").
   So this is one CORE_LINKS entry, "second_pass_sigmas": ("studio", 7), plus surfacing
   the low pass's existing `sigmas` text field. No new node, no new output.

   Only the SIGMAS is taken, not the low-pass SAMPLER: pass 2 reuses the sampler
   configured above it. So the panel deliberately shows just that one field rather than
   the whole low-pass sampler section — rendering its algorithm settings would offer
   knobs that quietly do nothing, which is the thing the editor rules forbid.

2. No re-entry sigma in the Editor. With an explicit pass-2 schedule the first sigma of
   that schedule IS where pass 2 re-enters, so second_pass_restart_sigma was a redundant
   second way to say the same thing. Dropped from the Editor; still on the node for
   graph users with no second schedule wired, where it is the only way to say it.

3. Not experimental. At its defaults the split is behaviour-neutral by construction —
   pass 2 resumes from exactly the state pass 1 handed over, same step count, same
   output — so calling it experimental overstated it. Moved from Chain Sampler >
   Experimental to FunPack Studio > Sampler algorithm, next to the schedule field it
   depends on, and the EXPERIMENTAL / UNVALIDATED LIVE framing is gone from both
   tooltips.

Verified live in the running app: the Sampler algorithm pane shows the Second pass
group and the schedule field, the re-entry knob is gone, and typing a schedule persists
to studio_settings.samplers.low.sigmas (confirmed the high pass is untouched). Suites at
baseline: 22 pre-existing failures / 306 passing, movie_editor 163 passing.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 movie_editor/backend/builder.py          |  6 ++++++
 movie_editor/frontend/engine_settings.js | 13 +++++++++----
 movie_editor/frontend/sampler_panel.js   | 19 +++++++++++++++++--
 samplers.py                              |  2 +-
 4 files changed, 33 insertions(+), 7 deletions(-)

diff --git a/movie_editor/backend/builder.py b/movie_editor/backend/builder.py
index ad97932b..e5f8b9bb 100644
--- a/movie_editor/backend/builder.py
+++ b/movie_editor/backend/builder.py
@@ -63,6 +63,12 @@ CORE_LINKS: dict[str, dict[str, tuple[str, int]]] = {
     "cond":     {"positive": ("studio", 1), "negative": ("studio", 2), "frame_rate": ("fps", 0)},
     "sampler":  {"model": ("studio", 0), "positive": ("cond", 0), "negative": ("cond", 1),
                  "sampler": ("studio", 4), "sigmas": ("studio", 5),
+                 # Studio has always emitted a second schedule (low_pass_sigmas, output 7);
+                 # the Editor just never wired it. second_pass reads it as pass 2's schedule
+                 # and ignores it when empty, so this link costs nothing when the feature is
+                 # off. Only the SIGMAS is taken — pass 2 reuses the main sampler object, so
+                 # the low pass's sampler-type settings deliberately do not apply.
+                 "second_pass_sigmas": ("studio", 7),
                  "latent_template": ("concat", 0), "refinement_key_input": ("keyloader", 0),
                  "num_frames_per_scene": ("frames", 0)},
     "concat":   {"video_latent": ("studio", 12)},
diff --git a/movie_editor/frontend/engine_settings.js b/movie_editor/frontend/engine_settings.js
index 76bd8cc0..a11cfc23 100644
--- a/movie_editor/frontend/engine_settings.js
+++ b/movie_editor/frontend/engine_settings.js
@@ -239,11 +239,9 @@
     { name: "anchor_shift_fresh_audio", label: "Regenerate audio in pass 2", kind: "bool", default: true, dependsOn: "anchor_shift",
       hint: "Reset the audio to an empty latent before pass 2 so it's written fresh against the shifted picture. On by default because pass 1's audio was formed against frames that no longer sit at those positions. Turn off only to A/B whether the carried audio actually sounds better." },
     { name: "second_pass", label: "Enable second pass", kind: "bool", default: false,
-      hint: "EXPERIMENTAL: stop the schedule partway and finish the scene in a second sampling pass. Separate from Anchor shift, which runs its own two passes — when that acts on a scene this is skipped with a note. On its own, at restart sigma 0, the split is behaviour-neutral: pass 2 resumes from exactly the state pass 1 handed over, nothing added, same step count, same output. It earns its keep when the second half is made DIFFERENT — re-entering higher up the schedule so the model reworks what it has. The i2v anchor stays pinned across the split, so the scene doesn't drift off its reference image. Cost is exactly the extra steps you add: at restart 0 it's free. UNVALIDATED LIVE." },
+      hint: "Stop the schedule partway and finish the scene in a second sampling pass. Separate from Anchor shift, which runs its own two passes — when that acts on a scene this is skipped with a note. On its own, at restart sigma 0, the split is behaviour-neutral: pass 2 resumes from exactly the state pass 1 handed over, nothing added, same step count, same output. It earns its keep when the second half is made DIFFERENT — re-entering higher up the schedule so the model reworks what it has. The i2v anchor stays pinned across the split, so the scene doesn't drift off its reference image. Cost is exactly the extra steps you add: with no second-pass schedule set, it's free." },
     { name: "second_pass_sigma", label: "Second pass starts at sigma", kind: "float", default: 0.603, min: 0.001, max: 0.999, step: 0.001, dependsOn: "second_pass",
       hint: "Where pass 1 stops. The schedule is walked and the last pass-1 step is the one whose next sigma has crossed this value, so the cut always lands on a real step in your schedule — only sigmas actually in the schedule are reachable, and a value outside its range is refused with a reason rather than ignored." },
-    { name: "second_pass_restart_sigma", label: "Pass 2 re-enters at sigma", kind: "float", default: 0.0, min: 0.0, max: 0.999, step: 0.001, dependsOn: "second_pass",
-      hint: "0 (default) = carry straight on from the cut: nothing is added and the total cost is unchanged. A value ABOVE the cut rewinds — the half-denoised latent is rebuilt at that higher sigma (exact for a mid-trajectory latent, not the naive img2img re-noise) and those steps run again, letting the model rework structure it already committed to, at the cost of repeating them. Below the cut is refused: noise can be added back, never removed." },
     { name: "second_pass_op", label: "Between-pass operation", kind: "combo", choices: ["none", "sharpen", "upscale_2x"], default: "none", dependsOn: "second_pass",
       hint: "OPTIONAL operation applied to the latent between the two passes — 'none' by default, nothing runs unless you pick one. 'sharpen': one forward of Lightricks' trained 2x latent upsampler, resampled straight back to the original size. No video-model calls, so it costs a fraction of a step; pass 2 then re-denoises the sharpened latent, which is what makes it stick. It adds detail consistent with what's already there and CANNOT fix wrong structure (an extra finger stays an extra finger, just sharper). 'upscale_2x': the same upsampler, but kept at 2x — pass 2 runs at four times the pixels and the scene decodes at double resolution. That's 3-5x the cost of the second half, and it drops the i2v pin (the anchor and its mask are the old size, and rescaling them would be inventing an anchor), so the scene can drift from the reference image; the scene report says when that happens. Both use the same upsampler file as segmented detailing. Video only — audio is never reshaped." },
     { name: "context_windows", label: "Context windows (long scenes)", kind: "bool", default: false,
@@ -385,7 +383,7 @@
     chain_timing: ["frame_overlap", "transition_duration", "use_same_seed"],
     chain_guidance: ["cfg", "embed_guidance", "embed_guidance_source", "embed_guidance_strength", "score_slider", "score_slider_strength", "taste_nearest_prompt", "output_guidance", "output_guidance_strength", "dynashift", "dynashift_strength", "dynashift_threshold"],
     chain_decode: ["decode_noise_scale", "decode_timestep", "decode_tile_size"],
-    chain_experimental: ["anchor_shift", "anchor_shift_sigma", "anchor_shift_frames", "anchor_shift_restart_sigma", "anchor_shift_tail", "anchor_shift_fresh_audio", "second_pass", "second_pass_sigma", "second_pass_restart_sigma", "second_pass_op", "context_windows", "context_window_length", "context_window_overlap", "context_window_schedule", "context_window_fuse", "context_window_freenoise", "context_window_retain_first", "plateau_cache", "plateau_cache_threshold", "segmented_detailing", "detail_targets", "detail_strength", "detail_threshold", "detail_max_area", "detail_mode", "detail_denoise", "mid_scene_guide", "mid_scene_guide_strength", "joyai_memory", "joyai_memory_size", "joyai_fix_frames", "joyai_frame_select", "joyai_memory_strength", "joyai_audio_memory", "v2a_grad_scale", "alg_blur_guides", "alg_guide_blur_strength", "alg_guide_blur_sigma_threshold", "bounded_attention_enabled", "identity_transfer_enabled", "source_id", "phase_scale", "id_strength", "arcface_mode", "debug_log"],
+    chain_experimental: ["anchor_shift", "anchor_shift_sigma", "anchor_shift_frames", "anchor_shift_restart_sigma", "anchor_shift_tail", "anchor_shift_fresh_audio", "context_windows", "context_window_length", "context_window_overlap", "context_window_schedule", "context_window_fuse", "context_window_freenoise", "context_window_retain_first", "plateau_cache", "plateau_cache_threshold", "segmented_detailing", "detail_targets", "detail_strength", "detail_threshold", "detail_max_area", "detail_mode", "detail_denoise", "mid_scene_guide", "mid_scene_guide_strength", "joyai_memory", "joyai_memory_size", "joyai_fix_frames", "joyai_frame_select", "joyai_memory_strength", "joyai_audio_memory", "v2a_grad_scale", "alg_blur_guides", "alg_guide_blur_strength", "alg_guide_blur_sigma_threshold", "bounded_attention_enabled", "identity_transfer_enabled", "source_id", "phase_scale", "id_strength", "arcface_mode", "debug_log"],
   };
 
   function countChainView(p, id) {
@@ -568,6 +566,13 @@
       err.style.color = "var(--danger)";
       box.append(err);
     }
+    // Second pass lives here rather than under Experimental: at its defaults the split is
+    // behaviour-neutral (pass 2 resumes from exactly the state pass 1 handed over), so it
+    // is a sampler setting, not a gamble. Its pass-2 SCHEDULE is the "Second pass schedule"
+    // field in the panel above — which is why there is no separate re-entry sigma here: the
+    // first sigma of that schedule IS where pass 2 re-enters.
+    const g = group(pane, "Second pass");
+    renderKnobList(g, st, ["second_pass", "second_pass_sigma", "second_pass_op"]);
   }
 
   function renderChainContinuity(pane, st) {
diff --git a/movie_editor/frontend/sampler_panel.js b/movie_editor/frontend/sampler_panel.js
index 2be73342..2486cd59 100644
--- a/movie_editor/frontend/sampler_panel.js
+++ b/movie_editor/frontend/sampler_panel.js
@@ -335,9 +335,24 @@
       return () => quiet ? save(s) : saveNow(s);
     }
 
-    // Only the high-pass sampler is wired in the Movie Editor graph
-    // (studio outputs 4+5 → chain sampler; outputs 6+7 are not connected).
+    // The high-pass sampler is the one the Movie Editor graph runs (studio outputs 4+5).
     renderPass(container, "high", "Sampler", s.high, mkSave(true), mkSave(false));
+
+    // Second pass schedule. Studio's low-pass SIGMAS (output 7) is wired to the chain
+    // sampler's second_pass_sigmas, so this field alone is pass 2's schedule — deliberately
+    // NOT the whole low-pass sampler panel, because only its sigmas are connected: pass 2
+    // reuses the sampler configured above, and rendering its algorithm settings here would
+    // offer knobs that quietly do nothing.
+    sectionTag(container, "Second pass");
+    const spSig = textCtrl(s.low.sigmas, "e.g. 0.812, 0.6, 0.35, 0.15, 0.0", "sp-second-sig",
+      (v) => { s.low.sigmas = v; mkSave(true)(); });
+    row(container, "Second pass schedule", spSig);
+    hint(container, "Used when 'Enable second pass' is on below. Comma-separated floats — pass 2 "
+                    + "runs THIS schedule end to end instead of continuing along the main one, so "
+                    + "the second half can have its own step count and spacing. Its FIRST sigma is "
+                    + "where pass 2 re-enters, and it must be at or above the cut (the state can be "
+                    + "re-noised back up, never un-noised down). Leave empty to carry straight on "
+                    + "from the cut instead.");
   }
 
   window.SamplerPanel = { render, defaultSamplers, defaultPass };
diff --git a/samplers.py b/samplers.py
index 2780aa3b..4e08dfcc 100644
--- a/samplers.py
+++ b/samplers.py
@@ -2576,7 +2576,7 @@ class FunPackLTXAVSceneChainSampler:
                 # builder's positional reference-workflow mapping (extract_widgets) stays aligned.
                 "second_pass": ("BOOLEAN", {
                     "default": False,
-                    "tooltip": "EXPERIMENTAL: stop the schedule partway and finish the scene in a SECOND sampling pass. Independent of anchor_shift (which runs its own two passes — when anchor_shift acts on a scene this is skipped, with a note). On its own the split is behaviour-neutral at second_pass_restart_sigma=0: pass 2 resumes from exactly the state pass 1 handed over, no noise added, same total step count, so the output matches a single pass. It becomes useful when the second half is made DIFFERENT — re-entering higher up the schedule (second_pass_restart_sigma) to let the model rework what it has, or finishing on a different schedule entirely (the second_pass_sigmas input). The i2v anchor stays pinned across the split, so the scene does not drift off its reference. Cost is exactly the extra steps you add: at restart 0 with no second schedule it is free; re-entering higher costs the replayed steps. Off by default. UNVALIDATED LIVE.",
+                    "tooltip": "Stop the schedule partway and finish the scene in a SECOND sampling pass. Independent of anchor_shift (which runs its own two passes — when anchor_shift acts on a scene this is skipped, with a note). On its own the split is behaviour-neutral at second_pass_restart_sigma=0: pass 2 resumes from exactly the state pass 1 handed over, no noise added, same total step count, so the output matches a single pass. It becomes useful when the second half is made DIFFERENT — re-entering higher up the schedule (second_pass_restart_sigma) to let the model rework what it has, or finishing on a different schedule entirely (the second_pass_sigmas input). The i2v anchor stays pinned across the split, so the scene does not drift off its reference. Cost is exactly the extra steps you add: at restart 0 with no second schedule it is free; re-entering higher costs the replayed steps. Off by default.",
                 }),
                 "second_pass_sigma": ("FLOAT", {
                     "default": 0.603, "min": 0.001, "max": 0.999, "step": 0.001,

From 1c6afe2e4df97a9753409c99b1a26a185204be2d Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Fri, 31 Jul 2026 13:45:13 +0300
Subject: [PATCH 22/29] =?UTF-8?q?second=5Fpass:=20in=20the=20Editor=20it?=
 =?UTF-8?q?=20is=20just=20the=20schedule=20=E2=80=94=20enable=20and=20cut?=
 =?UTF-8?q?=20derived=20from=20it?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

User: "'2nd pass starts at' and '2nd pass re-enters at' are confusing - just give me
the schedule to operate and that's it." They are right, and it was two controls saying
the same thing in different words: with an explicit pass-2 schedule, where pass 1 stops
and where pass 2 re-enters are both simply that schedule's first sigma.

The Editor now has ONE control for this: the Second pass schedule field. Typing a
schedule turns the second pass on and sets the cut to its first sigma; clearing it turns
the pass off (both sampler inputs are unset, not left behind). Cut == entry, so the
hand-over is exact and nothing is re-noised — the case that needed the re-entry sigma
does not arise. Only the optional between-pass operation is left beside it.

Frontend-only derivation (syncSecondPassFromSchedule), so the node keeps its full
range: second_pass / second_pass_sigma / second_pass_restart_sigma are still there for
graph users with no schedule wired, where they are the only way to express a rewind.
A single number is not treated as a schedule.

Also cleaned up after my own UI verification: earlier passes had left anchor_shift=true
in the README demo project's sampler_inputs. Unset and saved — that was my residue, not
a setting the user picked.

Verified live: no "Enable second pass" / "starts at" / "re-enters at" controls remain in
the Editor; typing 0.812, 0.6, 0.35, 0.15, 0.0 yields second_pass=true and
second_pass_sigma=0.812, and clearing the field removes both. Suites at baseline: 22
pre-existing failures, 469 passing across both.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 movie_editor/frontend/engine_settings.js | 33 +++++++++++++++++-------
 movie_editor/frontend/sampler_panel.js   | 13 +++++-----
 2 files changed, 31 insertions(+), 15 deletions(-)

diff --git a/movie_editor/frontend/engine_settings.js b/movie_editor/frontend/engine_settings.js
index a11cfc23..566fad2b 100644
--- a/movie_editor/frontend/engine_settings.js
+++ b/movie_editor/frontend/engine_settings.js
@@ -238,11 +238,7 @@
       hint: "What fills the freed end after the slide. 'extend_last' (default) repeats the final frame so pass 2 grows the new ending out of something continuous with it. 'wrap' puts the dropped head back at the end — continuous, but it re-shows the reference image at the END of the clip. 'empty' zeroes it and lets pass 2 generate freely — most freedom, most likely to drift from the rest of the shot. 'crop' regrows NOTHING: the scene simply ends 'Frames to drop' earlier and comes out SHORTER than the length you set. It is the only mode with no invented ending and no joint to blend — every surviving frame was generated as part of one continuous shot — so it removes the thin-ending failure the other three can produce, and makes a rewind restart much less necessary. Audio is cropped to match. Use it when the shot matters more than the exact duration; avoid it when a scene has to hit a specific length. The scene report states the new length." },
     { name: "anchor_shift_fresh_audio", label: "Regenerate audio in pass 2", kind: "bool", default: true, dependsOn: "anchor_shift",
       hint: "Reset the audio to an empty latent before pass 2 so it's written fresh against the shifted picture. On by default because pass 1's audio was formed against frames that no longer sit at those positions. Turn off only to A/B whether the carried audio actually sounds better." },
-    { name: "second_pass", label: "Enable second pass", kind: "bool", default: false,
-      hint: "Stop the schedule partway and finish the scene in a second sampling pass. Separate from Anchor shift, which runs its own two passes — when that acts on a scene this is skipped with a note. On its own, at restart sigma 0, the split is behaviour-neutral: pass 2 resumes from exactly the state pass 1 handed over, nothing added, same step count, same output. It earns its keep when the second half is made DIFFERENT — re-entering higher up the schedule so the model reworks what it has. The i2v anchor stays pinned across the split, so the scene doesn't drift off its reference image. Cost is exactly the extra steps you add: with no second-pass schedule set, it's free." },
-    { name: "second_pass_sigma", label: "Second pass starts at sigma", kind: "float", default: 0.603, min: 0.001, max: 0.999, step: 0.001, dependsOn: "second_pass",
-      hint: "Where pass 1 stops. The schedule is walked and the last pass-1 step is the one whose next sigma has crossed this value, so the cut always lands on a real step in your schedule — only sigmas actually in the schedule are reachable, and a value outside its range is refused with a reason rather than ignored." },
-    { name: "second_pass_op", label: "Between-pass operation", kind: "combo", choices: ["none", "sharpen", "upscale_2x"], default: "none", dependsOn: "second_pass",
+    { name: "second_pass_op", label: "Between-pass operation", kind: "combo", choices: ["none", "sharpen", "upscale_2x"], default: "none",
       hint: "OPTIONAL operation applied to the latent between the two passes — 'none' by default, nothing runs unless you pick one. 'sharpen': one forward of Lightricks' trained 2x latent upsampler, resampled straight back to the original size. No video-model calls, so it costs a fraction of a step; pass 2 then re-denoises the sharpened latent, which is what makes it stick. It adds detail consistent with what's already there and CANNOT fix wrong structure (an extra finger stays an extra finger, just sharper). 'upscale_2x': the same upsampler, but kept at 2x — pass 2 runs at four times the pixels and the scene decodes at double resolution. That's 3-5x the cost of the second half, and it drops the i2v pin (the anchor and its mask are the old size, and rescaling them would be inventing an anchor), so the scene can drift from the reference image; the scene report says when that happens. Both use the same upsampler file as segmented detailing. Video only — audio is never reshaped." },
     { name: "context_windows", label: "Context windows (long scenes)", kind: "bool", default: false,
       hint: "EXPERIMENTAL: denoise a scene that's LONGER than the model's comfortable window as overlapping windows instead of one giant pass — ComfyUI core's own mechanism, audio-aware on LTX (it maps each video window to its audio window and re-slices anchors, guides and JoyAI memory per window). Engages only on scenes longer than the window length below; shorter scenes are untouched and pay nothing. Cost at the defaults (145/40) is about 1.45× the per-frame work, since each window re-does its 40-frame overlap — offset by attention getting cheaper the longer the scene is (quadratic in one pass, near-flat when windowed). Roughly break-even around 200 frames, a net win past ~300. Needs ComfyUI v0.29.0 or newer; on older builds it's skipped with a note in the scene report. UNVALIDATED LIVE." },
@@ -556,6 +552,25 @@
       const next = JSON.stringify({ ...cur, samplers: updatedSamplers });
       if (quiet) S.setStudioInput("studio_settings", next);
       else S.setStudioInputNow("studio_settings", next);
+      syncSecondPassFromSchedule(updatedSamplers, quiet);
+    }
+    // The second pass is driven by ONE thing here: the schedule. Typing one turns it on and
+    // pass 1 stops where that schedule starts; clearing it turns it off. The node's own
+    // enable/cut widgets still exist for graph users with no schedule wired, but exposing
+    // them alongside the schedule meant two controls saying the same thing in different
+    // words ("starts at" vs "re-enters at"), which is exactly what made it confusing.
+    function syncSecondPassFromSchedule(samplers, quiet) {
+      const raw = String(samplers?.low?.sigmas || "").replace(/;/g, ",");
+      const vals = raw.split(",").map((v) => parseFloat(v.trim())).filter((v) => !isNaN(v));
+      const set = quiet ? S.setSamplerInput : S.setSamplerInputNow;
+      // Two real sigmas minimum — one number is not a schedule.
+      if (vals.length >= 2 && vals[0] > 0 && vals[0] < 1) {
+        set("second_pass", true);
+        set("second_pass_sigma", vals[0]);   // cut == entry -> an exact hand-over, no re-noise
+      } else {
+        S.unsetSamplerInput("second_pass");
+        S.unsetSamplerInput("second_pass_sigma");
+      }
     }
     try {
       window.SamplerPanel.render(box, samplers,
@@ -568,11 +583,11 @@
     }
     // Second pass lives here rather than under Experimental: at its defaults the split is
     // behaviour-neutral (pass 2 resumes from exactly the state pass 1 handed over), so it
-    // is a sampler setting, not a gamble. Its pass-2 SCHEDULE is the "Second pass schedule"
-    // field in the panel above — which is why there is no separate re-entry sigma here: the
-    // first sigma of that schedule IS where pass 2 re-enters.
+    // is a sampler setting, not a gamble. The only control is the schedule field in the
+    // panel above — enable and cut are derived from it (see syncSecondPassFromSchedule);
+    // all that is left here is the optional between-pass operation.
     const g = group(pane, "Second pass");
-    renderKnobList(g, st, ["second_pass", "second_pass_sigma", "second_pass_op"]);
+    renderKnobList(g, st, ["second_pass_op"]);
   }
 
   function renderChainContinuity(pane, st) {
diff --git a/movie_editor/frontend/sampler_panel.js b/movie_editor/frontend/sampler_panel.js
index 2486cd59..9902c193 100644
--- a/movie_editor/frontend/sampler_panel.js
+++ b/movie_editor/frontend/sampler_panel.js
@@ -347,12 +347,13 @@
     const spSig = textCtrl(s.low.sigmas, "e.g. 0.812, 0.6, 0.35, 0.15, 0.0", "sp-second-sig",
       (v) => { s.low.sigmas = v; mkSave(true)(); });
     row(container, "Second pass schedule", spSig);
-    hint(container, "Used when 'Enable second pass' is on below. Comma-separated floats — pass 2 "
-                    + "runs THIS schedule end to end instead of continuing along the main one, so "
-                    + "the second half can have its own step count and spacing. Its FIRST sigma is "
-                    + "where pass 2 re-enters, and it must be at or above the cut (the state can be "
-                    + "re-noised back up, never un-noised down). Leave empty to carry straight on "
-                    + "from the cut instead.");
+    hint(container, "Fill this in and the scene is sampled in two passes; leave it empty and it "
+                    + "isn't. Comma-separated floats. Pass 1 runs the main schedule down to the "
+                    + "FIRST sigma listed here, then pass 2 takes over and runs this schedule to "
+                    + "the end — so the second half can have its own step count and spacing. "
+                    + "Nothing is added at the hand-over, so with a schedule that simply continues "
+                    + "where the first left off the result matches a single pass; the cost is only "
+                    + "whatever extra steps you list.");
   }
 
   window.SamplerPanel = { render, defaultSamplers, defaultPass };

From 63f225e231850fc45b70900c023433adde31cb8a Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Fri, 31 Jul 2026 13:55:48 +0300
Subject: [PATCH 23/29] =?UTF-8?q?second=5Fpass:=20both=20schedules=20run?=
 =?UTF-8?q?=20in=20FULL=20=E2=80=94=20remove=20the=20cut=20I=20invented?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

User, after a live run: "First pass runs its own FULL schedule. Then 2nd pass begins.
If I want to stop 1st pass earlier - I remove sigmas from schedule... 'Continue from'
is ONLY relevant in our shifting technique which is a separate entity."

Correct, and the cut was mine, not theirs. I carried anchor_shift's cut/restart
semantics into a feature that has no use for them. Consequences they hit on the rental:

- Steps. Pass 1 was cut at the second schedule's first sigma, so a 9-step main plus a
  4-step second pass ran 3+4=7, not 13. They noticed the missing steps.
- Distortion. With the cut, the between-pass operation ran on a MID-TRAJECTORY latent,
  so "sharpen" was sharpening the noise still in it. It only makes sense on a finished
  clip.

Now: pass 1 runs the main schedule in full, exactly as written. The operation runs on
that finished clip. Pass 2 runs second_pass_sigmas in full, exactly as written, entering
the way any img2img refine does — comfy's ordinary CONST scaling on a clean latent, so
continue_from_state stays off. Total steps are the two schedules added up. To make pass 1
shorter, shorten the main schedule.

second_pass_sigma and second_pass_restart_sigma are deleted outright: with both schedules
run as written there is nothing to cut and nothing to continue from. The second schedule's
first sigma is now simply the strength dial, the way it is in every img2img refine.
_second_pass_plan is replaced by _second_pass_schedule, which only validates.

Also reported: "I have only sharpening enabled but log tells me upsampling is enabled as
well." The load line printed "[FunPackSceneChain] segmented detailing upsampler: ..."
regardless of which feature pulled it in, and sharpen legitimately loads that model —
so a sharpen-only run announced a feature that was off. Now "latent upsampler loaded".

Kept: the malformed-schedule refusals (ascending, or not ending at 0) — both are silent
in the output rather than loud at runtime, which is how the distorted run read.

tests/test_second_pass.py rewritten around the corrected shape, including that a 9-step
main plus a 4-step second pass is 13. Suites at baseline: 22 pre-existing failures, 467
passing. Verified live that typing a schedule sets second_pass with no cut knob leaking.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 movie_editor/frontend/engine_settings.js |  19 +--
 movie_editor/frontend/sampler_panel.js   |  16 +-
 samplers.py                              | 180 ++++++++---------------
 tests/test_second_pass.py                | 119 ++++++---------
 4 files changed, 120 insertions(+), 214 deletions(-)

diff --git a/movie_editor/frontend/engine_settings.js b/movie_editor/frontend/engine_settings.js
index 566fad2b..ab31de20 100644
--- a/movie_editor/frontend/engine_settings.js
+++ b/movie_editor/frontend/engine_settings.js
@@ -554,24 +554,17 @@
       else S.setStudioInputNow("studio_settings", next);
       syncSecondPassFromSchedule(updatedSamplers, quiet);
     }
-    // The second pass is driven by ONE thing here: the schedule. Typing one turns it on and
-    // pass 1 stops where that schedule starts; clearing it turns it off. The node's own
-    // enable/cut widgets still exist for graph users with no schedule wired, but exposing
-    // them alongside the schedule meant two controls saying the same thing in different
-    // words ("starts at" vs "re-enters at"), which is exactly what made it confusing.
+    // The second pass is driven by ONE thing: the schedule. Typing one turns it on; clearing
+    // it turns it off. There is no cut and no re-entry point to configure — pass 1 always runs
+    // the main schedule in full and pass 2 always runs this one in full.
     function syncSecondPassFromSchedule(samplers, quiet) {
       const raw = String(samplers?.low?.sigmas || "").replace(/;/g, ",");
       const vals = raw.split(",").map((v) => parseFloat(v.trim())).filter((v) => !isNaN(v));
       const set = quiet ? S.setSamplerInput : S.setSamplerInputNow;
-      // Two real sigmas minimum — one number is not a schedule.
-      if (vals.length >= 2 && vals[0] > 0 && vals[0] < 1) {
-        set("second_pass", true);
-        set("second_pass_sigma", vals[0]);   // cut == entry -> an exact hand-over, no re-noise
-      } else {
-        S.unsetSamplerInput("second_pass");
-        S.unsetSamplerInput("second_pass_sigma");
-      }
+      if (vals.length >= 2) set("second_pass", true);       // one number is not a schedule
+      else S.unsetSamplerInput("second_pass");
     }
+
     try {
       window.SamplerPanel.render(box, samplers,
         (s) => persistSamplers(s, true),
diff --git a/movie_editor/frontend/sampler_panel.js b/movie_editor/frontend/sampler_panel.js
index 9902c193..3a9f364f 100644
--- a/movie_editor/frontend/sampler_panel.js
+++ b/movie_editor/frontend/sampler_panel.js
@@ -347,13 +347,15 @@
     const spSig = textCtrl(s.low.sigmas, "e.g. 0.812, 0.6, 0.35, 0.15, 0.0", "sp-second-sig",
       (v) => { s.low.sigmas = v; mkSave(true)(); });
     row(container, "Second pass schedule", spSig);
-    hint(container, "Fill this in and the scene is sampled in two passes; leave it empty and it "
-                    + "isn't. Comma-separated floats. Pass 1 runs the main schedule down to the "
-                    + "FIRST sigma listed here, then pass 2 takes over and runs this schedule to "
-                    + "the end — so the second half can have its own step count and spacing. "
-                    + "Nothing is added at the hand-over, so with a schedule that simply continues "
-                    + "where the first left off the result matches a single pass; the cost is only "
-                    + "whatever extra steps you list.");
+hint(container, "Fill this in and each scene is sampled in two passes; leave it empty and "
+                    + "it isn't. Comma-separated floats, high to low, ending at 0. Pass 1 "
+                    + "runs the main Sigmas schedule above in full, then pass 2 runs THIS "
+                    + "one in full, so the total is simply the two added up (a 9-step main "
+                    + "plus a 4-step second pass is 13). Pass 2 starts from the finished "
+                    + "clip and re-noises it up to your first sigma, so that value is the "
+                    + "strength dial — near 1.0 reworks the shot, low values only polish "
+                    + "it — and the rest sets how many steps it gets. To make pass 1 "
+                    + "shorter, shorten the schedule above; nothing here cuts it short.");
   }
 
   window.SamplerPanel = { render, defaultSamplers, defaultPass };
diff --git a/samplers.py b/samplers.py
index 4e08dfcc..30f62699 100644
--- a/samplers.py
+++ b/samplers.py
@@ -2576,15 +2576,7 @@ class FunPackLTXAVSceneChainSampler:
                 # builder's positional reference-workflow mapping (extract_widgets) stays aligned.
                 "second_pass": ("BOOLEAN", {
                     "default": False,
-                    "tooltip": "Stop the schedule partway and finish the scene in a SECOND sampling pass. Independent of anchor_shift (which runs its own two passes — when anchor_shift acts on a scene this is skipped, with a note). On its own the split is behaviour-neutral at second_pass_restart_sigma=0: pass 2 resumes from exactly the state pass 1 handed over, no noise added, same total step count, so the output matches a single pass. It becomes useful when the second half is made DIFFERENT — re-entering higher up the schedule (second_pass_restart_sigma) to let the model rework what it has, or finishing on a different schedule entirely (the second_pass_sigmas input). The i2v anchor stays pinned across the split, so the scene does not drift off its reference. Cost is exactly the extra steps you add: at restart 0 with no second schedule it is free; re-entering higher costs the replayed steps. Off by default.",
-                }),
-                "second_pass_sigma": ("FLOAT", {
-                    "default": 0.603, "min": 0.001, "max": 0.999, "step": 0.001,
-                    "tooltip": "Where pass 1 stops. The schedule is walked and the last pass-1 step is the one whose NEXT sigma has crossed this value, so the cut always lands on a real schedule step — only the sigmas actually in your schedule are reachable. Both halves need at least one step, so a value outside the schedule's range is refused with a reason rather than silently ignored.",
-                }),
-                "second_pass_restart_sigma": ("FLOAT", {
-                    "default": 0.0, "min": 0.0, "max": 0.999, "step": 0.001,
-                    "tooltip": "Where pass 2 re-enters, when no second_pass_sigmas schedule is connected. 0 (default) = carry straight on from the cut: nothing is added, total cost unchanged. A value ABOVE second_pass_sigma rewinds — the half-denoised latent is rebuilt at that higher sigma (exact for a mid-trajectory latent, not the naive img2img re-noise) and those steps run again, letting the model rework structure it has already committed to, at the cost of repeating them. BELOW the cut is refused: noise can be added back, never removed. Ignored when second_pass_sigmas is connected, since that schedule's own first sigma is the entry point.",
+                    "tooltip": "Sample each scene in TWO passes. Pass 1 runs the main sigmas schedule in full, exactly as written; pass 2 then runs the second_pass_sigmas schedule in full, exactly as written, starting from pass 1's finished clip. Nothing is cut short and nothing is derived — to make pass 1 shorter, shorten the main schedule. Total steps are simply the two schedules added up (a 9-step main plus a 4-step second pass is 13). Pass 2 re-enters the way any img2img refine does, by re-noising the finished clip up to its first sigma, so that first sigma controls how much it is allowed to change: nearer 1.0 reworks the shot, low values only polish it. Requires a second_pass_sigmas schedule; without one the pass is skipped with a note. Independent of anchor_shift, which runs its own two passes for a different reason — when it acts on a scene, this is skipped.",
                 }),
                 "second_pass_op": (["none", "sharpen", "upscale_2x"], {
                     "default": "none",
@@ -2593,7 +2585,8 @@ class FunPackLTXAVSceneChainSampler:
                 # A connection socket, never a widget — safe at the end, and it must stay after
                 # every widget above (see the widgets_values note at the top of this block).
                 "second_pass_sigmas": ("SIGMAS", {
-                    "tooltip": "Optional SEPARATE schedule for pass 2. Wire any scheduler here and pass 2 runs that schedule end to end instead of continuing along the main one — so the second half can have a different step count, spacing or shift from the first (e.g. a short, fine tail schedule over a coarse first pass). Its FIRST sigma is where pass 2 re-enters, so it must start at or above second_pass_sigma (the state can be re-noised back up, never un-noised down); second_pass_restart_sigma is ignored when this is connected. The sampler is told this schedule is pass 2's real schedule, so its own phases (quality steps, final-correction window, AB2 ramp) are measured against it rather than against the main one.",
+                    "tooltip": "The schedule pass 2 runs — required for second_pass, and it is run EXACTLY as written, high to low, ending at 0. Wire any scheduler here, or type sigmas in the Editor. Pass 1 has already finished the main schedule by this point, so pass 2 starts from a clean clip and re-enters by re-noising it up to this schedule's FIRST sigma: that value is the strength dial (near 1.0 reworks the shot, low values only polish it), and the rest of the schedule sets how many steps it gets. A schedule that ascends, or that stops above 0, is refused with the reason — both would silently produce a distorted or under-denoised clip rather than fail loudly.",
+
                 }),
             },
             "hidden": {
@@ -3170,70 +3163,35 @@ class FunPackLTXAVSceneChainSampler:
         # which the sampler needs to keep its phase boundaries where the schedule put them.
         return first, second, vals[cut], vals[start], resume, start
 
-    def _second_pass_plan(self, sigmas, cut_sigma, restart_sigma, alt_sigmas=None):
-        """Plan a general two-pass run, optionally finishing on a DIFFERENT schedule.
+    def _second_pass_schedule(self, alt_sigmas):
+        """Validate the pass-2 schedule. Returns (sigmas, reason); one of them is None.
 
-        Returns (plan, reason). `plan` is None when the request cannot be honoured, and
-        `reason` then says why and what to change — never a silent no-op.
+        There is nothing to derive here and nothing to cut. Pass 1 runs the main schedule in
+        full, exactly as written; pass 2 then runs THIS schedule in full, exactly as written.
+        Pass 2 therefore starts from a FINISHED clip, which is the ordinary img2img re-entry
+        (comfy's CONST scaling, x = s*noise + (1-s)*clean, valid precisely because the input
+        is clean). "Continue from where pass 1 stopped" belongs to anchor_shift, which stops
+        mid-trajectory on purpose; it has no meaning here. To make pass 1 shorter, shorten
+        the main schedule.
 
-        plan = (pass1_sigmas, pass2_sigmas, cut_at, entry_at, resume, pass2_context)
-
-        Pass 1 always runs the top of `sigmas` down to the first sigma at or below
-        `cut_sigma` (same walk as anchor_shift: the last pre-cut step is the one whose NEXT
-        sigma crosses the threshold). Pass 2 is either a slice of the same schedule starting
-        at `restart_sigma` (0 = continue straight on from the cut), or — when `alt_sigmas` is
-        connected — that schedule in its entirety, entered at its own first sigma.
-
-        Either way pass 2 re-enters at a sigma at or above the cut, because _renoise_to_sigma
-        can add noise back but never remove it. `pass2_context` is what the sampler must be
-        told its real schedule is: the main schedule with an offset when pass 2 is a slice of
-        it, or the alternate schedule at offset 0 when pass 2 IS that whole schedule.
+        A hand-typed schedule is the one input that can be malformed, and both ways it can
+        be are silent in the OUTPUT rather than loud at runtime, so they are caught here.
         """
-        if not isinstance(sigmas, torch.Tensor) or sigmas.numel() < 3:
-            return None, "the main schedule needs at least 3 sigmas to be split"
-        vals = [float(v) for v in sigmas.tolist()]
-        eps = 1e-4  # SIGMAS are float32; see _anchor_shift_split_sigmas for why this matters
-
-        def _first_at_or_below(seq, s):
-            return next((i for i, v in enumerate(seq) if v <= s + eps), None)
-
-        cut = _first_at_or_below(vals, float(cut_sigma))
-        if cut is None or cut < 1:
-            return None, (f"second_pass_sigma={float(cut_sigma):g} is not reached by the schedule "
-                          f"with a step left before it — pass 1 would have no step to run")
-        first = sigmas[:cut + 1]
-        if first.numel() < 2:
-            return None, "pass 1 would have no step"
-        cut_at = vals[cut]
-
-        if isinstance(alt_sigmas, torch.Tensor) and alt_sigmas.numel() >= 2:
-            # Pass 2 runs its OWN schedule end to end. Its first sigma is where it re-enters,
-            # so that is what the state has to be rebuilt at.
-            second = alt_sigmas
-            entry_at = float(alt_sigmas[0].item())
-            ctx = {"sigmas": alt_sigmas, "offset": 0}
-            if entry_at < cut_at - eps:
-                return None, (f"second_pass_sigmas starts at {entry_at:g}, below "
-                              f"second_pass_sigma={cut_at:g} — pass 2 can be handed a noisier "
-                              f"latent than pass 1 left, never a cleaner one. Start the second "
-                              f"schedule at or above the cut, or lower second_pass_sigma")
-        else:
-            restart = float(restart_sigma)
-            if restart <= 0:
-                start = cut
-            else:
-                start = _first_at_or_below(vals, restart)
-                if start is None or start > cut:
-                    return None, (f"second_pass_restart_sigma={restart:g} is below "
-                                  f"second_pass_sigma={cut_at:g} — pass 2 can be handed a noisier "
-                                  f"latent than pass 1 left, never a cleaner one. Use 0 to carry "
-                                  f"straight on from the cut, or a value at or above it")
-            second = sigmas[start:]
-            entry_at = vals[start]
-            ctx = {"sigmas": sigmas, "offset": start}
-        if second.numel() < 2:
-            return None, "pass 2 would have no step"
-        return (first, second, cut_at, entry_at, abs(entry_at - cut_at) <= eps, ctx), None
+        if not isinstance(alt_sigmas, torch.Tensor) or alt_sigmas.numel() < 2:
+            return None, ("no second-pass schedule — set one (comma-separated sigmas, high to "
+                          "low, ending at 0) or turn the second pass off")
+        vals = [float(v) for v in alt_sigmas.tolist()]
+        eps = 1e-4
+        if any(b > a + eps for a, b in zip(vals, vals[1:])):
+            return None, ("second-pass schedule must descend — "
+                          f"{', '.join(f'{v:g}' for v in vals)} goes back up, which walks the "
+                          f"trajectory backwards. List the sigmas high to low")
+        if vals[-1] > eps:
+            return None, (f"second-pass schedule ends at {vals[-1]:g}, not 0 — the scene would "
+                          f"come out partially denoised (noise artefacts). End it at 0")
+        if vals[0] <= eps:
+            return None, "second-pass schedule starts at 0 — there is nothing for it to denoise"
+        return alt_sigmas, None
 
     def _second_pass_operate(self, latent, op, upsampler, vae):
         """Apply the chosen latent-space operation between the two passes.
@@ -5282,8 +5240,7 @@ class FunPackLTXAVSceneChainSampler:
                anchor_shift=False, anchor_shift_sigma=0.909, anchor_shift_frames=8,
                anchor_shift_restart_sigma=0.0, anchor_shift_tail="extend_last",
                anchor_shift_fresh_audio=True,
-               second_pass=False, second_pass_sigma=0.603,
-               second_pass_restart_sigma=0.0, second_pass_op="none", second_pass_sigmas=None,
+               second_pass=False, second_pass_op="none", second_pass_sigmas=None,
                unique_id=None, prompt=None):
         if not isinstance(positive, list) or not positive:
             raise ValueError("positive conditioning must contain at least one scene entry.")
@@ -5353,9 +5310,8 @@ class FunPackLTXAVSceneChainSampler:
                 anchor_shift_restart_sigma=anchor_shift_restart_sigma,
                 anchor_shift_tail=anchor_shift_tail,
                 anchor_shift_fresh_audio=anchor_shift_fresh_audio,
-                second_pass=second_pass, second_pass_sigma=second_pass_sigma,
-                second_pass_restart_sigma=second_pass_restart_sigma,
-                second_pass_op=second_pass_op, second_pass_sigmas=second_pass_sigmas,
+                second_pass=second_pass, second_pass_op=second_pass_op,
+                second_pass_sigmas=second_pass_sigmas,
             )
 
         max_scene_count = max(1, int(max_scenes))
@@ -5934,24 +5890,31 @@ class FunPackLTXAVSceneChainSampler:
                     # General second pass. Reaching this branch means anchor_shift did not act
                     # on this scene (it is either off, or was skipped with a reason above), so
                     # the two features never nest — they stay independent by construction.
-                    _sp_plan = None
+                    #
+                    # The shape is deliberately plain: pass 1 runs the main schedule IN FULL,
+                    # exactly as written, then pass 2 runs its own schedule IN FULL, exactly as
+                    # written. Nothing is cut and nothing is "continued from" — those belong to
+                    # anchor_shift, which stops mid-trajectory on purpose. To make pass 1
+                    # shorter, shorten the main schedule. Pass 2 therefore starts from a
+                    # FINISHED clip, so it re-enters through comfy's ordinary CONST noise
+                    # scaling (continue_from_state stays off) — valid precisely because the
+                    # input is clean. Total steps are simply the two schedules added up.
+                    _sp_b = None
                     if second_pass:
-                        _sp_plan, _sp_reason = self._second_pass_plan(
-                            sigmas, second_pass_sigma, second_pass_restart_sigma,
-                            second_pass_sigmas)
-                        if _sp_plan is None:
+                        _sp_b, _sp_reason = self._second_pass_schedule(second_pass_sigmas)
+                        if _sp_b is None:
                             run_mechanisms.append(f"second_pass(SKIPPED: {_sp_reason})")
-                    if _sp_plan is not None:
-                        _sp_a, _sp_b, _sp_cut, _sp_entry, _sp_resume, _sp_ctx = _sp_plan
-                        _sp_p1 = self._sample_chunk(
-                            model, sampler, _sp_a, scene_seed, cfg, scene_positive,
-                            scene_negative, chunk,
-                            schedule_context={"sigmas": sigmas, "offset": 0}, **_sample_kwargs)
-                        _sp_state = _sp_p1
+                    _full = self._sample_chunk(
+                        model, sampler, sigmas, scene_seed, cfg, scene_positive,
+                        scene_negative, chunk, **_sample_kwargs)
+                    if _sp_b is None:
+                        sampled = _full
+                    else:
+                        _sp_state = _full
                         if second_pass_op not in (None, "none", ""):
-                            # Operate BEFORE the re-noise: sharpening a latent that has just had
-                            # noise added back would sharpen the noise. Shares segmented
-                            # detailing's lazily-loaded upsampler — same model, same knob.
+                            # The op runs on the FINISHED pass-1 clip, which is the only state
+                            # it makes sense on: sharpening a half-denoised latent sharpens the
+                            # noise in it. Shares segmented detailing's lazily-loaded upsampler.
                             if _detail_upsampler_model is None and _detail_disabled_reason is None:
                                 try:
                                     try:
@@ -5970,17 +5933,12 @@ class FunPackLTXAVSceneChainSampler:
                                 run_mechanisms.append(
                                     f"second_pass_op={second_pass_op} skipped: upsampler "
                                     f"unavailable ({_detail_disabled_reason})")
-                        if not _sp_resume:
-                            # Rebuild the state at the higher entry sigma. Fresh field: reusing
-                            # scene_seed would re-apply the exact noise pass 1 just resolved.
-                            _sp_state = self._renoise_to_sigma(
-                                _sp_state, _sp_cut, _sp_entry, scene_seed + 4242)
                         # Unlike anchor_shift, a plain second pass must KEEP the i2v anchor
                         # pinned — otherwise pass 2 re-denoises the reference frame and the
                         # scene drifts away from the image it was supposed to start from.
                         _sp_before = _sp_state
                         _sp_state = self._restore_pinned_prefix(_sp_state, chunk)
-                        if (_sp_state is _sp_before and self._anchor_pinned_frames(chunk) > 0):
+                        if _sp_state is _sp_before and self._anchor_pinned_frames(chunk) > 0:
                             # Only happens when the op changed the resolution — say so, because
                             # an unpinned pass 2 can drift off the reference image.
                             run_mechanisms.append(
@@ -5988,23 +5946,15 @@ class FunPackLTXAVSceneChainSampler:
                                 "because second_pass_op changed the latent resolution — pass 2 runs "
                                 "unpinned and may drift from the reference image.")
                         _sp_kw = dict(_sample_kwargs)
-                        _sp_kw["step_offset"] = _sample_kwargs["step_offset"] + (_sp_a.numel() - 1)
-                        _sp_kw["continue_from_state"] = True
-                        _sp_kw["schedule_context"] = _sp_ctx
+                        _sp_kw["step_offset"] = _sample_kwargs["step_offset"] + (int(sigmas.numel()) - 1)
                         sampled = self._sample_chunk(
                             model, sampler, _sp_b, scene_seed + 4242, cfg, scene_positive,
                             scene_negative, _sp_state, **_sp_kw)
-                        _sp_alt = (isinstance(second_pass_sigmas, torch.Tensor)
-                                   and second_pass_sigmas.numel() >= 2)
                         run_mechanisms.append(
-                            f"second_pass({'continue' if _sp_resume else 'rewind'} "
-                            f"cut@{_sp_cut:g} entry@{_sp_entry:g}, "
-                            f"{_sp_a.numel() - 1}+{_sp_b.numel() - 1} steps"
-                            f"{', own schedule' if _sp_alt else ''})")
-                    else:
-                        sampled = self._sample_chunk(
-                            model, sampler, sigmas, scene_seed, cfg, scene_positive,
-                            scene_negative, chunk, **_sample_kwargs)
+                            f"second_pass({int(sigmas.numel()) - 1} steps + "
+                            f"{int(_sp_b.numel()) - 1} steps = "
+                            f"{int(sigmas.numel()) + int(_sp_b.numel()) - 2} total, "
+                            f"pass 2 from {float(_sp_b[0].item()):g})")
                 _scene_sample_s = _time.perf_counter() - _t_sample0
                 _phase_sampling += _scene_sample_s
                 if _plateau_stats is not None:
@@ -6043,7 +5993,7 @@ class FunPackLTXAVSceneChainSampler:
                     if _detail_upsampler_model is None:
                         _resolved = _detailing.resolve_upsampler_name(detail_upsampler)
                         _detail_upsampler_model = _detailing.load_latent_upsampler(_resolved)
-                        print(f"[FunPackSceneChain] segmented detailing upsampler: {_resolved}")
+                        print(f"[FunPackSceneChain] latent upsampler loaded: {_resolved}")
                     _t_detail0 = _time.perf_counter()
                     sampled, _detail_note = _detailing.detail_refine_scene(
                         self, model, vae, sampler, scene_positive, scene_negative, sampled,
@@ -6345,8 +6295,7 @@ class FunPackLTXAVSceneChainSampler:
                             anchor_shift=False, anchor_shift_sigma=0.909, anchor_shift_frames=8,
                             anchor_shift_restart_sigma=0.0, anchor_shift_tail="extend_last",
                             anchor_shift_fresh_audio=True,
-                            second_pass=False, second_pass_sigma=0.603,
-                            second_pass_restart_sigma=0.0, second_pass_op="none",
+                            second_pass=False, second_pass_op="none",
                             second_pass_sigmas=None):
         """Sample one chain per Studio-packed variant entry (seed + index), persisting each result
         (latent + preview + per-entry cond + manifest) under ComfyUI temp for rating in Studio.
@@ -6412,9 +6361,8 @@ class FunPackLTXAVSceneChainSampler:
                 anchor_shift_restart_sigma=anchor_shift_restart_sigma,
                 anchor_shift_tail=anchor_shift_tail,
                 anchor_shift_fresh_audio=anchor_shift_fresh_audio,
-                second_pass=second_pass, second_pass_sigma=second_pass_sigma,
-                second_pass_restart_sigma=second_pass_restart_sigma,
-                second_pass_op=second_pass_op, second_pass_sigmas=second_pass_sigmas,
+                second_pass=second_pass, second_pass_op=second_pass_op,
+                second_pass_sigmas=second_pass_sigmas,
                 unique_id=None, prompt=None,
             )
             last = out
diff --git a/tests/test_second_pass.py b/tests/test_second_pass.py
index 10a5bd7b..b8d08515 100644
--- a/tests/test_second_pass.py
+++ b/tests/test_second_pass.py
@@ -4,14 +4,15 @@ anchor_shift built the machinery (stop the schedule, hand the state over, re-ent
 this exposes it on its own so a scene can be finished differently from how it was started.
 The invariants that matter here are the ones a split can silently get wrong:
 
-1. Pass 1 stops on a REAL step of the user's schedule, found by walking it.
-2. Pass 2 re-enters at or above the cut — never below, because noise can be added back but
-   never removed (the same rule anchor_shift's rewind lives by).
-3. A connected second schedule replaces pass 2 wholesale, and its own first sigma becomes
-   the entry point, so the sampler's phases are measured against IT and not the main one.
-4. Nothing is ever a silent no-op: every refusal comes back with a reason naming the fix.
-5. The i2v anchor stays PINNED across the split — the opposite of anchor_shift, which
-   deletes the pin on purpose. Without this pass 2 re-denoises the reference frame.
+1. BOTH schedules run in full, exactly as written. Pass 1 is not cut short and pass 2 is
+   not derived from it — total steps are simply the two added up. (An earlier version cut
+   pass 1 at pass 2's first sigma, which is anchor_shift's behaviour and does not belong
+   here; it silently shortened the run and distorted the result.)
+2. A hand-typed schedule is the one malformed-able input, and both ways it can be wrong
+   are silent in the OUTPUT rather than loud at runtime, so they are refused up front.
+3. Nothing is ever a silent no-op: every refusal comes back with a reason naming the fix.
+4. The i2v anchor stays PINNED for pass 2 — the opposite of anchor_shift, which deletes
+   the pin on purpose. Without this pass 2 re-denoises the reference frame.
 """
 import sys
 import types
@@ -44,88 +45,50 @@ def _node():
     return samplers.FunPackLTXAVSceneChainSampler()
 
 
-def _plan(cut, restart=0.0, alt=None):
-    return _node()._second_pass_plan(SCHEDULE, cut, restart, alt)
+# ── the pass-2 schedule ─────────────────────────────────────────────────────
+
+def _sched(alt):
+    return _node()._second_pass_schedule(alt)
 
 
-# ── the split ───────────────────────────────────────────────────────────────
-
-def test_continue_splits_the_schedule_without_adding_a_step():
-    """restart 0 is behaviour-neutral: the two halves are the whole schedule, cut once, and
-    pass 2 resumes from the exact handed-over state (resume=True -> no re-noise)."""
-    plan, reason = _plan(0.603)
-    assert reason is None
-    first, second, cut_at, entry_at, resume, ctx = plan
-    assert [round(v, 3) for v in first.tolist()] == [1.0, 0.955, 0.893, 0.812, 0.715, 0.603]
-    assert [round(v, 3) for v in second.tolist()] == [0.603, 0.482, 0.241, 0.121, 0.0]
-    assert abs(cut_at - 0.603) < 1e-5 and abs(entry_at - 0.603) < 1e-5
-    assert resume is True
-    # No step is run twice: 5 + 4 == the schedule's own 9.
-    assert (first.numel() - 1) + (second.numel() - 1) == SCHEDULE.numel() - 1
-    # Pass 2's phases must still be measured against the whole schedule.
-    assert ctx["sigmas"] is SCHEDULE and ctx["offset"] == 5
+def test_a_well_formed_schedule_is_taken_exactly_as_written():
+    """Nothing is derived, cut or continued. Pass 1 runs the main schedule in full and pass 2
+    runs this one in full, so on the user's 9-step main a 4-step second pass is 13 steps —
+    not a re-slicing of the main schedule."""
+    alt = torch.tensor([0.812, 0.6, 0.35, 0.15, 0.0])
+    out, reason = _sched(alt)
+    assert reason is None and out is alt
+    assert (SCHEDULE.numel() - 1) + (out.numel() - 1) == 13
 
 
-def test_rewind_re_enters_higher_and_replays_those_steps():
-    plan, reason = _plan(0.482, restart=0.812)
-    assert reason is None
-    first, second, cut_at, entry_at, resume, ctx = plan
-    assert [round(v, 3) for v in first.tolist()] == [1.0, 0.955, 0.893, 0.812, 0.715, 0.603, 0.482]
-    assert [round(v, 3) for v in second.tolist()] == [0.812, 0.715, 0.603, 0.482, 0.241, 0.121, 0.0]
-    assert resume is False          # the caller must rebuild the state at 0.812 first
-    assert ctx["offset"] == 3
+def test_an_ascending_schedule_is_refused():
+    """Both malformed cases are silent in the OUTPUT rather than loud at runtime, so they
+    have to be caught before sampling. An ascending pair walks the trajectory backwards."""
+    out, reason = _sched(torch.tensor([0.812, 0.4, 0.55, 0.0]))
+    assert out is None and "must descend" in reason
 
 
-def test_restart_below_the_cut_is_refused_with_the_fix_named():
-    plan, reason = _plan(0.812, restart=0.482)
-    assert plan is None
-    assert "never a cleaner one" in reason and "second_pass_restart_sigma" in reason
+def test_a_schedule_that_stops_short_of_zero_is_refused():
+    """Stopping above 0 leaves the clip partially denoised — the noise-artefact symptom."""
+    out, reason = _sched(torch.tensor([0.812, 0.5, 0.25]))
+    assert out is None and "not 0" in reason
 
 
-def test_a_cut_outside_the_schedule_is_refused_not_ignored():
-    for cut in (1.0, 0.9999, 0.0005):
-        plan, reason = _plan(cut)
-        assert plan is None and reason, cut
+def test_equal_neighbouring_sigmas_are_not_treated_as_ascending():
+    out, reason = _sched(torch.tensor([0.812, 0.6, 0.6, 0.0]))
+    assert reason is None and out is not None
 
 
-# ── a separate schedule for pass 2 ──────────────────────────────────────────
-
-def test_a_connected_schedule_replaces_pass_two_wholesale():
-    """The point of the feature: the second half can have its own step count and spacing.
-    Its first sigma is the entry point, and the sampler must be told THAT is its schedule —
-    otherwise it measures its quality phase and correction window against the main one."""
-    alt = torch.tensor([0.715, 0.5, 0.3, 0.15, 0.0])
-    plan, reason = _plan(0.603, restart=0.0, alt=alt)
-    assert reason is None
-    first, second, cut_at, entry_at, resume, ctx = plan
-    assert second is alt
-    assert abs(entry_at - 0.715) < 1e-5      # the alt schedule's own first sigma
-    assert resume is False                   # 0.603 -> 0.715 needs the state rebuilt
-    assert ctx["sigmas"] is alt and ctx["offset"] == 0
-    # ...and pass 1 is unaffected by it.
-    assert [round(v, 3) for v in first.tolist()] == [1.0, 0.955, 0.893, 0.812, 0.715, 0.603]
+def test_a_missing_or_degenerate_schedule_is_refused_with_a_reason():
+    """second_pass with nothing to run must say so, not silently sample once."""
+    for alt in (None, torch.tensor([]), torch.tensor([0.5]), "0.8, 0.0"):
+        out, reason = _sched(alt)
+        assert out is None and reason
 
 
-def test_a_connected_schedule_starting_at_the_cut_is_an_exact_handover():
-    alt = torch.tensor([0.603, 0.4, 0.2, 0.0])
-    plan, reason = _plan(0.603, alt=alt)
-    assert reason is None and plan[4] is True     # resume -> nothing added
-
-
-def test_a_connected_schedule_starting_below_the_cut_is_refused():
-    alt = torch.tensor([0.3, 0.15, 0.0])
-    plan, reason = _plan(0.603, alt=alt)
-    assert plan is None
-    assert "second_pass_sigmas starts at" in reason
-
-
-def test_a_degenerate_connected_schedule_falls_back_to_the_restart_sigma():
-    """A single-sigma (or empty) SIGMAS input is not a schedule — it must not be treated as
-    one, and the restart sigma still governs."""
-    for alt in (None, torch.tensor([0.5]), torch.tensor([])):
-        plan, reason = _plan(0.603, restart=0.812, alt=alt)
-        assert reason is None
-        assert plan[1].tolist()[0] == SCHEDULE[3].item()   # a slice of the MAIN schedule
+def test_a_schedule_starting_at_zero_is_refused():
+    out, reason = _sched(torch.tensor([0.0, 0.0]))
+    assert out is None and "nothing for it to denoise" in reason
 
 
 # ── the pin survives the split ──────────────────────────────────────────────

From 1dd27101aa5d35c4803c8990f44afc68f4890aca Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Fri, 31 Jul 2026 14:05:49 +0300
Subject: [PATCH 24/29] second_pass: say plainly that the sampler does the
 re-entry, and what the first sigma costs
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

User asked why there is an "img2img re-noise" at all — "you just pass the original latent
from 1st pass as latent_image into 2nd pass and that's it, sampler does everything itself."
That is exactly what the code does. Pass 1's latent goes in as latent_image with
continue_from_state off, so _sample_chunk calls prepare_noise and comfy's own noise_scaling
handles the entry; _renoise_to_sigma is never called on this path (it is anchor_shift's
only, for its genuinely mid-trajectory case). Between the passes there are just two things,
one of them usually nothing: the optional op (skipped at "none") and re-attaching the i2v
noise_mask so pass 2 does not re-denoise the anchor.

So no code change — but the docs said "re-noising the finished clip", which named comfy's
internal step as if it were machinery I had added, and that is what prompted the question.
Reworded to say the sampler does it.

The same wording hid the answer to their actual symptom (softness). CONST scaling is
x = s*noise + (1-s)*picture, so the schedule's first sigma is a literal strength: at 0.812
pass 2 starts from 81% fresh noise over 19% of the pass-1 picture with 4 steps to resolve
it, which is a very strong img2img and is expected to read soft. Both tooltips now give the
0.8 / 0.4 / 0.2 scale so the dial is legible instead of implicit.

Suites at baseline: 22 pre-existing failures, 467 passing.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 movie_editor/frontend/sampler_panel.js | 11 ++++++++---
 samplers.py                            |  2 +-
 2 files changed, 9 insertions(+), 4 deletions(-)

diff --git a/movie_editor/frontend/sampler_panel.js b/movie_editor/frontend/sampler_panel.js
index 3a9f364f..72a3a252 100644
--- a/movie_editor/frontend/sampler_panel.js
+++ b/movie_editor/frontend/sampler_panel.js
@@ -352,9 +352,14 @@ hint(container, "Fill this in and each scene is sampled in two passes; leave it
                     + "runs the main Sigmas schedule above in full, then pass 2 runs THIS "
                     + "one in full, so the total is simply the two added up (a 9-step main "
                     + "plus a 4-step second pass is 13). Pass 2 starts from the finished "
-                    + "clip and re-noises it up to your first sigma, so that value is the "
-                    + "strength dial — near 1.0 reworks the shot, low values only polish "
-                    + "it — and the rest sets how many steps it gets. To make pass 1 "
+                    + "clip: it is handed in as the latent and the sampler noises it to your "
+                    + "first sigma itself, exactly as any img2img does — no extra step in "
+                    + "between. That first sigma is therefore the strength dial, and it is "
+                    + "literal: at 0.8 pass 2 starts from 80% fresh noise over 20% of the "
+                    + "pass-1 picture and will rework the shot (and look soft if it has few "
+                    + "steps to resolve it); at 0.4 it is 40/60 and polishes; at 0.2 it is "
+                    + "nearly pure detail work. The rest of the list sets how many steps it "
+                    + "gets. To make pass 1 "
                     + "shorter, shorten the schedule above; nothing here cuts it short.");
   }
 
diff --git a/samplers.py b/samplers.py
index 30f62699..d1fc77c4 100644
--- a/samplers.py
+++ b/samplers.py
@@ -2576,7 +2576,7 @@ class FunPackLTXAVSceneChainSampler:
                 # builder's positional reference-workflow mapping (extract_widgets) stays aligned.
                 "second_pass": ("BOOLEAN", {
                     "default": False,
-                    "tooltip": "Sample each scene in TWO passes. Pass 1 runs the main sigmas schedule in full, exactly as written; pass 2 then runs the second_pass_sigmas schedule in full, exactly as written, starting from pass 1's finished clip. Nothing is cut short and nothing is derived — to make pass 1 shorter, shorten the main schedule. Total steps are simply the two schedules added up (a 9-step main plus a 4-step second pass is 13). Pass 2 re-enters the way any img2img refine does, by re-noising the finished clip up to its first sigma, so that first sigma controls how much it is allowed to change: nearer 1.0 reworks the shot, low values only polish it. Requires a second_pass_sigmas schedule; without one the pass is skipped with a note. Independent of anchor_shift, which runs its own two passes for a different reason — when it acts on a scene, this is skipped.",
+                    "tooltip": "Sample each scene in TWO passes. Pass 1 runs the main sigmas schedule in full, exactly as written; pass 2 then runs the second_pass_sigmas schedule in full, exactly as written, starting from pass 1's finished clip. Nothing is cut short and nothing is derived — to make pass 1 shorter, shorten the main schedule. Total steps are simply the two schedules added up (a 9-step main plus a 4-step second pass is 13). Pass 1's finished latent is simply handed to pass 2 as its latent_image and the sampler noises it to the schedule's first sigma itself, exactly as any img2img does — there is no extra step in between. That first sigma is therefore the strength dial, and it is literal (CONST scaling: x = s*noise + (1-s)*picture): at 0.8 pass 2 starts from 80% fresh noise over 20% of the pass-1 picture and reworks the shot, looking soft if the schedule has few steps to resolve it; at 0.4 it is 40/60 and polishes; at 0.2 it is nearly pure detail work. Requires a second_pass_sigmas schedule; without one the pass is skipped with a note. Independent of anchor_shift, which runs its own two passes for a different reason — when it acts on a scene, this is skipped.",
                 }),
                 "second_pass_op": (["none", "sharpen", "upscale_2x"], {
                     "default": "none",

From 39533dfde4f990d1715a5ec70abe9cabfad98168 Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Fri, 31 Jul 2026 17:36:13 +0300
Subject: [PATCH 25/29] anchor_shift: remove the shift, keep only the head cut
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

The two-pass shift regrew the frames it dropped, and the invented ending
consistently came out with worse or missing movement — not worth paying
steps for. What is left is the part that works: generate the scene exactly
as normal, anchor pinned at full strength the whole way, then cut the
opening off the finished clip. Nothing is regrown, so the scene comes out
that much shorter and the audio is cropped to match.

Six knobs collapse into one INT, cut_opening_frames (0 = off), in the
Editor under Chain Sampler ▸ Timing & Seed rather than Experimental.
Gone with the shift: the mid-schedule split, the rewind re-noise
(_renoise_to_sigma), the tail refill modes, the fresh-audio reset, and the
schedule_context/continue_from_state plumbing that existed only so a split
scene would not re-time the sampler inside each half.

second_pass is untouched — it never used any of that machinery.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 movie_editor/backend/builder.py          |  27 +-
 movie_editor/frontend/engine_settings.js |  18 +-
 movie_editor/tests/test_builder.py       |  25 +
 samplers.py                              | 679 ++++++-----------------
 tests/test_anchor_shift.py               | 478 ----------------
 tests/test_cut_opening.py                | 160 ++++++
 tests/test_second_pass.py                |  18 +-
 7 files changed, 397 insertions(+), 1008 deletions(-)
 delete mode 100644 tests/test_anchor_shift.py
 create mode 100644 tests/test_cut_opening.py

diff --git a/movie_editor/backend/builder.py b/movie_editor/backend/builder.py
index e5f8b9bb..7cfc3174 100644
--- a/movie_editor/backend/builder.py
+++ b/movie_editor/backend/builder.py
@@ -901,24 +901,41 @@ def _apply_bypass(graph, slots, slot_node_id, slot_def, report):
         nd = slot_def.get(s["id"]) or {}
         outs = node_outputs(nd)
         cis = connection_inputs(nd)
+        # Only the outputs something in the graph actually CONSUMES need a passthrough. A
+        # node can emit an output nothing here reads — LTXICLoRALoaderModelOnly returns a
+        # FLOAT (latent_downscale_factor) alongside its MODEL, and the editor's graph wires
+        # only the MODEL — and demanding a matching input for an output that feeds nothing
+        # would refuse a bypass that is completely unambiguous for every link that exists.
+        consumed = set()
+        for nid, ndata in graph.items():
+            if nid == sid:
+                continue
+            for val in (ndata.get("inputs") or {}).values():
+                if isinstance(val, list) and len(val) == 2 and val[0] == sid:
+                    consumed.add(val[1])
         passthrough = {}
-        ok = True
+        blocked = None
         for i, o in enumerate(outs):
+            if i not in consumed:
+                continue
             # A union-typed input ("IMAGE,MASK") can carry any of its members through.
             names = [ci["name"] for ci in cis if type_accepts(ci["type"], o["type"])]
             if len(names) != 1:
-                ok = False
+                blocked = (o, names)
                 break
             passthrough[i] = graph[sid]["inputs"].get(names[0])
-        if not ok:
+        if blocked is not None:
             # Silently leaving the node active would mean a user who explicitly bypassed it
             # (e.g. to skip an i2v preprocessing node) gets generation output as if they
             # hadn't — with no visible sign why. Block instead: bypass either does what was
             # asked or the run stops with a clear reason, never a silent no-op.
+            _o, _names = blocked
             msg = (
                 f"{s.get('node_class')}: bypass needs exactly one input matching each output's "
-                f"type to pass through — this node doesn't have one, so it can't be safely "
-                f"bypassed. Remove it or rewire it with a single matching input per output type.")
+                f"type to pass through, and its '{_o['name']}' output ({_o['type']}) has "
+                f"{'no matching input' if not _names else 'more than one'} — so it can't be "
+                f"safely bypassed. Remove it, give it a single matching input for that type, "
+                f"or leave that output unconnected.")
             report["unsatisfied"].append(msg)
             report["blocking"].append(msg)
             continue
diff --git a/movie_editor/frontend/engine_settings.js b/movie_editor/frontend/engine_settings.js
index ab31de20..b12e0005 100644
--- a/movie_editor/frontend/engine_settings.js
+++ b/movie_editor/frontend/engine_settings.js
@@ -226,18 +226,8 @@
     { name: "detail_denoise", label: "Detail re-noise strength", kind: "float", default: 0.85, min: 0.3, max: 0.99, step: 0.05,
       deps: [{ name: "segmented_detailing" }, { name: "detail_mode", value: "repair" }],
       hint: "How much noise the crop gets re-noised to before its 3-step refine (0.85 is the official LTX 2.3 recipe's own value). Higher = more freedom to genuinely reconstruct the region (fix bad anatomy), risking drift from the surrounding frame; lower = closer to a plain upscale — looks 'detailed' as interpolation but doesn't actually repair it. If the result looks upscaled but not corrected, raise this. Only used in 'repair' mode." },
-    { name: "anchor_shift", label: "Anchor shift (fake t2v)", kind: "bool", default: false,
-      hint: "EXPERIMENTAL: keep the real, untouched i2v anchor — then delete it from the clip. The anchor is a pinned frame at position 0, so it holds character detail, style and composition better than anything that weakens it on the way in (ALG blurs it and loses detail; Best-FaceID tokens approximate it and lose some too), but it is also literally the first frame you see. This runs pass 1 down to the sigma below with the anchor pinned as normal, drops the first frames and slides everything left (clip length unchanged — no extra frames generated), then finishes the schedule with the pin gone. The result is an i2v generation that reads as t2v. Pass 2 always re-enters at the exact latent state for its first sigma, which is what keeps the shifted latent on-manifold. Skipped on continuation scenes and on scenes carrying guide frames or JoyAI audio memory, with the reason in the scene report. Validated live in continue mode." },
-    { name: "anchor_shift_sigma", label: "Shift at sigma", kind: "float", default: 0.909, min: 0.0, max: 0.999, step: 0.001, dependsOn: "anchor_shift",
-      hint: "The knob this feature exists to let you tune, in both modes. SET IT TO 0 for no second pass at all: the whole schedule runs exactly as if anchor shift were off (anchor pinned at full strength the whole way), and the head is then cut off the finished clip — zero extra sampling, and with 'Regrown tail starts from' = crop it is simply 'generate the video, then delete the opening'. At 0 the tail must be crop or wrap (nothing would denoise a refilled tail) and 'Regenerate audio in pass 2' is ignored. Above 0, pass 1 runs until the schedule first reaches this sigma, then the shift happens. 0.909 is where structure actually starts forming on the distilled schedule (1.0 and 0.975 are near-pure noise and carry almost no signal), so it's the earliest cut where the anchor has plausibly transferred anything — a starting guess, not a measured value. Higher = released sooner and cheaper, but the reference may never have landed. Lower = held longer, but more of pass 1's picture is thrown away by the slide and fewer steps remain to repair it." },
-    { name: "anchor_shift_frames", label: "Frames to drop", kind: "int", default: 8, min: 8, max: 512, step: 8, dependsOn: "anchor_shift",
-      hint: "How much of the front to drop at the shift, in real frames. 8 (one latent frame) removes just the anchor itself, which is usually not enough — the anchor is followed by a settling-in stretch where the shot is still leaving the reference still and little is happening, and on a prompt asking for immediate action that dead time is exactly what you want gone. 48 was the value that worked on a 768×768×305@30 chain with a quick-cut prompt; treat that as a starting point for this pipeline rather than a universal default. Raise it if the opening still looks like it departed from a photo. The clip doesn't get shorter — whatever is dropped here is regrown at the end by pass 2." },
-    { name: "anchor_shift_restart_sigma", label: "Pass 2 restart sigma", kind: "float", default: 0.0, min: 0.0, max: 0.999, step: 0.001, dependsOn: "anchor_shift",
-      hint: "Where pass 2 re-enters the schedule after the shift. Pass 1 always stops at the shift sigma either way — this only decides where the second half picks up. 0 (default) = CONTINUE: resume from exactly the state pass 1 handed over, nothing added, cost stays one full schedule. Above the shift sigma = REWIND: the shifted latent is re-noised from the cut back up to this sigma, then denoised down again — much more freedom to rebuild the regrown tail and blend the joint, at the cost of repeating those steps and partly overwriting what pass 1 established. The re-noise is exact for a half-denoised latent (it rebuilds the state at the higher sigma from what pass 1 produced plus a matched top-up of fresh noise), not the naive img2img re-noise that caused the under-denoising in the first live run. BELOW the shift sigma is refused: noise can be added back, never removed. Try a step or two above the cut if continue leaves a visible seam or a thin ending." },
-    { name: "anchor_shift_tail", label: "Regrown tail starts from", kind: "combo", choices: ["extend_last", "wrap", "empty", "crop"], default: "extend_last", dependsOn: "anchor_shift",
-      hint: "What fills the freed end after the slide. 'extend_last' (default) repeats the final frame so pass 2 grows the new ending out of something continuous with it. 'wrap' puts the dropped head back at the end — continuous, but it re-shows the reference image at the END of the clip. 'empty' zeroes it and lets pass 2 generate freely — most freedom, most likely to drift from the rest of the shot. 'crop' regrows NOTHING: the scene simply ends 'Frames to drop' earlier and comes out SHORTER than the length you set. It is the only mode with no invented ending and no joint to blend — every surviving frame was generated as part of one continuous shot — so it removes the thin-ending failure the other three can produce, and makes a rewind restart much less necessary. Audio is cropped to match. Use it when the shot matters more than the exact duration; avoid it when a scene has to hit a specific length. The scene report states the new length." },
-    { name: "anchor_shift_fresh_audio", label: "Regenerate audio in pass 2", kind: "bool", default: true, dependsOn: "anchor_shift",
-      hint: "Reset the audio to an empty latent before pass 2 so it's written fresh against the shifted picture. On by default because pass 1's audio was formed against frames that no longer sit at those positions. Turn off only to A/B whether the carried audio actually sounds better." },
+    { name: "cut_opening_frames", label: "Cut the opening (frames)", kind: "int", default: 0, min: 0, max: 512, step: 8,
+      hint: "Let the i2v anchor do its work, then cut it out of the clip. The anchor is a pinned frame at position 0, so it carries character detail, style and composition better than anything that weakens it on the way in (ALG blurs it and loses detail; Best-FaceID tokens approximate it and lose some too) — but it is also literally the first frame you see. The scene is generated exactly as normal, with the anchor pinned at full strength the whole way and no extra sampling, and this many frames are then dropped off the FRONT of the finished clip: an i2v generation that reads as t2v. 0 = off. 8 (one latent frame) removes just the anchor itself, which is usually not enough — the anchor is followed by a settling-in stretch where the shot is still leaving the reference still and little is happening, and on a prompt asking for immediate action that dead time is exactly what you want gone. 48 was the value that worked on a 768×768×305@30 chain with a quick-cut prompt; treat it as a starting point for this pipeline, not a universal default. NOTHING IS REGROWN: the scene comes out that much SHORTER than the length you set, and the audio is cropped to match — every surviving frame was generated as part of one continuous shot, with no invented ending. Needs an anchor image; skipped (with the reason in the scene report) on continuation scenes and on scenes carrying guide frames or JoyAI audio memory." },
     { name: "second_pass_op", label: "Between-pass operation", kind: "combo", choices: ["none", "sharpen", "upscale_2x"], default: "none",
       hint: "OPTIONAL operation applied to the latent between the two passes — 'none' by default, nothing runs unless you pick one. 'sharpen': one forward of Lightricks' trained 2x latent upsampler, resampled straight back to the original size. No video-model calls, so it costs a fraction of a step; pass 2 then re-denoises the sharpened latent, which is what makes it stick. It adds detail consistent with what's already there and CANNOT fix wrong structure (an extra finger stays an extra finger, just sharper). 'upscale_2x': the same upsampler, but kept at 2x — pass 2 runs at four times the pixels and the scene decodes at double resolution. That's 3-5x the cost of the second half, and it drops the i2v pin (the anchor and its mask are the old size, and rescaling them would be inventing an anchor), so the scene can drift from the reference image; the scene report says when that happens. Both use the same upsampler file as segmented detailing. Video only — audio is never reshaped." },
     { name: "context_windows", label: "Context windows (long scenes)", kind: "bool", default: false,
@@ -376,10 +366,10 @@
   // ── views (inner-sidebar categories) ───────────────────────────────────────
   const CHAIN_VIEW_KNOBS = {
     chain_continuity: ["carry_i2v_guides"],
-    chain_timing: ["frame_overlap", "transition_duration", "use_same_seed"],
+    chain_timing: ["frame_overlap", "transition_duration", "use_same_seed", "cut_opening_frames"],
     chain_guidance: ["cfg", "embed_guidance", "embed_guidance_source", "embed_guidance_strength", "score_slider", "score_slider_strength", "taste_nearest_prompt", "output_guidance", "output_guidance_strength", "dynashift", "dynashift_strength", "dynashift_threshold"],
     chain_decode: ["decode_noise_scale", "decode_timestep", "decode_tile_size"],
-    chain_experimental: ["anchor_shift", "anchor_shift_sigma", "anchor_shift_frames", "anchor_shift_restart_sigma", "anchor_shift_tail", "anchor_shift_fresh_audio", "context_windows", "context_window_length", "context_window_overlap", "context_window_schedule", "context_window_fuse", "context_window_freenoise", "context_window_retain_first", "plateau_cache", "plateau_cache_threshold", "segmented_detailing", "detail_targets", "detail_strength", "detail_threshold", "detail_max_area", "detail_mode", "detail_denoise", "mid_scene_guide", "mid_scene_guide_strength", "joyai_memory", "joyai_memory_size", "joyai_fix_frames", "joyai_frame_select", "joyai_memory_strength", "joyai_audio_memory", "v2a_grad_scale", "alg_blur_guides", "alg_guide_blur_strength", "alg_guide_blur_sigma_threshold", "bounded_attention_enabled", "identity_transfer_enabled", "source_id", "phase_scale", "id_strength", "arcface_mode", "debug_log"],
+    chain_experimental: ["context_windows", "context_window_length", "context_window_overlap", "context_window_schedule", "context_window_fuse", "context_window_freenoise", "context_window_retain_first", "plateau_cache", "plateau_cache_threshold", "segmented_detailing", "detail_targets", "detail_strength", "detail_threshold", "detail_max_area", "detail_mode", "detail_denoise", "mid_scene_guide", "mid_scene_guide_strength", "joyai_memory", "joyai_memory_size", "joyai_fix_frames", "joyai_frame_select", "joyai_memory_strength", "joyai_audio_memory", "v2a_grad_scale", "alg_blur_guides", "alg_guide_blur_strength", "alg_guide_blur_sigma_threshold", "bounded_attention_enabled", "identity_transfer_enabled", "source_id", "phase_scale", "id_strength", "arcface_mode", "debug_log"],
   };
 
   function countChainView(p, id) {
diff --git a/movie_editor/tests/test_builder.py b/movie_editor/tests/test_builder.py
index 9c6154b6..6bd28bb5 100644
--- a/movie_editor/tests/test_builder.py
+++ b/movie_editor/tests/test_builder.py
@@ -64,6 +64,13 @@ OI = {
                                           "strength_model": ["FLOAT", {"default": 1.0}],
                                           "strength_clip": ["FLOAT", {"default": 1.0}]}},
                   "output": ["MODEL", "CLIP"], "output_name": ["MODEL", "CLIP"]},
+    # Real shape of LTXICLoRALoaderModelOnly: a MODEL passthrough plus a FLOAT the graph
+    # never reads. strength_model is a widget, so no connection input matches that FLOAT.
+    "LTXICLoRALoaderModelOnly": {
+        "input": {"required": {"model": ["MODEL"],
+                               "lora_name": [["x.safetensors"]],
+                               "strength_model": ["FLOAT", {"default": 1.0}]}},
+        "output": ["MODEL", "FLOAT"], "output_name": ["model", "latent_downscale_factor"]},
 }
 
 PARAMS = {"prompt": "scene one", "seed": 42, "num_frames_per_scene": 121, "frame_rate": 24}
@@ -374,6 +381,24 @@ def test_non_bypassed_lora_stays_in_graph():
     assert graph["studio"]["inputs"]["clip"] == ["slot_lora", 1]
 
 
+def test_bypass_ignores_outputs_nothing_is_wired_to():
+    """LTXICLoRALoaderModelOnly emits a FLOAT (latent_downscale_factor) next to its MODEL,
+    and nothing in the editor's graph reads it. Demanding a matching input for an output
+    that feeds nothing refused a bypass that is unambiguous for every link that exists —
+    only CONSUMED outputs need a passthrough."""
+    models = {"full_control": True, "slots": [
+        {"id": "u", "node_class": "UnetLoader", "inputs": {"unet_name": "m.safetensors"}, "wires": {}},
+        {"id": "ic", "node_class": "LTXICLoRALoaderModelOnly", "bypassed": True,
+         "inputs": {"lora_name": "x.safetensors", "strength_model": 0.8, "model": ["slot_u", 0]},
+         "wires": {"MODEL": "port:FunPackStudio.model"}},
+    ]}
+    graph, report = builder.build(OI, models, PARAMS)
+    assert "slot_ic" not in graph
+    assert graph["studio"]["inputs"]["model"] == ["slot_u", 0]
+    assert not any("bypass" in b for b in report["blocking"])
+    assert any("LTXICLoRALoaderModelOnly bypassed" in w for w in report["wired"])
+
+
 def test_bypass_on_node_with_no_matching_input_blocks_generation():
     # VaeLoader has no connection_input at all, so there's nothing to pass an output through.
     # A bypass a user explicitly asked for must never be silently ignored — generation blocks
diff --git a/samplers.py b/samplers.py
index d1fc77c4..df9a9b77 100644
--- a/samplers.py
+++ b/samplers.py
@@ -340,24 +340,6 @@ def _velocity_bias_key(refinement_key, target, x):
     return (key, f"{float(target):.2f}", shape)
 
 
-def _schedule_view(sigmas, schedule_context):
-    """The real schedule behind a possibly-partial `sigmas`, plus this run's step offset.
-
-    anchor_shift samples a scene as two sample_custom calls over slices of one schedule.
-    A sampler that measures its phases from `len(sigmas)` therefore re-derives them inside
-    each slice — the final-correction window reopens at the end of pass 1, the AB2 ramp
-    restarts, the velocity-bias ratio is taken against the slice's own first sigma. The
-    caller passes the whole schedule and where this slice starts in it; absent (any normal
-    single-call run) `sigmas` IS the whole schedule and the offset is 0.
-    """
-    if isinstance(schedule_context, dict):
-        full = schedule_context.get("sigmas")
-        if isinstance(full, torch.Tensor) and int(full.numel()) >= 2:
-            offset = max(0, int(schedule_context.get("offset", 0) or 0))
-            return full, offset
-    return sigmas, 0
-
-
 def _sigma_ratio(sigmas, sigma):
     try:
         start = float(sigmas[0].item())
@@ -1127,8 +1109,7 @@ def _sample_const_rf_full(model, x, sigmas, extra_args, callback, disable,
                           velocity_refinement_key,
                           rescue_mode, rescue_threshold, rescue_strength, rescue_prompt_sig,
                           quality_sharpness=0.0, velocity_bias_source="mean",
-                          normalize_strength=0.0, normalize_start_sigma=0.9,
-                          schedule_context=None):
+                          normalize_strength=0.0, normalize_start_sigma=0.9):
     """Full-feature rectified-flow sampler for CONST models (LTXAV).
 
     Rectified-flow-correct port of the hybrid sampler so its features actually run on
@@ -1159,14 +1140,11 @@ def _sample_const_rf_full(model, x, sigmas, extra_args, callback, disable,
     correction_blend = max(0.0, min(1.0, float(correction_blend)))
     eta_final = max(0.0, min(float(eta), float(eta_final)))
 
-    # See _schedule_view: `sigmas` may be one half of an anchor_shift split, and the quality
-    # phase / motion-pulse anchors below are positions in the SCHEDULE, not in this call.
-    sched, step_offset = _schedule_view(sigmas, schedule_context)
-    sched_steps = max(1, int(len(sched)) - 1)
+    sched_steps = max(1, int(len(sigmas)) - 1)
 
     if not motion_pulse_steps:
         _, _, motion_pulse_steps, motion_pulse_noise = _prepare_dynamic_sigmas(
-            sched, high_quality_pct, motion_pulse_mode, motion_pulse_start_pct,
+            sigmas, high_quality_pct, motion_pulse_mode, motion_pulse_start_pct,
             motion_pulse_count, motion_pulse_spacing_pct, motion_pulse_strength)
     motion_pulse_noise = max(0.0, float(motion_pulse_noise or 0.0))
     motion_step_noise = {
@@ -1175,7 +1153,7 @@ def _sample_const_rf_full(model, x, sigmas, extra_args, callback, disable,
     }
 
     late_start = _get_late_start_index(sched_steps, high_quality_pct)
-    quality_sigma_start = float(sched[late_start].item()) if late_start < sched.shape[0] else None
+    quality_sigma_start = float(sigmas[late_start].item()) if late_start < sigmas.shape[0] else None
     num_quality_steps = sched_steps - late_start
 
     s_in = x.new_ones([x.shape[0]])
@@ -1201,12 +1179,11 @@ def _sample_const_rf_full(model, x, sigmas, extra_args, callback, disable,
     for i in comfy.utils.model_trange(total_steps, disable=disable):
         sigma = sigmas[i]
         sigma_next = sigmas[i + 1]
-        step_abs = i + step_offset  # position in the REAL schedule, not in this call's slice
         in_quality = quality_sigma_start is not None and float(sigma.item()) <= quality_sigma_start
-        velocity_target = _velocity_bias_target(sched, sigma)
+        velocity_target = _velocity_bias_target(sigmas, sigma)
 
         if not in_quality:
-            pulse = motion_step_noise.get(int(step_abs), 0.0)
+            pulse = motion_step_noise.get(int(i), 0.0)
             if pulse > 0.0:
                 x = _video_only(_apply_motion_pulse(x, sigma, sigma_next, pulse, noise_sampler), x, video_mask)
                 prev_denoised = None
@@ -1215,7 +1192,7 @@ def _sample_const_rf_full(model, x, sigmas, extra_args, callback, disable,
         if _velocity_bias_enabled(velocity_bias_mode, "apply"):
             x_pre = x
             x = _apply_velocity_bias(x, velocity_refinement_key, velocity_target, velocity_bias_strength,
-                                     sigma_ratio=_sigma_ratio(sched, sigma),
+                                     sigma_ratio=_sigma_ratio(sigmas, sigma),
                                      prompt_sig=rescue_prompt_sig, source=velocity_bias_source)
             x = _video_only(x, x_pre, video_mask)
 
@@ -1269,9 +1246,7 @@ def _sample_const_rf_full(model, x, sigmas, extra_args, callback, disable,
             if num_quality_steps <= 1:
                 effective_blend = correction_blend
             else:
-                # Which quality step this is IN THE SCHEDULE — a per-call counter would
-                # restart the euler->Heun ramp inside each half of an anchor_shift split.
-                q_idx = max(0, step_abs - late_start)
+                q_idx = max(0, i - late_start)
                 effective_blend = 0.0 if q_idx < (num_quality_steps // 2) else correction_blend
             dt = sigma_next - sigma
             d1 = k_diffusion_sampling.to_d(x, sigma, denoised_eff)
@@ -1291,7 +1266,7 @@ def _sample_const_rf_full(model, x, sigmas, extra_args, callback, disable,
         else:
             # Early phase: ancestral RF euler (matches sample_euler_ancestral_RF), with
             # eta decay toward the quality boundary, using the AB2 denoised estimate.
-            effective_eta = _effective_eta(eta, eta_final, sched, sigma)
+            effective_eta = _effective_eta(eta, eta_final, sigmas, sigma)
             # Deterministic euler-RF step to sigma_next (this is what audio rides — no
             # ancestral re-noising). For single-stream video (mask None) it is only used
             # as the eta==0 fallback; the full ancestral result is kept for video.
@@ -1336,8 +1311,7 @@ def sample_funpack_hybrid_euler_2s(model, x, sigmas, extra_args=None, callback=N
                                    rescue_prompt_sig=None,
                                    eta_final=1.0,
                                    normalize_strength=0.0,
-                                   normalize_start_sigma=0.9,
-                                   schedule_context=None):
+                                   normalize_start_sigma=0.9):
     """
     Hybrid sampler:
     - Early schedule: Euler ancestral with order-2 denoised extrapolation for
@@ -1414,7 +1388,6 @@ def sample_funpack_hybrid_euler_2s(model, x, sigmas, extra_args=None, callback=N
             velocity_bias_source=velocity_bias_source,
             normalize_strength=normalize_strength,
             normalize_start_sigma=normalize_start_sigma,
-            schedule_context=schedule_context,
         )
 
     extra_args = {} if extra_args is None else extra_args
@@ -1786,7 +1759,7 @@ def sample_funpack_distilled_flow(model, x, sigmas, extra_args=None, callback=No
                                    alg_guide_tail_frames=0,
                                    alg_guide_blur_strength=2.0, alg_guide_blur_sigma_threshold=0.975,
                                    mg_enabled=False, mg_strength=0.5, mg_decay=0.5, mg_sigma_threshold=0.975,
-                                   quality_sharpness=0.0, schedule_context=None):
+                                   quality_sharpness=0.0):
     """
     ODE sampler for distilled few-step video models (e.g. LTX2.3 distilled LoRA).
 
@@ -1836,13 +1809,7 @@ def sample_funpack_distilled_flow(model, x, sigmas, extra_args=None, callback=No
     if total_steps <= 0:
         return x
 
-    # `sigmas` is not always the schedule the user configured: anchor_shift runs a scene as
-    # two sample_custom calls, so this can be a FRAGMENT. Everything phase-relative below —
-    # where the final-correction window opens, how far along the AB2 ramp is, what the
-    # velocity-bias sigma ratio is measured against — has to be read off the REAL schedule,
-    # or enabling anchor_shift silently re-times all of it inside each half.
-    sched, step_offset = _schedule_view(sigmas, schedule_context)
-    sched_steps = max(1, int(len(sched)) - 1)
+    sched_steps = max(1, int(len(sigmas)) - 1)
 
     order = max(1, min(2, int(order)))
     s_noise = max(0.0, min(0.5, float(s_noise)))
@@ -1954,9 +1921,7 @@ def sample_funpack_distilled_flow(model, x, sigmas, extra_args=None, callback=No
         for i in comfy.utils.model_trange(total_steps, disable=disable):
             sigma = sigmas[i]
             sigma_next = sigmas[i + 1]
-            # Position in the REAL schedule, not in this call's slice of it.
-            step_abs = i + step_offset
-            velocity_target = _velocity_bias_target(sched, sigma)
+            velocity_target = _velocity_bias_target(sigmas, sigma)
 
             if alg_active:
                 model.latent_image = alg_latents[(
@@ -1967,7 +1932,7 @@ def sample_funpack_distilled_flow(model, x, sigmas, extra_args=None, callback=No
             if _velocity_bias_enabled(velocity_bias_mode, "apply"):
                 x_pre = x
                 x = _apply_velocity_bias(x, velocity_refinement_key, velocity_target, velocity_bias_strength,
-                                         sigma_ratio=_sigma_ratio(sched, sigma),
+                                         sigma_ratio=_sigma_ratio(sigmas, sigma),
                                          prompt_sig=rescue_prompt_sig, source=velocity_bias_source)
                 x = _video_only(x, x_pre, video_mask)
 
@@ -1985,7 +1950,7 @@ def sample_funpack_distilled_flow(model, x, sigmas, extra_args=None, callback=No
 
             # Restore high-frequency detail during the final Heun-correction steps (free,
             # video-only) — same unsharp mechanism as the Hybrid Euler 2S sampler.
-            if step_abs >= correction_start_idx:
+            if i >= correction_start_idx:
                 denoised = _video_only(_apply_quality_sharpness(denoised, prev_denoised, quality_sharpness), denoised, video_mask)
 
             # Video-only latent normalization (opt-in, anti-overbake) — stacks on top of the ODE.
@@ -2015,7 +1980,7 @@ def sample_funpack_distilled_flow(model, x, sigmas, extra_args=None, callback=No
             # is rough there and full AB2 overshoots); late/detail steps get full AB2. Reuses the
             # already-computed AB2 estimate, so no extra model evals. No-op at order=1.
             if ab2_ramp and sched_steps > 1:
-                w = step_abs / (sched_steps - 1)  # 0 at first step -> 1 at last
+                w = i / (sched_steps - 1)  # 0 at first step -> 1 at last
                 denoised_eff = denoised + (denoised_eff - denoised) * w
 
             # Audio rides plain 1st-order euler: keep the (ramped) AB2 estimate for video,
@@ -2033,7 +1998,7 @@ def sample_funpack_distilled_flow(model, x, sigmas, extra_args=None, callback=No
 
             dt = sigma_next - sigma  # negative: sigmas decrease
 
-            if step_abs >= correction_start_idx:
+            if i >= correction_start_idx:
                 # Heun predictor-corrector.
                 # Predictor: Euler step using the (multistep-corrected) denoised.
                 d1 = k_diffusion_sampling.to_d(x, sigma, denoised_eff)
@@ -2520,29 +2485,9 @@ class FunPackLTXAVSceneChainSampler:
                     "default": "repair",
                     "tooltip": "'repair' (default): upsample the crop, then re-denoise it through the video model for 3 extra steps — can genuinely fix wrong structure (bad anatomy) but costs real compute (~4x region area x 3 steps). 'sharpen': stop after the upsampler's own forward pass — no video-model calls at all, close to free — good for a region that's blurry/under-resolved but already correctly shaped; it CANNOT fix wrong structure (an extra finger stays an extra finger, just sharper), since a super-resolution net only adds detail consistent with what's already there.",
                 }),
-                "anchor_shift": ("BOOLEAN", {
-                    "default": False,
-                    "tooltip": "EXPERIMENTAL: let the i2v anchor condition the scene, then delete it from the clip. The anchor is a pinned latent frame at position 0 — it holds identity/style/composition all the way down the schedule, and it is also literally the first frame you see, so every i2v scene opens on the exact reference still. This splits the schedule: pass 1 runs down to anchor_shift_sigma with the anchor pinned as usual, then the first anchor_shift_frames frames are DROPPED and everything slides left (clip length unchanged — no extra frames are generated), then pass 2 finishes the schedule on the shifted latent with the pin gone. Pass 2 always re-enters at the exact latent state for its first sigma — resumed as-is, or re-noised up to anchor_shift_restart_sigma first — which keeps it on the rectified-flow manifold and is the reason this is two passes rather than a roll between steps. The whole experiment is WHERE to cut: above ~0.909 nothing has formed yet, so the anchor gets discarded before it has transferred anything; too low and pass 2 has no steps left to heal the seam. Off by default. Validated live in continue mode.",
-                }),
-                "anchor_shift_sigma": ("FLOAT", {
-                    "default": 0.909, "min": 0.0, "max": 0.999, "step": 0.001,
-                    "tooltip": "Sigma at which pass 1 stops and the shift happens — the knob this whole feature exists to let you tune, and it applies in BOTH modes. SET IT TO 0 for no second pass at all: the whole schedule runs exactly as if anchor_shift were off (anchor pinned at full strength throughout), and the head is then cut off the finished clip. That is the cheapest form of this by far — zero extra sampling — and it pairs with anchor_shift_tail=crop as plain 'generate the video, then delete the opening'. It needs tail=crop or wrap, since with no second pass a refilled tail would never be denoised, and anchor_shift_fresh_audio is ignored (nothing would rewrite the audio). Above 0, pass 1 runs until the schedule first reaches a sigma at or below this. 0.909 is the step where structure actually starts forming on the LTX distilled schedule (1.0 and 0.975 are the near-pure-noise plateau and carry almost no signal), so it is the earliest cut where the anchor has plausibly transferred anything — but it is a starting guess, not a measured value. Higher = anchor released sooner, cheaper, more likely the reference never really landed. Lower = anchor held longer, more of pass 1's picture is thrown away by the shift and fewer steps remain to repair it. If the schedule never reaches this sigma, the pass is skipped with a note.",
-                }),
-                "anchor_shift_frames": ("INT", {
-                    "default": 8, "min": 8, "max": 512, "step": 8,
-                    "tooltip": "How many frames to drop off the front at the shift, in real frames (converted to latent frames with the VAE's own time scale). One latent frame — 8 real frames at the standard scale — removes just the anchor itself, which is usually NOT enough: the anchor is followed by a settling-in stretch where the shot is still leaving the reference still and little is happening yet, and on a prompt that asks for immediate action that dead time is exactly what you want gone (48 was the value that worked on a 768x768x305@30 i2v chain with a quick-cut prompt — a starting point for this pipeline, not a universal default). More also removes the settling-in region right after it, where the clip is still visibly 'leaving' the reference image; raise this if the opening still looks like it is departing from a still rather than already in motion. The clip does not get shorter: whatever is dropped here is regrown at the end by pass 2.",
-                }),
-                "anchor_shift_restart_sigma": ("FLOAT", {
-                    "default": 0.0, "min": 0.0, "max": 0.999, "step": 0.001,
-                    "tooltip": "Where pass 2 re-enters the schedule after the shift. Pass 1 always stops at anchor_shift_sigma either way — this only decides where the second half picks up. 0 (default) = CONTINUE: resume from exactly the state pass 1 handed over, nothing added, total cost stays one full schedule. A value ABOVE anchor_shift_sigma = REWIND: the shifted latent is re-noised from the cut back up to this sigma, then denoised down again, giving the model far more freedom to rebuild the regrown tail and blend the joint — at the cost of repeating those steps (and of partly overwriting what pass 1 established). The re-noise is exact for a mid-trajectory latent (it rebuilds x at the higher sigma from the latent it already has plus a matched top-up of fresh noise), NOT the naive img2img re-noise, which assumes a finished image and is what caused the under-denoising in the first live run. A value BELOW anchor_shift_sigma is refused: noise can be added back, never removed. Try rewind (a step or two above the cut) if continue leaves a visible seam or a thin ending.",
-                }),
-                "anchor_shift_tail": (["extend_last", "wrap", "empty", "crop"], {
-                    "default": "extend_last",
-                    "tooltip": "What the freed tail starts from after the slide. 'extend_last' (default) repeats the final frame, so pass 2 grows the new ending out of content that is already continuous with it. 'wrap' puts the dropped head back at the end (Mobius) — cheap and continuous, but it re-shows the reference image at the END of the clip, which is usually not what you want. 'empty' zeros the region and lets pass 2's noise scaling generate it from scratch — most freedom, most likely to drift from the rest of the shot. 'crop' regrows NOTHING: the clip simply ends anchor_shift_frames earlier, so the scene comes out shorter than the length you asked for. That is the only mode with no invented ending and no joint to blend — every frame that survives was generated as part of one continuous shot — so it removes the 'thin ending' failure the other three can produce, and it makes the extra freedom of a rewind restart much less necessary. Audio is cropped by the matching amount. Pick it when the shot mattering more than the exact duration is fine (the montage just gets a shorter clip); avoid it when a scene has to hit an exact length.",
-                }),
-                "anchor_shift_fresh_audio": ("BOOLEAN", {
-                    "default": True,
-                    "tooltip": "Reset the audio stream to an empty latent before pass 2, so audio is generated fresh against the shifted picture. On by default because pass 1's audio was formed against frames that no longer sit at those positions — carrying it over means audio scored to a picture that moved. Turn off only to A/B whether the carried audio actually sounds better.",
+                "cut_opening_frames": ("INT", {
+                    "default": 0, "min": 0, "max": 512, "step": 8,
+                    "tooltip": "Let the i2v anchor do its work, then cut it out of the clip: generate the scene exactly as normal (anchor pinned at full strength the whole way, nothing weakened, no extra sampling), then drop this many frames off the FRONT of the finished clip. The anchor is a pinned latent frame at position 0 — it transfers identity, style and composition better than anything that softens it on the way in (ALG blurs it and loses character detail; Best-FaceID tokens approximate it and lose some too), but it is also literally the first frame you see, so every i2v scene opens on the exact reference still. Cutting it afterwards keeps the transfer and removes the tell: an i2v generation that reads as t2v. 0 (default) = off. The value is in REAL frames and is converted with the VAE's own time scale; one latent frame (8 real frames at the standard scale) removes just the anchor itself, which is usually NOT enough — the anchor is followed by a settling-in stretch where the shot is still leaving the reference still and little is happening yet, and on a prompt that asks for immediate action that dead time is exactly what you want gone (48 was the value that worked on a 768x768x305@30 i2v chain with a quick-cut prompt — a starting point for this pipeline, not a universal default). NOTHING IS REGROWN: the scene comes out that much SHORTER than the length you asked for, and the audio is cropped to match. That is the trade — every surviving frame was generated as part of one continuous shot, with no invented ending. Needs a pinned i2v anchor; skipped with the reason in the scene report on continuation scenes and on scenes carrying guide frames or JoyAI audio memory.",
                 }),
                 "context_windows": ("BOOLEAN", {
                     "default": False,
@@ -2576,7 +2521,7 @@ class FunPackLTXAVSceneChainSampler:
                 # builder's positional reference-workflow mapping (extract_widgets) stays aligned.
                 "second_pass": ("BOOLEAN", {
                     "default": False,
-                    "tooltip": "Sample each scene in TWO passes. Pass 1 runs the main sigmas schedule in full, exactly as written; pass 2 then runs the second_pass_sigmas schedule in full, exactly as written, starting from pass 1's finished clip. Nothing is cut short and nothing is derived — to make pass 1 shorter, shorten the main schedule. Total steps are simply the two schedules added up (a 9-step main plus a 4-step second pass is 13). Pass 1's finished latent is simply handed to pass 2 as its latent_image and the sampler noises it to the schedule's first sigma itself, exactly as any img2img does — there is no extra step in between. That first sigma is therefore the strength dial, and it is literal (CONST scaling: x = s*noise + (1-s)*picture): at 0.8 pass 2 starts from 80% fresh noise over 20% of the pass-1 picture and reworks the shot, looking soft if the schedule has few steps to resolve it; at 0.4 it is 40/60 and polishes; at 0.2 it is nearly pure detail work. Requires a second_pass_sigmas schedule; without one the pass is skipped with a note. Independent of anchor_shift, which runs its own two passes for a different reason — when it acts on a scene, this is skipped.",
+                    "tooltip": "Sample each scene in TWO passes. Pass 1 runs the main sigmas schedule in full, exactly as written; pass 2 then runs the second_pass_sigmas schedule in full, exactly as written, starting from pass 1's finished clip. Nothing is cut short and nothing is derived — to make pass 1 shorter, shorten the main schedule. Total steps are simply the two schedules added up (a 9-step main plus a 4-step second pass is 13). Pass 1's finished latent is simply handed to pass 2 as its latent_image and the sampler noises it to the schedule's first sigma itself, exactly as any img2img does — there is no extra step in between. That first sigma is therefore the strength dial, and it is literal (CONST scaling: x = s*noise + (1-s)*picture): at 0.8 pass 2 starts from 80% fresh noise over 20% of the pass-1 picture and reworks the shot, looking soft if the schedule has few steps to resolve it; at 0.4 it is 40/60 and polishes; at 0.2 it is nearly pure detail work. Requires a second_pass_sigmas schedule; without one the pass is skipped with a note.",
                 }),
                 "second_pass_op": (["none", "sharpen", "upscale_2x"], {
                     "default": "none",
@@ -3005,22 +2950,14 @@ class FunPackLTXAVSceneChainSampler:
     def _sample_chunk(self, model, sampler, sigmas, seed, cfg, positive, negative, latent,
                       pbar=None, step_offset=0, alg_guide_tail_frames=0,
                       alg_guide_blur_strength=2.0, alg_guide_blur_sigma_threshold=0.975,
-                      bounded_attention_enabled=False, continue_from_state=False,
-                      schedule_context=None):
+                      bounded_attention_enabled=False):
         if sampler is None:
             raise ValueError("sampler input is required.")
         if not isinstance(sigmas, torch.Tensor):
             raise ValueError("sigmas input must be a SIGMAS tensor.")
         latent = self._clone_latent(latent)
         samples = latent["samples"]
-        # continue_from_state: `samples` is ALREADY the noisy x at sigmas[0] (a run resumed
-        # mid-trajectory), not a clean image. comfy's CONST scaling is
-        # x = s*noise + (1-s)*latent_image, which treats latent_image as CLEAN and re-noises
-        # it — on a mid-trajectory latent that scales the picture down by (1-s) and buries it
-        # under a fresh s of noise. Passing the state as BOTH terms makes the expression
-        # collapse to an identity (s*x + (1-s)*x == x), so sampling resumes from exactly the
-        # state we hand it. Only correct when the caller really is mid-trajectory.
-        noise = samples if continue_from_state else comfy.sample.prepare_noise(samples, int(seed))
+        noise = comfy.sample.prepare_noise(samples, int(seed))
 
         def _progress_cb(step, _denoised, _x, _total_steps):
             if pbar is not None:
@@ -3037,14 +2974,6 @@ class FunPackLTXAVSceneChainSampler:
             extra_options["alg_guide_tail_frames"] = int(alg_guide_tail_frames)
             extra_options["alg_guide_blur_strength"] = float(alg_guide_blur_strength)
             extra_options["alg_guide_blur_sigma_threshold"] = float(alg_guide_blur_sigma_threshold)
-        # anchor_shift runs a scene as two calls over slices of one schedule. Tell the sampler
-        # what the real schedule is (and where this slice sits in it) so its phase boundaries
-        # stay where the user's schedule put them instead of being re-derived per slice — see
-        # _schedule_view. Always written, even as None, so it can never leak into a later chunk.
-        if isinstance(extra_options, dict) and sampler.sampler_function in (
-                sample_funpack_distilled_flow, sample_funpack_hybrid_euler_2s):
-            extra_options["schedule_context"] = schedule_context
-
         # EXPERIMENTAL Bounded Attention: model-level attention hooks (sampler-agnostic, unlike
         # the toggles above which only work on Distilled Flow), so install/remove here rather
         # than via extra_options. Cheap to attempt (no-ops fast without the right metadata).
@@ -3063,30 +2992,19 @@ class FunPackLTXAVSceneChainSampler:
         return latent
 
     # ---------------------------------------------------------------------------
-    # anchor_shift — let the i2v anchor do its work, then delete it from the clip.
+    # cut_opening_frames — let the i2v anchor do its work, then cut it out of the clip.
     #
     # The anchor is a real, PINNED latent frame at temporal position 0: it constrains
     # identity/style/composition all the way down the schedule, and it is also literally
-    # the first frame you see. This runs the schedule in two passes so it can be the
-    # former without being the latter:
+    # the first frame you see. The scene is sampled exactly as normal — the anchor is
+    # never weakened, blurred or approximated — and the opening is then cut off the
+    # FINISHED latent, so it can be the former without being the latter. An i2v
+    # generation that reads as t2v, for no extra sampling at all.
     #
-    #   pass 1: sigma[0] .. shift_sigma, anchor pinned as usual -> a partly-formed clip
-    #           that has already absorbed the reference
-    #   shift : drop the first N latent frames (the anchor and its settling-in region),
-    #           slide everything left, refill the freed tail, drop the pin
-    #   pass 2: restart_sigma .. 0 on the shifted latent
-    #
-    # Why two passes rather than mutating x between steps inside the sampler: pass 2 goes
-    # back through comfy's CONST noise scaling (x = s*noise + (1-s)*latent), which puts the
-    # shifted latent back ON the rectified-flow manifold at the restart sigma. A raw
-    # in-flight roll skips that, and [[project_sigmas]] records that this model cannot
-    # recover from off-manifold latent states (the churn dead end). Same on-manifold
-    # re-entry recipe that segmented detailing's stage-2 tail already uses in production.
-    #
-    # Everything about WHEN and HOW MUCH is a knob: shift sigma, frames dropped, restart
-    # sigma, tail refill, audio. The sigma in particular is the whole experiment - too high
-    # and the anchor is discarded before it has transferred anything (nothing has formed
-    # above ~0.909), too low and pass 2 has too few steps left to heal the seam.
+    # Nothing is regrown to replace what is cut: the scene simply comes out that much
+    # shorter. Regrowing it was tried (slide the frames left, refill the freed tail,
+    # finish the schedule on the result) and the invented ending consistently came out
+    # with worse or missing movement, which is not worth paying steps for.
     # ---------------------------------------------------------------------------
 
     def _anchor_pinned_frames(self, chunk):
@@ -3106,63 +3024,6 @@ class FunPackLTXAVSceneChainSampler:
         except Exception:
             return 0
 
-    def _anchor_shift_split_sigmas(self, sigmas, shift_sigma, restart_sigma):
-        """Cut the schedule into (pass 1, pass 2), or return None if it cannot be cut.
-
-        pass 1 ALWAYS runs from the top down to the first sigma at or below shift_sigma —
-        that cut is the whole point of the feature and nothing else may override it. pass 2
-        starts at the first sigma at or below restart_sigma (restart_sigma <= 0 means
-        "continue from where pass 1 stopped") and runs to the end. When the restart sits
-        above the cut, the shifted latent is re-noised back up to it (see
-        _renoise_to_sigma); `resume` says which of the two the caller must do.
-
-        Both passes need at least one real step, so a threshold outside the schedule's
-        range is refused rather than silently producing a zero-step pass. A restart BELOW
-        the cut is refused too — that would mean removing noise, which is not a thing.
-
-        Everything here is read off the ACTUAL schedule, never off the typed floats: walk
-        the sigmas and the last pre-shift step is the one whose NEXT sigma has crossed the
-        threshold. On a 1.000, 0.955, 0.893, 0.812, 0.715, 0.603, 0.482, 0.241, 0.121, 0.0
-        schedule with shift 0.482, steps at 1.000 and 0.955 both have a next sigma still
-        above it and proceed; the step at 0.603 has next=0.482, so it is the last one and
-        the shift happens after it. `_first_at_or_below` is that walk in closed form — the
-        first index at or below the threshold IS the sigma the last pre-shift step lands on.
-        Returned cut/restart values are the schedule's own float32 entries, so the sigma
-        pass 2 re-enters at is exactly the one _renoise_to_sigma rebuilds the state for.
-        """
-        if not isinstance(sigmas, torch.Tensor) or sigmas.numel() < 3:
-            return None
-        vals = [float(v) for v in sigmas.tolist()]
-        # SIGMAS are float32; a threshold typed as 0.725 is a float64 that sits just BELOW the
-        # float32 0.725 in the schedule, so a bare `v <= s` silently cuts one step later than
-        # the number the user entered. Match core's own tolerance convention (isclose rtol=1e-4).
-        eps = 1e-4
-
-        def _first_at_or_below(s):
-            return next((i for i, v in enumerate(vals) if v <= s + eps), None)
-
-        cut = _first_at_or_below(float(shift_sigma))
-        if cut is None or cut < 1:
-            return None  # threshold above the first sigma, or not reached at all
-        restart = float(restart_sigma)
-        if restart <= 0:
-            start = cut  # CONTINUE: pass 2 picks up exactly where pass 1 stopped.
-        else:
-            start = _first_at_or_below(restart)
-            if start is None or start > cut:
-                # start > cut means the restart sigma is LOWER than the cut: pass 2 would
-                # claim the latent is cleaner than it is. Noise can be added back, never
-                # removed, so this is a misconfiguration, not a mode.
-                return None
-        # REWIND (start < cut) hands pass 2 a re-noised copy; CONTINUE (start == cut) hands
-        # over the state untouched. Either way pass 1 stopped at the cut the user asked for.
-        first, second, resume = sigmas[:cut + 1], sigmas[start:], start == cut
-        if first.numel() < 2 or second.numel() < 2:
-            return None
-        # `start` goes back to the caller too: it is pass 2's offset into the real schedule,
-        # which the sampler needs to keep its phase boundaries where the schedule put them.
-        return first, second, vals[cut], vals[start], resume, start
-
     def _second_pass_schedule(self, alt_sigmas):
         """Validate the pass-2 schedule. Returns (sigmas, reason); one of them is None.
 
@@ -3170,9 +3031,7 @@ class FunPackLTXAVSceneChainSampler:
         full, exactly as written; pass 2 then runs THIS schedule in full, exactly as written.
         Pass 2 therefore starts from a FINISHED clip, which is the ordinary img2img re-entry
         (comfy's CONST scaling, x = s*noise + (1-s)*clean, valid precisely because the input
-        is clean). "Continue from where pass 1 stopped" belongs to anchor_shift, which stops
-        mid-trajectory on purpose; it has no meaning here. To make pass 1 shorter, shorten
-        the main schedule.
+        is clean). To make pass 1 shorter, shorten the main schedule.
 
         A hand-typed schedule is the one input that can be malformed, and both ways it can
         be are silent in the OUTPUT rather than loud at runtime, so they are caught here.
@@ -3252,10 +3111,9 @@ class FunPackLTXAVSceneChainSampler:
         """Put the i2v pin back on a latent that is about to be handed to a second pass.
 
         _sample_chunk drops noise_mask from what it returns, so without this a second pass
-        would run UNPINNED and re-denoise the anchor frame, letting the reference drift —
-        the opposite of anchor_shift, which deletes the pin on purpose. The pinned region's
-        values are copied back from the original chunk as well, because a rewind re-noise
-        adds noise everywhere, including to frames that are supposed to be frozen.
+        would run UNPINNED and re-denoise the anchor frame, letting the reference drift. The
+        pinned region's values are copied back from the original chunk as well, since pass 2
+        re-noises everything it is handed, including frames that are supposed to be frozen.
         """
         mask = chunk.get("noise_mask")
         pinned = self._anchor_pinned_frames(chunk)
@@ -3285,56 +3143,31 @@ class FunPackLTXAVSceneChainSampler:
         result["noise_mask"] = self._clone_value(mask)
         return result
 
-    def _renoise_to_sigma(self, latent, from_sigma, to_sigma, seed, reset_indices=()):
-        """Move a latent that sits mid-trajectory at `from_sigma` back up to `to_sigma`.
+    def _cut_opening_latent(self, latent, drop):
+        """Cut the first `drop` latent frames off a FINISHED scene latent.
 
-        This model's CONST scaling means a latent at sigma s is x_s = s*eps + (1-s)*x0.
-        Given x_a we cannot recover x0 or eps separately — but we do not need to. A valid
-        x_b for b >= a is a linear mix of what we already have and fresh noise:
+        The i2v anchor is a pinned frame at position 0: it transfers identity, style and
+        composition at full strength all the way down the schedule, and it is also literally
+        the first frame of the clip, so every i2v scene opens on the exact reference still.
+        Cutting it (plus the settling-in stretch behind it, where the shot is still leaving
+        that still) afterwards keeps the transfer and removes the tell.
 
-            x_b = alpha*x_a + beta*n,  alpha = (1-b)/(1-a),  beta = sqrt(b^2 - (a*alpha)^2)
+        Nothing is regrown, so the scene simply comes out `drop` latent frames SHORTER than
+        the length that was asked for. That is the whole trade: every surviving frame was
+        generated as part of one continuous shot, with no invented ending and no joint.
 
-        alpha reproduces x0's coefficient exactly and beta tops the noise term back up to
-        b, so the result sits on the manifold the model expects at b. Both endpoints fall
-        out of the same formula: b == a gives alpha=1, beta=0 (an exact resume, nothing
-        added) and a == 0 gives alpha=1-b, beta=b, which is comfy's own fresh-noise
-        scaling on a clean latent. beta has a real root only when b >= a — noise can be
-        added back but never removed, which is why the caller refuses a restart below the
-        cut.
+        Nothing downstream constrains the new size: LTXAV's video patchifier has temporal
+        patch size 1 (SymmetricPatchifier(1) -> no divisibility rule on latent frames), the
+        streams reach the transformer as independent tensors with no enforced video:audio
+        ratio, and VAE decode is (f-1)*scale+1 for any f >= 1.
 
-        Streams listed in `reset_indices` were wiped to zeros (fresh audio) and are NOT
-        mid-trajectory, so they re-enter at a=0 and get the full b*n a from-scratch run
-        would start from, rather than a partial top-up of a latent that no longer exists.
-        """
-        a, b = float(from_sigma), float(to_sigma)
-        result = self._clone_latent(latent)
-        tensors = self._latent_tensors(result)
-        noise = comfy.sample.prepare_noise(result["samples"], int(seed))
-        noises = list(noise.unbind()) if self._is_nested(noise) else [noise]
-        for i, t in enumerate(tensors):
-            a_i = 0.0 if i in tuple(reset_indices) else a
-            alpha = (1.0 - b) / (1.0 - a_i) if a_i < 1.0 else 0.0
-            beta = math.sqrt(max(0.0, b * b - (a_i * alpha) ** 2))
-            n = noises[i].to(device=t.device, dtype=t.dtype)
-            tensors[i] = t * alpha + n * beta
-        if self._is_nested(result.get("samples")):
-            result["samples"] = comfy.nested_tensor.NestedTensor(tensors)
-        else:
-            result["samples"] = tensors[0]
-        return result
+        What DOES matter is proportion. Audio timings come from the audio stream's own index
+        and video's from its own RoPE, so cropping the two by different amounts of TIME
+        desynchronises them silently — no error, just sound that drifts. Each extra stream's
+        kept length is therefore derived from the new VIDEO length directly, never by
+        subtracting a separately-rounded drop.
 
-    def _anchor_shift_latent(self, latent, drop, tail_mode, fresh_audio):
-        """Slide the video stream left by `drop` latent frames and refill the freed tail.
-
-        The head frames (anchor + settling-in region) are dropped. In the three refilling
-        modes the clip keeps its full length, so no extra frames are ever generated to pay
-        for this, and `tail_mode` picks what the freed tail starts from. In "crop" there is
-        no tail at all: the clip is simply that much shorter, which is the only mode where
-        pass 2 never has to invent an ending or blend a joint.
-
-        Audio is optionally reset to an empty latent so pass 2 writes it fresh against the
-        shifted picture instead of inheriting pass 1's audio, which was scored against
-        frames that no longer exist at those positions.
+        Returns (latent, dropped).
         """
         result = self._clone_latent(latent)
         tensors = self._latent_tensors(result)
@@ -3343,50 +3176,21 @@ class FunPackLTXAVSceneChainSampler:
         drop = max(0, min(int(drop), frames - 1))
         if drop <= 0:
             return result, 0
-        head, body = video[:, :, :drop], video[:, :, drop:]
-        if tail_mode == "crop":
-            # No regrown tail — the clip just gets shorter.
-            #
-            # Nothing downstream constrains the new size: LTXAV's video patchifier has
-            # temporal patch size 1 (SymmetricPatchifier(1) -> no divisibility rule on
-            # latent frames), the streams reach the transformer as independent tensors with
-            # no enforced video:audio ratio, and comfy re-packs and re-derives latent_shapes
-            # (and the denoise masks off them) from whatever latent it is handed on the next
-            # sample_custom call — so a shorter latent needs nothing rebuilt.
-            #
-            # What DOES matter is proportion. Audio timings come from the audio stream's own
-            # index and video's from its own RoPE, so cropping the two by different amounts
-            # of TIME desynchronises them silently — no error, just sound that drifts. Each
-            # extra stream's kept length is therefore derived from the new VIDEO length
-            # directly, not by subtracting a separately-rounded drop, so rounding cannot
-            # leave the streams describing clips of different durations.
-            tensors[0] = body
-            kept = frames - drop
-            for _idx in range(1, len(tensors)):
-                _t = tensors[_idx]
-                if _t is None:
-                    continue
-                _n = self._tensor_frames(_t)
-                _keep = max(1, min(_n, int(round(_n * kept / max(1, frames)))))
-                if _keep < _n:
-                    tensors[_idx] = _t[:, :, _n - _keep:]
-        else:
-            if tail_mode == "wrap":
-                tail = head  # Mobius: the dropped head reappears at the end
-            elif tail_mode == "extend_last":
-                tail = body[:, :, -1:].repeat(1, 1, drop, 1, 1)
-            else:  # "empty": zeros, so pass 2's noise scaling starts that region from noise
-                tail = torch.zeros_like(head)
-            tensors[0] = torch.cat([body, tail], dim=2)
-        # After any cropping: the reset writes zeros at whatever length the stream now has,
-        # which is what defines the clip's audio duration.
-        if fresh_audio and len(tensors) > 1 and tensors[1] is not None:
-            tensors[1] = torch.zeros_like(tensors[1])
+        tensors[0] = video[:, :, drop:]
+        kept = frames - drop
+        for _idx in range(1, len(tensors)):
+            _t = tensors[_idx]
+            if _t is None:
+                continue
+            _n = self._tensor_frames(_t)
+            _keep = max(1, min(_n, int(round(_n * kept / max(1, frames)))))
+            if _keep < _n:
+                tensors[_idx] = _t[:, :, _n - _keep:]
         if self._is_nested(result.get("samples")):
             result["samples"] = comfy.nested_tensor.NestedTensor(tensors)
         else:
             result["samples"] = tensors[0]
-        # The pin belongs to a frame that no longer exists; pass 2 must run unpinned.
+        # The pin belongs to a frame that no longer exists.
         result.pop("noise_mask", None)
         return result, drop
 
@@ -5237,9 +5041,7 @@ class FunPackLTXAVSceneChainSampler:
                context_windows=False, context_window_length=145, context_window_overlap=40,
                context_window_schedule="uniform_standard", context_window_fuse="pyramid",
                context_window_freenoise=True, context_window_retain_first=False,
-               anchor_shift=False, anchor_shift_sigma=0.909, anchor_shift_frames=8,
-               anchor_shift_restart_sigma=0.0, anchor_shift_tail="extend_last",
-               anchor_shift_fresh_audio=True,
+               cut_opening_frames=0,
                second_pass=False, second_pass_op="none", second_pass_sigmas=None,
                unique_id=None, prompt=None):
         if not isinstance(positive, list) or not positive:
@@ -5305,11 +5107,7 @@ class FunPackLTXAVSceneChainSampler:
                 context_window_fuse=context_window_fuse,
                 context_window_freenoise=context_window_freenoise,
                 context_window_retain_first=context_window_retain_first,
-                anchor_shift=anchor_shift, anchor_shift_sigma=anchor_shift_sigma,
-                anchor_shift_frames=anchor_shift_frames,
-                anchor_shift_restart_sigma=anchor_shift_restart_sigma,
-                anchor_shift_tail=anchor_shift_tail,
-                anchor_shift_fresh_audio=anchor_shift_fresh_audio,
+                cut_opening_frames=cut_opening_frames,
                 second_pass=second_pass, second_pass_op=second_pass_op,
                 second_pass_sigmas=second_pass_sigmas,
             )
@@ -5723,238 +5521,104 @@ class FunPackLTXAVSceneChainSampler:
                     alg_guide_blur_sigma_threshold=alg_guide_blur_sigma_threshold,
                     bounded_attention_enabled=bounded_attention_enabled,
                 )
-                # anchor_shift: "fake t2v" — run with the real, untouched i2v anchor, then
-                # delete it from the clip instead of weakening it (ALG blurs the anchor and
-                # loses character detail; overlap tokens approximate it and lose some too).
-                _shift_split = None
-                _shift_post_only = False   # sigma 0: whole schedule, then shift, no pass 2
-                if anchor_shift:
-                    _shift_drop = self._expected_latent_frames(
-                        int(anchor_shift_frames) + 1, time_scale) - 1
+                # cut_opening_frames: let the real, untouched i2v anchor condition the scene
+                # at full strength, then cut it out of the finished clip instead of weakening
+                # it on the way in (ALG blurs the anchor and loses character detail; overlap
+                # tokens approximate it and lose some too). Eligibility is decided here, while
+                # the pre-sampling chunk is still around; the cut itself is a post-process on
+                # the finished latent, below, and costs no sampling at all.
+                _cut_drop = 0
+                if int(cut_opening_frames) > 0:
+                    _cut_drop = self._expected_latent_frames(
+                        int(cut_opening_frames) + 1, time_scale) - 1
                     if carried + soft_carried > 0:
-                        _reason = ("continuation scene — the head is carried frames from the "
-                                   "previous scene, not an anchor")
-                    elif guide_tail > 0:
-                        _reason = ("scene has appended guide frames at the tail (mid_scene_guide "
-                                   "/ carried i2v guides) — the slide would overwrite them")
-                    elif audio_tail > 0:
-                        _reason = ("scene has appended JoyAI audio memory — resetting the audio "
-                                   "stream would destroy the injected tail")
+                        _reason = ("continuation scene — the opening is carried frames from the "
+                                   "previous scene, not an anchor, and cutting them would break "
+                                   "the join with it")
+                    elif guide_tail > 0 or audio_tail > 0:
+                        _reason = ("scene is carrying appended frames (mid_scene_guide / carried "
+                                   "i2v guides / JoyAI audio memory) that are stripped after "
+                                   "sampling — the audio crop is derived from the video length, "
+                                   "which those extra frames would make wrong")
                     elif self._context_scene_latent_frames(chunk) is None:
                         _reason = "scene latent could not be read"
-                    elif _shift_drop <= 0:
-                        _reason = f"anchor_shift_frames={anchor_shift_frames} is under one latent frame"
+                    elif _cut_drop <= 0:
+                        _reason = (f"cut_opening_frames={cut_opening_frames} is under one latent "
+                                   f"frame at this VAE time scale")
                     elif self._anchor_pinned_frames(chunk) <= 0:
                         # No pinned prefix = a genuine t2v scene (no anchor image attached).
-                        # Shifting here would drop real generated frames for nothing — this is
-                        # the "fake t2v" trick, it needs a real anchor to fake it WITH.
-                        _reason = ("scene has no pinned i2v anchor (t2v scene) — nothing to shift; "
-                                   "attach an anchor image, or leave anchor_shift off")
-                    elif float(anchor_shift_sigma) <= 0.0:
-                        # NO SECOND PASS: "generate the whole video normally, then just cut the
-                        # beginning off." A cut at sigma 0 IS the end of the schedule, so pass 1
-                        # is the entire run and there is nothing left to denoise — the shift
-                        # becomes a post-process on the finished latent and costs nothing at all.
-                        if float(anchor_shift_restart_sigma) > 0:
-                            _reason = (f"anchor_shift_sigma=0 means no second pass at all (the "
-                                       f"whole schedule runs, then the head is cut), so there is "
-                                       f"nothing for anchor_shift_restart_sigma="
-                                       f"{anchor_shift_restart_sigma:g} to restart. Set it to 0, "
-                                       f"or raise anchor_shift_sigma above 0 to cut mid-schedule")
-                        elif anchor_shift_tail in ("extend_last", "empty"):
-                            # Nothing runs after the slide, so a refilled tail is never denoised:
-                            # extend_last would freeze the last frame for anchor_shift_frames and
-                            # empty would leave an empty latent on screen. crop and wrap are pure
-                            # rearrangements of already-finished content, so they are fine.
-                            _reason = (f"anchor_shift_tail={anchor_shift_tail} needs a second pass "
-                                       f"to regrow the tail, and anchor_shift_sigma=0 means there "
-                                       f"is none — the refilled tail would never be denoised. Use "
-                                       f"'crop' (clip just ends earlier) or 'wrap'")
-                        else:
-                            _shift_post_only = True
-                    elif 0 < float(anchor_shift_restart_sigma) < float(anchor_shift_sigma) - 1e-4:
-                        # Pass 2 would claim the latent is cleaner than pass 1 left it.
-                        # The re-noise can add noise back, never remove it.
-                        _reason = (f"anchor_shift_restart_sigma={anchor_shift_restart_sigma:g} is "
-                                   f"below anchor_shift_sigma={anchor_shift_sigma:g} — pass 2 can "
-                                   f"re-noise the shifted latent back UP to a higher sigma, but it "
-                                   f"cannot un-noise it down to a lower one. Use 0 to continue "
-                                   f"straight on from the cut, or a value at or above the cut")
+                        # Cutting here would throw away real generated frames for nothing —
+                        # this is the "fake t2v" trick, it needs a real anchor to fake it WITH.
+                        _reason = ("scene has no pinned i2v anchor (t2v scene) — nothing to cut "
+                                   "out; attach an anchor image, or set cut_opening_frames to 0")
                     else:
-                        _shift_split = self._anchor_shift_split_sigmas(
-                            sigmas, anchor_shift_sigma, anchor_shift_restart_sigma)
-                        _reason = (f"schedule never reaches anchor_shift_sigma="
-                                   f"{anchor_shift_sigma} with a step left on both sides — the cut "
-                                   f"needs a real step on each side of it. Use anchor_shift_sigma=0 "
-                                   f"to run the whole schedule and only cut the head off instead")
-                    if _shift_split is None and not _shift_post_only:
-                        run_mechanisms.append(f"anchor_shift(SKIPPED: {_reason})")
-                if _shift_split is not None:
-                    _sig_a, _sig_b, _cut_at, _restart_at, _resume, _restart_idx = _shift_split
-                    # Both passes are slices of THIS schedule. Hand the sampler the real thing
-                    # plus where each slice starts, so the quality phase, final-correction
-                    # window, AB2 ramp, pulse anchors and eta decay stay where the schedule
-                    # puts them instead of being re-derived inside each half.
-                    _pass1 = self._sample_chunk(
-                        model, sampler, _sig_a, scene_seed, cfg, scene_positive, scene_negative,
-                        chunk, schedule_context={"sigmas": sigmas, "offset": 0}, **_sample_kwargs)
-                    _shifted, _dropped = self._anchor_shift_latent(
-                        _pass1, _shift_drop, anchor_shift_tail, anchor_shift_fresh_audio)
-                    if not _resume:
-                        # REWIND: put the shifted mid-trajectory latent back at the restart
-                        # sigma. A fresh noise field is wanted here — reusing scene_seed would
-                        # re-apply the exact field pass 1 just resolved, against content that
-                        # has since moved.
-                        _reset_streams = ((1,) if (anchor_shift_fresh_audio
-                                                   and len(self._latent_tensors(_shifted)) > 1)
-                                          else ())
-                        _shifted = self._renoise_to_sigma(
-                            _shifted, _cut_at, _restart_at, scene_seed + 4242, _reset_streams)
-                    # Either way pass 2 is handed the exact x at its first sigma — as the
-                    # untouched hand-over (continue) or as the re-noised one (rewind) — so it
-                    # must never re-noise again. See _sample_chunk's continue_from_state.
-                    _kw2 = dict(_sample_kwargs)
-                    _kw2["step_offset"] = _sample_kwargs["step_offset"] + (_sig_a.numel() - 1)
-                    _kw2["continue_from_state"] = True
-                    _kw2["schedule_context"] = {"sigmas": sigmas, "offset": _restart_idx}
-                    sampled = self._sample_chunk(
-                        model, sampler, _sig_b, scene_seed + 4242, cfg, scene_positive,
-                        scene_negative, _shifted, **_kw2)
-                    _pinned_n = self._anchor_pinned_frames(chunk)
-                    # tail=crop makes the scene SHORTER than the length that was asked for.
-                    # That is the mode's whole point, but it must never be something the user
-                    # has to infer from the output — say it in the report, in latent frames
-                    # and in the real frames they set.
-                    _tail_note = ""
-                    if anchor_shift_tail == "crop":
-                        try:
-                            _before = self._tensor_frames(self._latent_tensors(_pass1)[0])
-                            _after = self._tensor_frames(self._latent_tensors(sampled)[0])
-                            _tail_note = (f", CROPPED to {_after} of {_before} latent frames "
-                                          f"(~{int(anchor_shift_frames)} real frames shorter — "
-                                          f"no tail regrown)")
-                        except Exception:
-                            _tail_note = ", CROPPED (no tail regrown)"
-                    run_mechanisms.append(
-                        f"anchor_shift({'continue' if _resume else 'rewind'} "
-                        f"cut@{_cut_at:g} restart@{_restart_at:g}, "
-                        f"dropped {_dropped} of {_pinned_n} pinned latent frames, "
-                        f"tail={anchor_shift_tail}{_tail_note}"
-                        f"{', fresh audio' if anchor_shift_fresh_audio else ''})")
-                    if _dropped < _pinned_n:
-                        # Part of the anchor survives the slide and stays visible in the clip —
-                        # the one outcome this feature exists to prevent, so name the fix.
-                        run_mechanisms.append(
-                            f"anchor_shift WARNING: {_pinned_n - _dropped} anchor latent frame(s) "
-                            f"still in the clip — raise anchor_shift_frames to at least "
-                            f"{_pinned_n * max(1, int(time_scale))}")
-                elif _shift_post_only:
-                    # No second pass: sample the scene exactly as if anchor_shift were off — the
-                    # anchor stays pinned for the whole schedule, which is the point (full-strength
-                    # identity transfer) — then slide the head off the FINISHED latent. Zero extra
-                    # sampling, so this is the cheapest form of the trick by a wide margin.
-                    _full = self._sample_chunk(
-                        model, sampler, sigmas, scene_seed, cfg, scene_positive, scene_negative,
-                        chunk, **_sample_kwargs)
-                    # fresh_audio is forced OFF here: it resets the audio for pass 2 to rewrite,
-                    # and with no pass 2 the reset would just leave the clip silent.
-                    sampled, _dropped = self._anchor_shift_latent(
-                        _full, _shift_drop, anchor_shift_tail, False)
-                    _pinned_n = self._anchor_pinned_frames(chunk)
-                    _tail_note = ""
-                    if anchor_shift_tail == "crop":
-                        try:
-                            _before = self._tensor_frames(self._latent_tensors(_full)[0])
-                            _after = self._tensor_frames(self._latent_tensors(sampled)[0])
-                            _tail_note = (f", CROPPED to {_after} of {_before} latent frames "
-                                          f"(~{int(anchor_shift_frames)} real frames shorter)")
-                        except Exception:
-                            _tail_note = ", CROPPED"
-                    run_mechanisms.append(
-                        f"anchor_shift(no second pass — full schedule then head cut, "
-                        f"dropped {_dropped} of {_pinned_n} pinned latent frames, "
-                        f"tail={anchor_shift_tail}{_tail_note})")
-                    if anchor_shift_fresh_audio:
-                        # The audio was written against the finished picture and nothing will
-                        # rewrite it, so a reset here would just leave the clip silent.
-                        run_mechanisms.append(
-                            "anchor_shift NOTE: anchor_shift_fresh_audio is ignored with no second "
-                            "pass — resetting the audio with nothing left to regenerate it would "
-                            "produce a silent clip, so pass 1's audio is kept.")
-                    if _dropped < _pinned_n:
-                        run_mechanisms.append(
-                            f"anchor_shift WARNING: {_pinned_n - _dropped} anchor latent frame(s) "
-                            f"still in the clip — raise anchor_shift_frames to at least "
-                            f"{_pinned_n * max(1, int(time_scale))}")
-                else:
-                    # General second pass. Reaching this branch means anchor_shift did not act
-                    # on this scene (it is either off, or was skipped with a reason above), so
-                    # the two features never nest — they stay independent by construction.
-                    #
-                    # The shape is deliberately plain: pass 1 runs the main schedule IN FULL,
-                    # exactly as written, then pass 2 runs its own schedule IN FULL, exactly as
-                    # written. Nothing is cut and nothing is "continued from" — those belong to
-                    # anchor_shift, which stops mid-trajectory on purpose. To make pass 1
-                    # shorter, shorten the main schedule. Pass 2 therefore starts from a
-                    # FINISHED clip, so it re-enters through comfy's ordinary CONST noise
-                    # scaling (continue_from_state stays off) — valid precisely because the
-                    # input is clean. Total steps are simply the two schedules added up.
-                    _sp_b = None
-                    if second_pass:
-                        _sp_b, _sp_reason = self._second_pass_schedule(second_pass_sigmas)
-                        if _sp_b is None:
-                            run_mechanisms.append(f"second_pass(SKIPPED: {_sp_reason})")
-                    _full = self._sample_chunk(
-                        model, sampler, sigmas, scene_seed, cfg, scene_positive,
-                        scene_negative, chunk, **_sample_kwargs)
+                        _reason = None
+                    if _reason is not None:
+                        run_mechanisms.append(f"cut_opening_frames(SKIPPED: {_reason})")
+                        _cut_drop = 0
+                # Optional second pass. The shape is deliberately plain: pass 1 runs the
+                # main schedule IN FULL, exactly as written, then pass 2 runs its own
+                # schedule IN FULL, exactly as written. Nothing is cut short and nothing is
+                # derived — to make pass 1 shorter, shorten the main schedule. Pass 2 starts
+                # from a FINISHED clip, so it re-enters through comfy's ordinary CONST noise
+                # scaling, valid precisely because the input is clean. Total steps are simply
+                # the two schedules added up.
+                _sp_b = None
+                if second_pass:
+                    _sp_b, _sp_reason = self._second_pass_schedule(second_pass_sigmas)
                     if _sp_b is None:
-                        sampled = _full
-                    else:
-                        _sp_state = _full
-                        if second_pass_op not in (None, "none", ""):
-                            # The op runs on the FINISHED pass-1 clip, which is the only state
-                            # it makes sense on: sharpening a half-denoised latent sharpens the
-                            # noise in it. Shares segmented detailing's lazily-loaded upsampler.
-                            if _detail_upsampler_model is None and _detail_disabled_reason is None:
+                        run_mechanisms.append(f"second_pass(SKIPPED: {_sp_reason})")
+                _full = self._sample_chunk(
+                    model, sampler, sigmas, scene_seed, cfg, scene_positive,
+                    scene_negative, chunk, **_sample_kwargs)
+                if _sp_b is None:
+                    sampled = _full
+                else:
+                    _sp_state = _full
+                    if second_pass_op not in (None, "none", ""):
+                        # The op runs on the FINISHED pass-1 clip, which is the only state
+                        # it makes sense on: sharpening a half-denoised latent sharpens the
+                        # noise in it. Shares segmented detailing's lazily-loaded upsampler.
+                        if _detail_upsampler_model is None and _detail_disabled_reason is None:
+                            try:
                                 try:
-                                    try:
-                                        from . import detailing as _det
-                                    except ImportError:
-                                        import detailing as _det
-                                    _r = _det.resolve_upsampler_name(detail_upsampler)
-                                    _detail_upsampler_model = _det.load_latent_upsampler(_r)
-                                except Exception as _exc:  # noqa: BLE001
-                                    _detail_disabled_reason = str(_exc)
-                            _sp_state, _op_note = self._second_pass_operate(
-                                _sp_state, second_pass_op, _detail_upsampler_model, vae)
-                            if _op_note:
-                                run_mechanisms.append(_op_note)
-                            elif _detail_disabled_reason:
-                                run_mechanisms.append(
-                                    f"second_pass_op={second_pass_op} skipped: upsampler "
-                                    f"unavailable ({_detail_disabled_reason})")
-                        # Unlike anchor_shift, a plain second pass must KEEP the i2v anchor
-                        # pinned — otherwise pass 2 re-denoises the reference frame and the
-                        # scene drifts away from the image it was supposed to start from.
-                        _sp_before = _sp_state
-                        _sp_state = self._restore_pinned_prefix(_sp_state, chunk)
-                        if _sp_state is _sp_before and self._anchor_pinned_frames(chunk) > 0:
-                            # Only happens when the op changed the resolution — say so, because
-                            # an unpinned pass 2 can drift off the reference image.
+                                    from . import detailing as _det
+                                except ImportError:
+                                    import detailing as _det
+                                _r = _det.resolve_upsampler_name(detail_upsampler)
+                                _detail_upsampler_model = _det.load_latent_upsampler(_r)
+                            except Exception as _exc:  # noqa: BLE001
+                                _detail_disabled_reason = str(_exc)
+                        _sp_state, _op_note = self._second_pass_operate(
+                            _sp_state, second_pass_op, _detail_upsampler_model, vae)
+                        if _op_note:
+                            run_mechanisms.append(_op_note)
+                        elif _detail_disabled_reason:
                             run_mechanisms.append(
-                                "second_pass NOTE: the i2v anchor could not stay pinned for pass 2 "
-                                "because second_pass_op changed the latent resolution — pass 2 runs "
-                                "unpinned and may drift from the reference image.")
-                        _sp_kw = dict(_sample_kwargs)
-                        _sp_kw["step_offset"] = _sample_kwargs["step_offset"] + (int(sigmas.numel()) - 1)
-                        sampled = self._sample_chunk(
-                            model, sampler, _sp_b, scene_seed + 4242, cfg, scene_positive,
-                            scene_negative, _sp_state, **_sp_kw)
+                                f"second_pass_op={second_pass_op} skipped: upsampler "
+                                f"unavailable ({_detail_disabled_reason})")
+                    # A second pass must KEEP the i2v anchor pinned — otherwise pass 2
+                    # re-denoises the reference frame and the scene drifts away from the
+                    # image it was supposed to start from.
+                    _sp_before = _sp_state
+                    _sp_state = self._restore_pinned_prefix(_sp_state, chunk)
+                    if _sp_state is _sp_before and self._anchor_pinned_frames(chunk) > 0:
+                        # Only happens when the op changed the resolution — say so, because
+                        # an unpinned pass 2 can drift off the reference image.
                         run_mechanisms.append(
-                            f"second_pass({int(sigmas.numel()) - 1} steps + "
-                            f"{int(_sp_b.numel()) - 1} steps = "
-                            f"{int(sigmas.numel()) + int(_sp_b.numel()) - 2} total, "
-                            f"pass 2 from {float(_sp_b[0].item()):g})")
+                            "second_pass NOTE: the i2v anchor could not stay pinned for pass 2 "
+                            "because second_pass_op changed the latent resolution — pass 2 runs "
+                            "unpinned and may drift from the reference image.")
+                    _sp_kw = dict(_sample_kwargs)
+                    _sp_kw["step_offset"] = _sample_kwargs["step_offset"] + (int(sigmas.numel()) - 1)
+                    sampled = self._sample_chunk(
+                        model, sampler, _sp_b, scene_seed + 4242, cfg, scene_positive,
+                        scene_negative, _sp_state, **_sp_kw)
+                    run_mechanisms.append(
+                        f"second_pass({int(sigmas.numel()) - 1} steps + "
+                        f"{int(_sp_b.numel()) - 1} steps = "
+                        f"{int(sigmas.numel()) + int(_sp_b.numel()) - 2} total, "
+                        f"pass 2 from {float(_sp_b[0].item()):g})")
                 _scene_sample_s = _time.perf_counter() - _t_sample0
                 _phase_sampling += _scene_sample_s
                 if _plateau_stats is not None:
@@ -5973,6 +5637,25 @@ class FunPackLTXAVSceneChainSampler:
                         model.model_options["model_function_wrapper"] = _scene_base_wrapper
                     else:
                         model.model_options.pop("model_function_wrapper", None)
+            if _cut_drop > 0:
+                # The finished clip, minus its opening. Nothing is regrown, so the scene is
+                # now shorter than the length that was asked for — say so in the report
+                # rather than leaving it to be inferred from the output.
+                _before_cut = self._tensor_frames(self._latent_tensors(sampled)[0])
+                sampled, _dropped = self._cut_opening_latent(sampled, _cut_drop)
+                _after_cut = self._tensor_frames(self._latent_tensors(sampled)[0])
+                _pinned_n = self._anchor_pinned_frames(chunk)
+                run_mechanisms.append(
+                    f"cut_opening_frames(dropped {_dropped} of {_pinned_n} pinned latent "
+                    f"frames — clip CROPPED to {_after_cut} of {_before_cut} latent frames, "
+                    f"~{int(cut_opening_frames)} real frames shorter)")
+                if _dropped < _pinned_n:
+                    # Part of the anchor is still visible — the one outcome this exists to
+                    # prevent, so name the fix.
+                    run_mechanisms.append(
+                        f"cut_opening_frames WARNING: {_pinned_n - _dropped} anchor latent "
+                        f"frame(s) still in the clip — raise cut_opening_frames to at least "
+                        f"{_pinned_n * max(1, int(time_scale))}")
             if carried + soft_carried > 0:
                 sampled = self._crop_video_head(sampled, carried + soft_carried)
             if guide_tail > 0:
@@ -6292,9 +5975,7 @@ class FunPackLTXAVSceneChainSampler:
                             context_window_overlap=40, context_window_schedule="uniform_standard",
                             context_window_fuse="pyramid", context_window_freenoise=True,
                             context_window_retain_first=False,
-                            anchor_shift=False, anchor_shift_sigma=0.909, anchor_shift_frames=8,
-                            anchor_shift_restart_sigma=0.0, anchor_shift_tail="extend_last",
-                            anchor_shift_fresh_audio=True,
+                            cut_opening_frames=0,
                             second_pass=False, second_pass_op="none",
                             second_pass_sigmas=None):
         """Sample one chain per Studio-packed variant entry (seed + index), persisting each result
@@ -6356,11 +6037,7 @@ class FunPackLTXAVSceneChainSampler:
                 context_window_fuse=context_window_fuse,
                 context_window_freenoise=context_window_freenoise,
                 context_window_retain_first=context_window_retain_first,
-                anchor_shift=anchor_shift, anchor_shift_sigma=anchor_shift_sigma,
-                anchor_shift_frames=anchor_shift_frames,
-                anchor_shift_restart_sigma=anchor_shift_restart_sigma,
-                anchor_shift_tail=anchor_shift_tail,
-                anchor_shift_fresh_audio=anchor_shift_fresh_audio,
+                cut_opening_frames=cut_opening_frames,
                 second_pass=second_pass, second_pass_op=second_pass_op,
                 second_pass_sigmas=second_pass_sigmas,
                 unique_id=None, prompt=None,
diff --git a/tests/test_anchor_shift.py b/tests/test_anchor_shift.py
deleted file mode 100644
index 0042ee54..00000000
--- a/tests/test_anchor_shift.py
+++ /dev/null
@@ -1,478 +0,0 @@
-"""anchor_shift — "fake t2v": run with the real untouched i2v anchor, then delete it.
-
-The point of the feature is that the anchor is NOT weakened on the way in (ALG blurs it and
-loses character detail; Best-FaceID overlap tokens approximate it and lose some too) — it is
-pinned at full strength for pass 1 and then removed from the clip entirely. So the invariants
-worth testing are about the shift itself:
-
-0. Pass 1 stops at anchor_shift_sigma — ALWAYS. That cut is the feature; no other setting
-   may quietly override it (an earlier fix let the restart sigma do exactly that, which
-   made the shift sigma inert without saying so).
-1. The schedule is cut into two passes that each still have a real step, or refused outright.
-1b. A restart above the cut re-noises the half-denoised latent back up to it correctly —
-   rebuilding x at the higher sigma, not re-noising it as if it were a finished image.
-2. The slide drops the head WITHOUT shortening the clip — no extra frames are ever generated.
-3. The pin is dropped with the frame it belonged to (pass 2 must run unpinned).
-4. Audio is reset when asked, since pass 1's audio was formed against frames that moved.
-"""
-import math
-import sys
-import types
-from pathlib import Path
-
-import pytest
-import torch
-
-sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
-
-for _name in (
-    "comfy", "comfy.k_diffusion", "comfy.k_diffusion.sampling",
-    "comfy.model_sampling", "comfy.nested_tensor", "comfy.sample",
-    "comfy.samplers", "comfy.utils",
-):
-    sys.modules.setdefault(_name, types.ModuleType(_name))
-sys.modules["comfy.nested_tensor"].NestedTensor = object
-
-import samplers  # noqa: E402
-
-
-# The standard LTX distilled schedule: plateau, then structure at 0.909, then detail.
-SCHEDULE = torch.tensor([1.0, 0.975, 0.909, 0.725, 0.422, 0.0])
-
-
-def _node():
-    return samplers.FunPackLTXAVSceneChainSampler()
-
-
-def _latent(frames=10, audio=True):
-    video = torch.arange(frames, dtype=torch.float32).view(1, 1, frames, 1, 1).repeat(1, 4, 1, 2, 2)
-    latent = {"samples": video, "noise_mask": torch.zeros_like(video)}
-    if audio:
-        latent["_audio"] = torch.ones(1, 4, frames * 2)
-    return latent
-
-
-# ── schedule splitting ──────────────────────────────────────────────────────
-
-def test_continue_mode_stops_at_the_cut_and_resumes_from_that_state():
-    first, second, cut_at, restart_at, resume, start_idx = _node()._anchor_shift_split_sigmas(
-        SCHEDULE, 0.909, 0.0)
-    # float32: the schedule stores 0.909 as 0.90899997, so compare loosely.
-    assert abs(cut_at - 0.909) < 1e-5 and abs(restart_at - 0.909) < 1e-5
-    # pass 1 ends ON the cut sigma; pass 2 resumes from it, so no step is run twice.
-    assert [round(v, 3) for v in first.tolist()] == [1.0, 0.975, 0.909]
-    assert [round(v, 3) for v in second.tolist()] == [0.909, 0.725, 0.422, 0.0]
-    # resume=True is load-bearing: pass 2 receives a MID-TRAJECTORY latent, and comfy's
-    # CONST scaling (x = s*noise + (1-s)*latent) would otherwise treat it as a clean image
-    # and re-noise it — scaling the picture to (1-s) under a fresh s of noise. That is the
-    # bug that made the first live run come out under-denoised.
-    assert resume is True
-
-
-def test_rewind_mode_still_stops_pass_one_at_the_cut():
-    """The cut sigma is the whole feature — rewind must NOT override it. Pass 1 stops
-    where the user asked, and the restart only decides where pass 2 re-enters."""
-    first, second, cut_at, restart_at, resume, start_idx = _node()._anchor_shift_split_sigmas(
-        SCHEDULE, 0.725, 0.975)
-    assert abs(cut_at - 0.725) < 1e-5 and abs(restart_at - 0.975) < 1e-5
-    assert [round(v, 3) for v in first.tolist()] == [1.0, 0.975, 0.909, 0.725]
-    assert [round(v, 3) for v in second.tolist()] == [0.975, 0.909, 0.725, 0.422, 0.0]
-    # resume=False means the caller must re-noise 0.725 -> 0.975 before pass 2 runs.
-    assert resume is False
-
-
-def test_sigma_zero_is_refused_as_a_split_because_it_is_the_no_second_pass_mode():
-    """anchor_shift_sigma=0 must not produce a split — the cut IS the end of the schedule,
-    so there is no pass 2. The caller handles it as a post-process on the finished latent
-    ('generate the whole video, then cut the head off'); the splitter just declines."""
-    assert _node()._anchor_shift_split_sigmas(USER_SCHEDULE, 0.0, 0.0) is None
-    # The other end is genuinely unusable: a cut at the first sigma leaves pass 1 no step.
-    assert _node()._anchor_shift_split_sigmas(USER_SCHEDULE, 1.0, 0.0) is None
-
-
-def test_rewind_refuses_a_restart_below_the_cut():
-    """Pass 2 can be handed a NOISIER latent, never a cleaner one — there is no way to
-    remove noise from the state pass 1 stopped at."""
-    assert _node()._anchor_shift_split_sigmas(SCHEDULE, 0.909, 0.422) is None
-
-
-def test_restart_landing_on_the_cut_is_just_continue():
-    """A restart that snaps to the cut's own step has nothing to re-noise."""
-    _, _, cut_at, restart_at, resume, _ = _node()._anchor_shift_split_sigmas(
-        SCHEDULE, 0.909, 0.909)
-    assert abs(cut_at - restart_at) < 1e-5
-    assert resume is True
-
-
-# ── the sampler must still see the REAL schedule ────────────────────────────
-
-# The user's own 9-step schedule, used here because the boundary walk has to be right on
-# the schedule they actually run, not on the toy one above.
-USER_SCHEDULE = torch.tensor(
-    [1.0, 0.955, 0.893, 0.812, 0.715, 0.603, 0.482, 0.241, 0.121, 0.0])
-
-
-def test_cut_is_the_step_whose_next_sigma_crosses_the_threshold():
-    """Walk the real schedule: the last pre-shift step is the one whose NEXT sigma has
-    crossed the shift point. At shift 0.482 the steps at 1.000 and 0.955 both have a next
-    sigma still above it and proceed; the step at 0.603 has next=0.482, so it is the last."""
-    first, second, cut_at, restart_at, resume, start_idx = _node()._anchor_shift_split_sigmas(
-        USER_SCHEDULE, 0.482, 0.812)
-    assert [round(v, 3) for v in first.tolist()] == [1.0, 0.955, 0.893, 0.812, 0.715, 0.603, 0.482]
-    assert abs(cut_at - 0.482) < 1e-5
-    # Pass 2 re-enters at 0.812, which is index 3 of the real schedule.
-    assert start_idx == 3
-    assert abs(restart_at - 0.812) < 1e-5
-    assert [round(v, 3) for v in second.tolist()] == [0.812, 0.715, 0.603, 0.482, 0.241, 0.121, 0.0]
-    assert resume is False
-
-
-def test_schedule_view_hands_the_sampler_the_whole_schedule():
-    """Without this the sampler measures its phases from the SLICE: the final-correction
-    window reopens at the end of pass 1, the AB2 ramp restarts, and the velocity-bias
-    ratio is taken against the slice's own first sigma instead of the schedule's."""
-    slice_ = USER_SCHEDULE[3:]
-    sched, offset = samplers._schedule_view(
-        slice_, {"sigmas": USER_SCHEDULE, "offset": 3})
-    assert sched is USER_SCHEDULE and offset == 3
-    # Concretely: 9 real steps, not the 6 the slice would have claimed.
-    assert len(sched) - 1 == 9 and len(slice_) - 1 == 6
-
-
-def test_schedule_view_falls_back_to_the_sigmas_it_was_given():
-    """Every normal single-call run passes no context — `sigmas` IS the whole schedule."""
-    for ctx in (None, {}, {"sigmas": None}, {"sigmas": torch.tensor([1.0])}, "nonsense"):
-        sched, offset = samplers._schedule_view(USER_SCHEDULE, ctx)
-        assert sched is USER_SCHEDULE and offset == 0
-
-
-def test_schedule_view_never_returns_a_negative_offset():
-    sched, offset = samplers._schedule_view(
-        USER_SCHEDULE, {"sigmas": USER_SCHEDULE, "offset": -5})
-    assert offset == 0
-
-
-# ── the mid-trajectory re-noise ─────────────────────────────────────────────
-
-class _FakeNested(list):
-    """Minimal stand-in for comfy's NestedTensor: enough for _is_nested + unbind."""
-    is_nested = True
-
-    def unbind(self):
-        return list(self)
-
-
-@pytest.fixture
-def renoise_stubs():
-    """Deterministic noise (a constant 7.0) plus a usable NestedTensor.
-
-    Snapshot/restore for the same reason the fixture below does it: these comfy stubs are
-    shared module objects, and mutations left behind change other modules' results.
-    """
-    mod = sys.modules["comfy.sample"]
-    comfy_mod = sys.modules["comfy"]
-    nested_mod = sys.modules["comfy.nested_tensor"]
-    saved = (getattr(mod, "prepare_noise", None), getattr(comfy_mod, "sample", None),
-             nested_mod.NestedTensor, getattr(comfy_mod, "nested_tensor", None))
-
-    def prepare_noise(samples, seed, *a, **k):
-        if getattr(samples, "is_nested", False):
-            return _FakeNested([torch.full_like(t, 7.0) for t in samples.unbind()])
-        return torch.full_like(samples, 7.0)
-
-    mod.prepare_noise = prepare_noise
-    comfy_mod.sample = mod
-    comfy_mod.nested_tensor = nested_mod  # attribute access, not just sys.modules
-    nested_mod.NestedTensor = _FakeNested
-    yield
-    if saved[0] is None:
-        delattr(mod, "prepare_noise")
-    else:
-        mod.prepare_noise = saved[0]
-    if saved[1] is None:
-        delattr(comfy_mod, "sample")
-    else:
-        comfy_mod.sample = saved[1]
-    nested_mod.NestedTensor = saved[2]
-    if saved[3] is None:
-        delattr(comfy_mod, "nested_tensor")
-    else:
-        comfy_mod.nested_tensor = saved[3]
-
-
-def test_renoise_to_the_same_sigma_is_an_identity(renoise_stubs):
-    """b == a must add nothing: alpha=1, beta=0. This is what lets continue mode and
-    rewind mode be one formula instead of two special cases."""
-    latent = {"samples": torch.full((1, 4, 6, 2, 2), 3.0)}
-    out = _node()._renoise_to_sigma(latent, 0.725, 0.725, seed=7)
-    assert torch.allclose(out["samples"], latent["samples"], atol=1e-6)
-
-
-def test_renoise_from_zero_matches_comfy_const_scaling(renoise_stubs):
-    """a == 0 (a finished latent) must reproduce comfy's own x = b*noise + (1-b)*x0, so
-    the formula strictly generalises the img2img re-noise rather than replacing it."""
-    b = 0.975
-    x0 = torch.full((1, 4, 6, 2, 2), 3.0)
-    out = _node()._renoise_to_sigma({"samples": x0}, 0.0, b, seed=11)
-    expected = _const_noise_scaling(b, torch.full_like(x0, 7.0), x0)
-    assert torch.allclose(out["samples"], expected, atol=1e-6)
-
-
-def test_renoise_upward_rebuilds_the_state_at_the_higher_sigma(renoise_stubs):
-    """The bug this feature shipped with, fixed properly. Pass 1 stops at 0.603 and pass 2
-    restarts at 0.893: x0's coefficient must land on (1-b) EXACTLY and the noise term must
-    total b — anything else is the under-denoising from the first live run coming back."""
-    a, b = 0.603, 0.893
-    x0, eps = torch.full((1, 4, 6, 2, 2), 3.0), torch.full((1, 4, 6, 2, 2), -1.5)
-    x_a = x0 * (1.0 - a) + eps * a          # a genuine mid-trajectory latent
-    out = _node()._renoise_to_sigma({"samples": x_a}, a, b, seed=3)
-
-    alpha = (1.0 - b) / (1.0 - a)
-    beta = math.sqrt(b * b - (a * alpha) ** 2)
-    assert abs(alpha * (1.0 - a) - (1.0 - b)) < 1e-9   # picture kept at full strength
-    assert abs((alpha * a) ** 2 + beta ** 2 - b * b) < 1e-9  # noise topped back up to b
-    assert torch.allclose(out["samples"], x_a * alpha + 7.0 * beta, atol=1e-6)
-    # And the naive path is measurably NOT this — the whole point of the fix.
-    assert not torch.allclose(out["samples"],
-                              _const_noise_scaling(b, torch.full_like(x_a, 7.0), x_a), atol=1e-3)
-
-
-def test_renoise_starts_a_reset_stream_from_scratch(renoise_stubs):
-    """A stream wiped by fresh_audio is not mid-trajectory — topping it up as if it were
-    would start it quieter than a from-scratch run does. It gets the full b*noise."""
-    b = 0.893
-    latent = {"samples": _FakeNested(
-        [torch.full((1, 4, 6, 2, 2), 2.0), torch.zeros(1, 4, 12)])}
-    out = _node()._renoise_to_sigma(latent, 0.603, b, seed=5, reset_indices=(1,))
-    video, audio = out["samples"].unbind()
-    assert torch.allclose(audio, torch.full_like(audio, 7.0 * b), atol=1e-6)
-    # ...and the video stream still took the mid-trajectory path, not the a=0 one.
-    alpha = (1.0 - b) / (1.0 - 0.603)
-    expected = 2.0 * alpha + 7.0 * math.sqrt(b * b - (0.603 * alpha) ** 2)
-    assert torch.allclose(video, torch.full_like(video, expected), atol=1e-6)
-
-
-def test_renoise_never_mutates_its_input(renoise_stubs):
-    latent = {"samples": torch.full((1, 4, 6, 2, 2), 3.0)}
-    before = latent["samples"].clone()
-    _node()._renoise_to_sigma(latent, 0.603, 0.893, seed=1)
-    assert torch.equal(latent["samples"], before)
-
-
-def test_split_refuses_when_a_pass_would_have_no_steps():
-    n = _node()
-    # Threshold at/above the first sigma: pass 1 would be a single point, no step.
-    assert n._anchor_shift_split_sigmas(SCHEDULE, 1.0, 0.0) is None
-    # Threshold below everything in the schedule: never reached.
-    assert n._anchor_shift_split_sigmas(SCHEDULE, 0.001, 0.0) is None
-    # One step either side is legitimate, even on a minimal 3-sigma schedule.
-    assert n._anchor_shift_split_sigmas(torch.tensor([1.0, 0.5, 0.0]), 0.5, 0.0) is not None
-    # ...but cutting at the FINAL sigma leaves pass 2 a single point, no step.
-    assert n._anchor_shift_split_sigmas(torch.tensor([1.0, 0.5, 0.0]), 0.0, 0.0) is None
-
-
-def test_split_refuses_a_degenerate_schedule():
-    n = _node()
-    assert n._anchor_shift_split_sigmas(torch.tensor([1.0, 0.0]), 0.5, 0.0) is None
-    assert n._anchor_shift_split_sigmas(None, 0.9, 0.0) is None
-
-
-# ── the slide ───────────────────────────────────────────────────────────────
-
-def test_slide_drops_the_head_without_shortening_the_clip():
-    latent = _latent(frames=10)
-    shifted, dropped = _node()._anchor_shift_latent(latent, 2, "extend_last", False)
-    assert dropped == 2
-    v = shifted["samples"]
-    # Length preserved — the feature must never cost extra generated frames.
-    assert v.shape[2] == 10
-    # Frames 2..9 slid to 0..7; the anchor (frame 0) is gone from the clip entirely.
-    assert [float(v[0, 0, i, 0, 0]) for i in range(8)] == [2., 3., 4., 5., 6., 7., 8., 9.]
-    # ...and the freed tail continues from the last real frame.
-    assert [float(v[0, 0, i, 0, 0]) for i in (8, 9)] == [9., 9.]
-
-
-def test_wrap_tail_puts_the_dropped_head_at_the_end():
-    shifted, _ = _node()._anchor_shift_latent(_latent(frames=10), 2, "wrap", False)
-    v = shifted["samples"]
-    assert [float(v[0, 0, i, 0, 0]) for i in (8, 9)] == [0., 1.]
-
-
-def test_empty_tail_zeroes_the_freed_region():
-    shifted, _ = _node()._anchor_shift_latent(_latent(frames=10), 3, "empty", False)
-    v = shifted["samples"]
-    assert torch.equal(v[:, :, -3:], torch.zeros_like(v[:, :, -3:]))
-    assert float(v[0, 0, 0, 0, 0]) == 3.0
-
-
-def test_slide_drops_the_pin_with_the_frame_it_belonged_to():
-    latent = _latent(frames=10)
-    assert "noise_mask" in latent
-    shifted, _ = _node()._anchor_shift_latent(latent, 1, "extend_last", False)
-    # Pass 2 must run unpinned — the pinned frame no longer exists.
-    assert "noise_mask" not in shifted
-
-
-def test_slide_never_consumes_the_whole_clip():
-    shifted, dropped = _node()._anchor_shift_latent(_latent(frames=4), 99, "extend_last", False)
-    assert dropped == 3  # clamped to frames - 1
-    assert shifted["samples"].shape[2] == 4
-
-
-def test_zero_drop_is_a_no_op():
-    shifted, dropped = _node()._anchor_shift_latent(_latent(frames=6), 0, "extend_last", True)
-    assert dropped == 0
-    assert torch.equal(shifted["samples"], _latent(frames=6)["samples"])
-
-
-def test_source_latent_is_never_mutated():
-    latent = _latent(frames=8)
-    before = latent["samples"].clone()
-    _node()._anchor_shift_latent(latent, 3, "extend_last", True)
-    assert torch.equal(latent["samples"], before)
-
-
-# ── tail=crop: no regrown tail, the clip just gets shorter ──────────────────
-
-def _av_latent(video_frames=10, audio_frames=20):
-    """A packed-style AV latent: video [B,C,F,H,W] + audio [B,C,T] at its own rate."""
-    video = torch.arange(video_frames, dtype=torch.float32).view(
-        1, 1, video_frames, 1, 1).repeat(1, 4, 1, 2, 2)
-    audio = torch.arange(audio_frames, dtype=torch.float32).view(1, 1, audio_frames).repeat(1, 4, 1)
-    return {"samples": _FakeNested([video, audio]), "noise_mask": torch.zeros_like(video)}
-
-
-def test_crop_shortens_the_clip_instead_of_regrowing_a_tail(renoise_stubs):
-    shifted, dropped = _node()._anchor_shift_latent(_latent(frames=10), 3, "crop", False)
-    assert dropped == 3
-    # 10 - 3, not 10: nothing is invented at the end, which is the whole point of the mode.
-    assert shifted["samples"].shape[2] == 7
-    # And what survives is the ORIGINAL frames 3..9, untouched — no blend, no joint.
-    assert [int(v) for v in shifted["samples"][0, 0, :, 0, 0]] == [3, 4, 5, 6, 7, 8, 9]
-
-
-def test_crop_keeps_audio_and_video_describing_the_same_duration(renoise_stubs):
-    """Audio timing comes from the audio stream's own index and video's from its own RoPE,
-    so cropping them by different amounts of TIME desyncs the clip silently — no error,
-    just drifting sound. The kept lengths must stay in proportion."""
-    shifted, _ = _node()._anchor_shift_latent(_av_latent(10, 20), 3, "crop", False)
-    video, audio = shifted["samples"].unbind()
-    assert video.shape[2] == 7 and audio.shape[2] == 14      # 7/10 == 14/20
-    # Cropped from the HEAD, matching the video slide — the tail is what survives.
-    assert [int(v) for v in audio[0, 0]] == list(range(6, 20))
-
-
-def test_crop_keeps_proportion_when_the_rate_does_not_divide_evenly(renoise_stubs):
-    """The rounding trap: deriving audio's KEPT length from the new video length keeps the
-    two in proportion; subtracting a separately-rounded drop can leave them a frame apart."""
-    for v_frames, a_frames, drop in ((10, 15, 3), (9, 14, 4), (13, 7, 5), (10, 21, 7)):
-        shifted, _ = _node()._anchor_shift_latent(_av_latent(v_frames, a_frames), drop, "crop", False)
-        video, audio = shifted["samples"].unbind()
-        assert audio.shape[2] == max(1, round(a_frames * video.shape[2] / v_frames))
-        assert audio.shape[2] >= 1 and video.shape[2] >= 1
-
-
-def test_crop_still_resets_audio_when_asked_at_the_cropped_length(renoise_stubs):
-    """fresh_audio zeroes the stream AFTER the crop, so the reset length is the new
-    duration — zeroing first would leave the clip's audio length describing the old one."""
-    shifted, _ = _node()._anchor_shift_latent(_av_latent(10, 20), 4, "crop", True)
-    video, audio = shifted["samples"].unbind()
-    assert video.shape[2] == 6 and audio.shape[2] == 12
-    assert torch.count_nonzero(audio) == 0
-
-
-def test_the_other_tail_modes_still_keep_the_clip_length(renoise_stubs):
-    """crop is an OPTION — the three refilling modes must be untouched by it."""
-    for mode in ("extend_last", "wrap", "empty"):
-        shifted, _ = _node()._anchor_shift_latent(_av_latent(10, 20), 3, mode, False)
-        video, audio = shifted["samples"].unbind()
-        assert video.shape[2] == 10 and audio.shape[2] == 20, mode
-
-
-# ── the t2v guard ───────────────────────────────────────────────────────────
-
-def test_pinned_frames_counts_the_anchor_prefix():
-    n = _node()
-    frames = 6
-    video = torch.zeros(1, 4, frames, 2, 2)
-    mask = torch.ones(1, 4, frames, 2, 2)
-    mask[:, :, :2] = 0.0  # two pinned anchor frames
-    assert n._anchor_pinned_frames({"samples": video, "noise_mask": mask}) == 2
-
-
-def test_pinned_frames_is_zero_for_a_real_t2v_scene():
-    """No anchor image attached — Easy Gen's default. Shifting would drop real content,
-    so the caller must skip: this is the 'fake t2v' trick and it needs an anchor to fake with."""
-    n = _node()
-    video = torch.zeros(1, 4, 6, 2, 2)
-    assert n._anchor_pinned_frames({"samples": video, "noise_mask": torch.ones(1, 4, 6, 2, 2)}) == 0
-    assert n._anchor_pinned_frames({"samples": video}) == 0  # no mask at all
-    assert n._anchor_pinned_frames({"samples": None}) == 0   # unreadable -> refuse, don't raise
-
-
-# ── the re-noise bug this feature shipped with, locked down ─────────────────
-
-@pytest.fixture
-def capture_sample_custom():
-    """Stub comfy.sample so we can see exactly what noise/latent the sampler receives.
-
-    Snapshot/restore, because these comfy stubs are SHARED module objects across every test
-    module — leaving mutations behind changes other files' results depending on collection
-    order (the same trap test_detailing.py hit with comfy.nested_tensor).
-    """
-    mod = sys.modules["comfy.sample"]
-    comfy_mod = sys.modules["comfy"]
-    saved = (getattr(mod, "prepare_noise", None), getattr(mod, "sample_custom", None),
-             getattr(comfy_mod, "sample", None))
-    seen = {}
-
-    def prepare_noise(samples, seed, *a, **k):
-        return torch.full_like(samples, 7.0)  # unmistakably "fresh noise"
-
-    def sample_custom(model, noise, cfg, sampler, sigmas, pos, neg, latent_image, **kw):
-        seen["noise"] = noise
-        seen["latent_image"] = latent_image
-        return latent_image
-
-    mod.prepare_noise = prepare_noise
-    mod.sample_custom = sample_custom
-    sys.modules["comfy"].sample = mod  # attribute access, not just sys.modules
-    yield seen
-    for name, val in (("prepare_noise", saved[0]), ("sample_custom", saved[1])):
-        if val is None:
-            delattr(mod, name)
-        else:
-            setattr(mod, name, val)
-    if saved[2] is None:
-        delattr(comfy_mod, "sample")
-    else:
-        comfy_mod.sample = saved[2]
-
-
-def _const_noise_scaling(sigma, noise, latent_image):
-    """comfy's CONST rule, verbatim: x = s*noise + (1-s)*latent_image."""
-    return sigma * noise + (1.0 - sigma) * latent_image
-
-
-def test_continue_from_state_makes_const_scaling_an_identity(capture_sample_custom):
-    """The real fix. Pass 2 gets a MID-TRAJECTORY latent; handing it as both terms makes
-    comfy's scaling collapse to x, so sampling resumes exactly where pass 1 stopped."""
-    seen = capture_sample_custom
-    state = torch.randn(1, 4, 5, 2, 2)
-    _node()._sample_chunk(object(), object(), torch.tensor([0.725, 0.422, 0.0]), 1, 1.0,
-                          [], [], {"samples": state}, continue_from_state=True)
-    assert torch.equal(seen["noise"], seen["latent_image"])
-    resumed = _const_noise_scaling(0.725, seen["noise"], seen["latent_image"])
-    assert torch.allclose(resumed, state, atol=1e-6)
-
-
-def test_without_continue_from_state_the_latent_is_renoised(capture_sample_custom):
-    """The other mode, and the shape of the original bug: fresh noise is mixed in and the
-    picture is scaled to (1-sigma). Correct for a CLEAN input, wrong mid-trajectory."""
-    seen = capture_sample_custom
-    clean = torch.randn(1, 4, 5, 2, 2)
-    _node()._sample_chunk(object(), object(), torch.tensor([0.725, 0.422, 0.0]), 1, 1.0,
-                          [], [], {"samples": clean}, continue_from_state=False)
-    assert not torch.equal(seen["noise"], seen["latent_image"])
-    entered = _const_noise_scaling(0.725, seen["noise"], seen["latent_image"])
-    assert not torch.allclose(entered, clean, atol=1e-3)
diff --git a/tests/test_cut_opening.py b/tests/test_cut_opening.py
new file mode 100644
index 00000000..6d997bee
--- /dev/null
+++ b/tests/test_cut_opening.py
@@ -0,0 +1,160 @@
+"""cut_opening_frames — "fake t2v": generate with the real untouched i2v anchor, then cut it.
+
+The point of the feature is that the anchor is NOT weakened on the way in (ALG blurs it and
+loses character detail; Best-FaceID overlap tokens approximate it and lose some too) — it is
+pinned at full strength for the whole schedule and the opening is then cut off the FINISHED
+clip. Nothing is regrown to replace it (regrowing was tried and the invented ending came out
+with worse or missing movement), so the invariants worth testing are:
+
+1. The clip really does get SHORTER — no tail is invented, no joint is blended, and every
+   surviving frame is the original untouched one.
+2. Video and audio still describe the same duration. Audio timing comes from the audio
+   stream's own index, so cropping the two by different amounts desyncs the clip silently.
+3. The pin goes with the frame it belonged to.
+4. The cut can never consume the whole clip, and never mutates its input.
+5. The t2v guard: no pinned anchor means there is nothing to cut out.
+"""
+import sys
+import types
+from pathlib import Path
+
+import pytest
+import torch
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+for _name in (
+    "comfy", "comfy.k_diffusion", "comfy.k_diffusion.sampling",
+    "comfy.model_sampling", "comfy.nested_tensor", "comfy.sample",
+    "comfy.samplers", "comfy.utils",
+):
+    sys.modules.setdefault(_name, types.ModuleType(_name))
+sys.modules["comfy.nested_tensor"].NestedTensor = object
+
+import samplers  # noqa: E402
+
+
+class _FakeNested(list):
+    """Minimal stand-in for comfy's NestedTensor: enough for _is_nested + unbind."""
+    is_nested = True
+
+    def unbind(self):
+        return list(self)
+
+
+@pytest.fixture
+def nested_stub():
+    """Give the module a usable NestedTensor for the packed AV latents.
+
+    Snapshot/restore: these comfy stubs are SHARED module objects across every test module,
+    so leaving mutations behind changes other files' results depending on collection order.
+    """
+    comfy_mod = sys.modules["comfy"]
+    nested_mod = sys.modules["comfy.nested_tensor"]
+    saved = (nested_mod.NestedTensor, getattr(comfy_mod, "nested_tensor", None))
+    nested_mod.NestedTensor = _FakeNested
+    comfy_mod.nested_tensor = nested_mod  # attribute access, not just sys.modules
+    yield
+    nested_mod.NestedTensor = saved[0]
+    if saved[1] is None:
+        delattr(comfy_mod, "nested_tensor")
+    else:
+        comfy_mod.nested_tensor = saved[1]
+
+
+def _node():
+    return samplers.FunPackLTXAVSceneChainSampler()
+
+
+def _latent(frames=10):
+    video = torch.arange(frames, dtype=torch.float32).view(1, 1, frames, 1, 1).repeat(1, 4, 1, 2, 2)
+    return {"samples": video, "noise_mask": torch.zeros_like(video)}
+
+
+def _av_latent(video_frames=10, audio_frames=20):
+    """A packed-style AV latent: video [B,C,F,H,W] + audio [B,C,T] at its own rate."""
+    video = torch.arange(video_frames, dtype=torch.float32).view(
+        1, 1, video_frames, 1, 1).repeat(1, 4, 1, 2, 2)
+    audio = torch.arange(audio_frames, dtype=torch.float32).view(1, 1, audio_frames).repeat(1, 4, 1)
+    return {"samples": _FakeNested([video, audio]), "noise_mask": torch.zeros_like(video)}
+
+
+# ── the cut ─────────────────────────────────────────────────────────────────
+
+def test_cut_shortens_the_clip_instead_of_regrowing_a_tail():
+    cut, dropped = _node()._cut_opening_latent(_latent(frames=10), 3)
+    assert dropped == 3
+    # 10 - 3, not 10: nothing is invented at the end, which is the whole point.
+    assert cut["samples"].shape[2] == 7
+    # And what survives is the ORIGINAL frames 3..9, untouched — no blend, no joint.
+    assert [int(v) for v in cut["samples"][0, 0, :, 0, 0]] == [3, 4, 5, 6, 7, 8, 9]
+
+
+def test_cut_drops_the_pin_with_the_frame_it_belonged_to():
+    latent = _latent(frames=10)
+    assert "noise_mask" in latent
+    cut, _ = _node()._cut_opening_latent(latent, 1)
+    assert "noise_mask" not in cut
+
+
+def test_cut_never_consumes_the_whole_clip():
+    cut, dropped = _node()._cut_opening_latent(_latent(frames=4), 99)
+    assert dropped == 3  # clamped to frames - 1
+    assert cut["samples"].shape[2] == 1
+
+
+def test_zero_drop_is_a_no_op():
+    cut, dropped = _node()._cut_opening_latent(_latent(frames=6), 0)
+    assert dropped == 0
+    assert torch.equal(cut["samples"], _latent(frames=6)["samples"])
+
+
+def test_source_latent_is_never_mutated():
+    latent = _latent(frames=8)
+    before = latent["samples"].clone()
+    _node()._cut_opening_latent(latent, 3)
+    assert torch.equal(latent["samples"], before)
+
+
+# ── audio stays in sync ─────────────────────────────────────────────────────
+
+def test_cut_keeps_audio_and_video_describing_the_same_duration(nested_stub):
+    """Audio timing comes from the audio stream's own index and video's from its own RoPE,
+    so cropping them by different amounts of TIME desyncs the clip silently — no error,
+    just drifting sound. The kept lengths must stay in proportion."""
+    cut, _ = _node()._cut_opening_latent(_av_latent(10, 20), 3)
+    video, audio = cut["samples"].unbind()
+    assert video.shape[2] == 7 and audio.shape[2] == 14      # 7/10 == 14/20
+    # Cropped from the HEAD, matching the video — the tail is what survives.
+    assert [int(v) for v in audio[0, 0]] == list(range(6, 20))
+
+
+def test_cut_keeps_proportion_when_the_rate_does_not_divide_evenly(nested_stub):
+    """The rounding trap: deriving audio's KEPT length from the new video length keeps the
+    two in proportion; subtracting a separately-rounded drop can leave them a frame apart."""
+    for v_frames, a_frames, drop in ((10, 15, 3), (9, 14, 4), (13, 7, 5), (10, 21, 7)):
+        cut, _ = _node()._cut_opening_latent(_av_latent(v_frames, a_frames), drop)
+        video, audio = cut["samples"].unbind()
+        assert audio.shape[2] == max(1, round(a_frames * video.shape[2] / v_frames))
+        assert audio.shape[2] >= 1 and video.shape[2] >= 1
+
+
+# ── the t2v guard ───────────────────────────────────────────────────────────
+
+def test_pinned_frames_counts_the_anchor_prefix():
+    n = _node()
+    frames = 6
+    video = torch.zeros(1, 4, frames, 2, 2)
+    mask = torch.ones(1, 4, frames, 2, 2)
+    mask[:, :, :2] = 0.0  # two pinned anchor frames
+    assert n._anchor_pinned_frames({"samples": video, "noise_mask": mask}) == 2
+
+
+def test_pinned_frames_is_zero_for_a_real_t2v_scene():
+    """No anchor image attached — Easy Gen's default. Cutting would throw away real content,
+    so the caller must skip: this is the 'fake t2v' trick and it needs an anchor to fake with."""
+    n = _node()
+    video = torch.zeros(1, 4, 6, 2, 2)
+    assert n._anchor_pinned_frames({"samples": video, "noise_mask": torch.ones(1, 4, 6, 2, 2)}) == 0
+    assert n._anchor_pinned_frames({"samples": video}) == 0  # no mask at all
+    assert n._anchor_pinned_frames({"samples": None}) == 0   # unreadable -> refuse, don't raise
diff --git a/tests/test_second_pass.py b/tests/test_second_pass.py
index b8d08515..d5f143db 100644
--- a/tests/test_second_pass.py
+++ b/tests/test_second_pass.py
@@ -1,18 +1,16 @@
-"""second_pass — a general two-pass split on the Chain Sampler, independent of anchor_shift.
+"""second_pass — a general two-pass split on the Chain Sampler.
 
-anchor_shift built the machinery (stop the schedule, hand the state over, re-enter exactly);
-this exposes it on its own so a scene can be finished differently from how it was started.
-The invariants that matter here are the ones a split can silently get wrong:
+A scene can be finished differently from how it was started. The invariants that matter
+here are the ones a split can silently get wrong:
 
 1. BOTH schedules run in full, exactly as written. Pass 1 is not cut short and pass 2 is
    not derived from it — total steps are simply the two added up. (An earlier version cut
-   pass 1 at pass 2's first sigma, which is anchor_shift's behaviour and does not belong
-   here; it silently shortened the run and distorted the result.)
+   pass 1 at pass 2's first sigma; it silently shortened the run and distorted the result.)
 2. A hand-typed schedule is the one malformed-able input, and both ways it can be wrong
    are silent in the OUTPUT rather than loud at runtime, so they are refused up front.
 3. Nothing is ever a silent no-op: every refusal comes back with a reason naming the fix.
-4. The i2v anchor stays PINNED for pass 2 — the opposite of anchor_shift, which deletes
-   the pin on purpose. Without this pass 2 re-denoises the reference frame.
+4. The i2v anchor stays PINNED for pass 2 — without this pass 2 re-denoises the reference
+   frame and the scene drifts off the image it was supposed to start from.
 """
 import sys
 import types
@@ -95,13 +93,13 @@ def test_a_schedule_starting_at_zero_is_refused():
 
 def test_the_i2v_anchor_is_re_pinned_for_pass_two():
     """_sample_chunk drops noise_mask from what it returns, so without this pass 2 runs
-    unpinned and re-denoises the reference frame. anchor_shift wants that; this does not."""
+    unpinned and re-denoises the reference frame."""
     frames = 6
     clean = torch.arange(frames, dtype=torch.float32).view(1, 1, frames, 1, 1).repeat(1, 4, 1, 2, 2)
     mask = torch.ones_like(clean)
     mask[:, :, :1] = 0.0                       # one pinned anchor frame
     chunk = {"samples": clean, "noise_mask": mask}
-    # A "state" where the anchor frame has been polluted (as a rewind re-noise would).
+    # A "state" where the anchor frame has been polluted (as pass 2's re-noise would).
     state = {"samples": torch.full_like(clean, -99.0)}
 
     out = _node()._restore_pinned_prefix(state, chunk)

From 7681c599a00c6f83cfa3fd002a35320cde2bd17c Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Fri, 31 Jul 2026 17:57:21 +0300
Subject: [PATCH 26/29] progress: say which scene and which pass is running;
 fix context_window_schedule
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Three things, all about a run telling you what it is doing.

1. The second pass is now visible. ComfyUI's progress channel carries only
   (value, max), so a chain sampling some scenes twice was one anonymous bar.
   The sampler publishes a live label ("scene 2/3 · pass 2 of 2") through the
   new run_phase module; /api/progress hands it to the editor, which appends it
   to the readout, and pass 2 also announces itself on the console the moment it
   starts rather than only in the after-the-fact run report.

   run_phase keeps its state on `sys`, not in module globals: the writer reaches
   it package-relative and the reader imports FunPack modules top-level by name,
   so they can hold different module objects and the label would never arrive.

2. The progress bar total now counts both passes. It only ever counted the main
   schedule, so with a second pass on it overflowed during scene 1 and jumped
   backwards at scene 2, whose offset is a multiple of the per-scene stride.

3. context_windows was unusable. The knob offered "uniform_standard" etc.;
   core's names are the other way round ("standard_uniform"), so every schedule
   except "batched" raised ValueError out of the sampler and FAILED THE RENDER.
   Core's names are the choices now, the old spellings are aliased so saved
   projects keep working, and an unknown name is refused with a reason naming
   what core accepts instead of crashing.

   Same call had a second, quieter break: a keyword core's handler doesn't take
   (latent_retain_index_list is absent on some builds, including this Mac's)
   raised TypeError, which was reported as "ComfyUI core too old" — silently
   switching off a feature core fully supports. Extras are dropped now, with a
   note naming the one knob that stops working.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 movie_editor/backend/bridge.py           |  18 ++-
 movie_editor/frontend/engine_settings.js |   4 +-
 movie_editor/frontend/store.js           |  14 +-
 run_phase.py                             |  59 +++++++++
 samplers.py                              | 161 ++++++++++++++++++-----
 tests/test_context_windows.py            | 129 ++++++++++++++++--
 tests/test_run_phase.py                  |  52 ++++++++
 tests/test_scene_chain_sampler.py        | 115 +++++++++++++++-
 8 files changed, 501 insertions(+), 51 deletions(-)
 create mode 100644 run_phase.py
 create mode 100644 tests/test_run_phase.py

diff --git a/movie_editor/backend/bridge.py b/movie_editor/backend/bridge.py
index 6c2f342b..1036d1af 100644
--- a/movie_editor/backend/bridge.py
+++ b/movie_editor/backend/bridge.py
@@ -658,8 +658,24 @@ def reset_progress() -> None:
 
 
 def current_progress() -> dict:
+    """Sampler step counter, plus what the Chain Sampler says it is doing right now.
+
+    ComfyUI's progress channel is numbers only, so a chain that samples several scenes —
+    some of them twice, with a second pass — is one anonymous bar. The sampler publishes a
+    short phase label ("scene 2/3 · pass 2 of 2") that rides along here. Absent (an older
+    sampler, a non-FunPack job) it is simply an empty string and the UI shows the numbers
+    alone, exactly as before.
+    """
     _install_progress_hook()
-    return {"value": _progress["value"], "max": _progress["max"]}
+    label = ""
+    try:
+        # Top-level by name (never a relative import past this package — see
+        # _ensure_funpack_path). run_phase keeps its state on `sys` precisely so it does not
+        # matter whether the sampler's copy and this one are the same module object.
+        label = _funpack_attr("run_phase", "current")().get("label") or ""
+    except Exception:  # noqa: BLE001 — a readout must never break the progress poll
+        pass
+    return {"value": _progress["value"], "max": _progress["max"], "label": label}
 
 
 async def is_running(prompt_id: str) -> bool:
diff --git a/movie_editor/frontend/engine_settings.js b/movie_editor/frontend/engine_settings.js
index b12e0005..6caee4fb 100644
--- a/movie_editor/frontend/engine_settings.js
+++ b/movie_editor/frontend/engine_settings.js
@@ -236,8 +236,8 @@
       hint: "Window size in real frames. A scene at or below this length skips windowing entirely, so this doubles as the engage threshold. Keep it at or under the length the model already generates well in one pass — the point is to stay inside that range while the scene as a whole goes past it." },
     { name: "context_window_overlap", label: "Window overlap (frames)", kind: "int", default: 40, min: 0, max: 512, step: 8, dependsOn: "context_windows",
       hint: "How many frames consecutive windows share. This is the only thing carrying motion and appearance across a window boundary, and also the only extra compute this costs. Too low shows as a seam or a motion hitch at the boundary; too high pays for frames you already have." },
-    { name: "context_window_schedule", label: "Window schedule", kind: "combo", choices: ["uniform_standard", "static_standard", "uniform_looped", "batched"], default: "uniform_standard", dependsOn: "context_windows",
-      hint: "How windows are laid out each step. 'uniform_standard' (default) shifts the grid between steps so boundaries never bake in — safest. 'static_standard' keeps fixed cut points (cheapest, but a bad boundary stays bad). 'uniform_looped' wraps the end into the start for looping content. 'batched' uses disjoint chunks with no overlap logic (fastest, weakest continuity)." },
+    { name: "context_window_schedule", label: "Window schedule", kind: "combo", choices: ["standard_uniform", "standard_static", "looped_uniform", "batched"], default: "standard_uniform", dependsOn: "context_windows",
+      hint: "How windows are laid out each step (ComfyUI core's own schedule names). 'standard_uniform' (default) shifts the grid between steps so boundaries never bake in — safest. 'standard_static' keeps fixed cut points (cheapest, but a bad boundary stays bad). 'looped_uniform' wraps the end into the start for looping content. 'batched' uses disjoint chunks with no overlap logic (fastest, weakest continuity)." },
     { name: "context_window_fuse", label: "Window blend", kind: "combo", choices: ["pyramid", "relative", "flat", "overlap-linear"], default: "pyramid", dependsOn: "context_windows",
       hint: "How overlapping windows are weighted when merged. 'pyramid' (default) fades each window toward its edges so seams go soft. 'flat' averages equally (can smear). Change this if boundaries look ghosted rather than merely misaligned." },
     { name: "context_window_freenoise", label: "FreeNoise blending", kind: "bool", default: true, dependsOn: "context_windows",
diff --git a/movie_editor/frontend/store.js b/movie_editor/frontend/store.js
index c003a954..dc8da836 100644
--- a/movie_editor/frontend/store.js
+++ b/movie_editor/frontend/store.js
@@ -3211,17 +3211,22 @@
       _clearGenTimers();
       let pendingStreak = 0;
       let transientStreak = 0;
-      // Faster step-progress poll (sampler current/total steps).
+      // Faster step-progress poll (sampler current/total steps, plus what it says it's
+      // doing — "scene 2/3 · pass 2 of 2"). The message is rebuilt from prefix + elapsed
+      // the same way the slower poll below builds it, rather than regex-stripping the last
+      // one off the end: a suffix the strip pattern doesn't know about (the phase label)
+      // would otherwise be re-appended every tick and grow without limit.
       progressTimer = setInterval(async () => {
         if (_interrupted) return;
         try {
           const pr = await API.progress();
           if (pr && pr.max > 0) {
-            const head = (state.gen.msg || prefix).replace(/\s*·\s*sampling \d+\/\d+$/, "");
+            const phase = pr.label ? `  ·  ${pr.label}` : "";
             updateGenProgress({
               step: pr.value,
               maxStep: pr.max,
-              msg: `${head}  ·  sampling ${pr.value}/${pr.max}`,
+              phase: pr.label || "",
+              msg: `${prefix} ${_elapsed()}  ·  sampling ${pr.value}/${pr.max}${phase}`,
             });
           }
         } catch (_) {}
@@ -3257,7 +3262,8 @@
               return;
             }
             const step = (state.gen.maxStep > 0) ? `  ·  sampling ${state.gen.step}/${state.gen.maxStep}` : "";
-            updateGenProgress({ state: s.state, msg: `${prefix} ${_elapsed()}${step}` });
+            const phase = state.gen.phase ? `  ·  ${state.gen.phase}` : "";
+            updateGenProgress({ state: s.state, msg: `${prefix} ${_elapsed()}${step}${phase}` });
           }
         } catch (e) {
           if (_isTransientTunnelError(e)) {
diff --git a/run_phase.py b/run_phase.py
new file mode 100644
index 00000000..40ef0b56
--- /dev/null
+++ b/run_phase.py
@@ -0,0 +1,59 @@
+"""What the sampler is doing RIGHT NOW, as a short label a UI can poll.
+
+ComfyUI's progress channel carries only (value, max) — no text — so a chain that samples
+several scenes, some of them twice, reads as one undifferentiated bar: you can watch the
+number climb without knowing which scene it belongs to or whether the second pass has
+started. The Chain Sampler publishes a label here as it moves through the run, and the
+Movie Editor's ``/api/progress`` hands it to the UI alongside the numbers.
+
+**The state lives on `sys`, not in this module's globals, and that is load-bearing.** The
+writer (samplers.py) reaches this file as a package-relative import, so it gets
+``ComfyUI-FunPack.run_phase``; the reader (movie_editor/backend/bridge.py) imports FunPack
+modules top-level by name after putting the root on sys.path, so it would get a SECOND,
+separate ``run_phase`` module object — two copies, two sets of globals, and a label that
+never arrives. Hanging the dict off ``sys`` (unambiguously one object per process) makes
+both import paths share it. Stateless helpers like `conditioning` do not care which copy
+they are; anything holding mutable state across that boundary does.
+
+Everything here is BEST-EFFORT and never affects sampling: it is a live readout, not state
+anything is derived from. Nothing reads it back to make a decision, so a label left over
+from a crashed run is cosmetic — the next run overwrites it and ``clear()`` empties it —
+and it is not the kind of cross-request cache that would violate "the UI is the only source
+of truth".
+"""
+import sys
+
+_SYS_KEY = "_funpack_run_phase"
+
+
+def _state() -> dict:
+    st = getattr(sys, _SYS_KEY, None)
+    if not isinstance(st, dict):
+        st = {"label": "", "seq": 0}
+        setattr(sys, _SYS_KEY, st)
+    return st
+
+
+def set_phase(label: str) -> None:
+    """Publish the current phase, e.g. "scene 2/3 · pass 2 of 2"."""
+    try:
+        st = _state()
+        st["label"] = str(label or "")
+        st["seq"] += 1
+    except Exception:  # noqa: BLE001 — a readout must never break a render
+        pass
+
+
+def clear() -> None:
+    """Nothing is sampling. Call from a finally, so an interrupt doesn't leave a label up."""
+    set_phase("")
+
+
+def current() -> dict:
+    """{"label": str, "seq": int}. `seq` only ever increases, so a poller can tell "still
+    the same phase" from "this phase came round again"."""
+    try:
+        st = _state()
+        return {"label": st["label"], "seq": st["seq"]}
+    except Exception:  # noqa: BLE001
+        return {"label": "", "seq": 0}
diff --git a/samplers.py b/samplers.py
index df9a9b77..902a8ec8 100644
--- a/samplers.py
+++ b/samplers.py
@@ -2501,9 +2501,9 @@ class FunPackLTXAVSceneChainSampler:
                     "default": 40, "min": 0, "max": 512, "step": 8,
                     "tooltip": "How many real frames consecutive windows share. This is the ONLY thing carrying motion/appearance continuity across a window boundary, and it is also the only extra compute this feature costs (overlap/length = the redundant fraction). Too low and boundaries show as a seam or a motion hitch; too high and you pay for frames you already have.",
                 }),
-                "context_window_schedule": (["uniform_standard", "static_standard", "uniform_looped", "batched"], {
-                    "default": "uniform_standard",
-                    "tooltip": "How the windows are laid out across the scene, per step. 'uniform_standard' (default, core's own LTXV default) shifts the window grid between steps so boundaries land in different places each step and never bake in — the safest general choice. 'static_standard' keeps the same fixed cut points every step (cheapest, but a bad boundary stays bad). 'uniform_looped' wraps the last window into the first, for seamless looping content. 'batched' denoises disjoint chunks with no overlap logic (fastest, weakest continuity).",
+                "context_window_schedule": (["standard_uniform", "standard_static", "looped_uniform", "batched"], {
+                    "default": "standard_uniform",
+                    "tooltip": "How the windows are laid out across the scene, per step. These are ComfyUI core's own schedule names (comfy.context_windows). 'standard_uniform' (default, core's own LTXV default) shifts the window grid between steps so boundaries land in different places each step and never bake in — the safest general choice. 'standard_static' keeps the same fixed cut points every step (cheapest, but a bad boundary stays bad). 'looped_uniform' wraps the last window into the first, for seamless looping content. 'batched' denoises disjoint chunks with no overlap logic (fastest, weakest continuity). Projects saved with the old reversed spellings (uniform_standard / static_standard / uniform_looped) are still accepted and mapped onto these.",
                 }),
                 "context_window_fuse": (["pyramid", "relative", "flat", "overlap-linear"], {
                     "default": "pyramid",
@@ -2947,6 +2947,23 @@ class FunPackLTXAVSceneChainSampler:
         result.pop("noise_mask", None)
         return result
 
+    def _set_phase(self, label):
+        """Publish what is running right now for the editor's progress readout.
+
+        The ComfyUI progress channel is (value, max) only, so without this a multi-scene
+        chain — especially one sampling some scenes twice — is a single anonymous bar.
+        Best-effort in every direction: a missing module or a failed write must never
+        affect the render.
+        """
+        try:
+            try:
+                from . import run_phase as _rp
+            except ImportError:  # loaded as a top-level module (tests, direct import)
+                import run_phase as _rp
+            _rp.set_phase(label)
+        except Exception:  # noqa: BLE001
+            pass
+
     def _sample_chunk(self, model, sampler, sigmas, seed, cfg, positive, negative, latent,
                       pbar=None, step_offset=0, alg_guide_tail_frames=0,
                       alg_guide_blur_strength=2.0, alg_guide_blur_sigma_threshold=0.975,
@@ -4553,6 +4570,18 @@ class FunPackLTXAVSceneChainSampler:
     # Wrapper keys used by context windows; core registers them under these names.
     _CTX_WRAPPER_KEYS = ("ContextWindows_prepare_sampling", "ContextWindows_sampler_sample")
 
+    # Core's schedule identifiers put the words the other way round (comfy.context_windows
+    # ContextSchedules: "standard_uniform", "standard_static", "looped_uniform", "batched").
+    # This knob shipped with the readable-but-wrong spellings, so every schedule except
+    # "batched" raised ValueError out of get_matching_context_schedule and failed the whole
+    # render. The knob now offers core's own names; these aliases keep a project saved with
+    # the old ones working instead of failing at generation time.
+    _CTX_SCHEDULE_ALIASES = {
+        "uniform_standard": "standard_uniform",
+        "static_standard": "standard_static",
+        "uniform_looped": "looped_uniform",
+    }
+
     def _install_context_windows(self, model, length, overlap, schedule, fuse,
                                  freenoise, retain_first):
         """Hand this scene's denoise to ComfyUI core's context-window sampler.
@@ -4563,8 +4592,12 @@ class FunPackLTXAVSceneChainSampler:
         which every FunPack sampler already goes through (they all call model(x, sigma, ...)
         on the CFGGuider rather than apply_model directly), so no sampler change is needed.
 
-        Returns (remove_fn, latent_len) or None when the running ComfyUI core predates LTXAV
-        window support. That capability gate is the important part: the handler class itself
+        Returns (remove_fn, latent_len, None), or (None, None, reason) when it cannot run.
+        Everything that can go wrong here is a mismatch with the installed core, and every
+        one of them used to surface as either the wrong explanation or a failed render, so
+        the reason is carried back and reported per scene rather than inferred.
+
+        The capability gate below is the important part: the handler class itself
         has existed for a long time for unpacked video, but the packed AV latent needs
         BaseModel.map_context_window_to_modalities (+ resize_cond_for_context_window) to
         unpack the AV stream, map each video window onto its audio window and re-slice
@@ -4576,30 +4609,63 @@ class FunPackLTXAVSceneChainSampler:
             import comfy.context_windows as _cw
             import comfy.patcher_extension as _pe
         except ImportError:
-            return None
+            return None, None, ("this ComfyUI build has no context-window support at all "
+                                "(needs ComfyUI >= v0.29.0)")
         base = getattr(model, "model", None)
         if not hasattr(base, "map_context_window_to_modalities"):
-            return None
+            return None, None, ("this ComfyUI build has no LTXAV context-window support "
+                                "(needs the core context-windows change, ComfyUI >= v0.29.0)")
         # Real frames -> latent frames, exactly as core's LTXVContextWindows node does it.
         latent_len = max(((int(length) - 1) // 8) + 1, 1)
         latent_overlap = max(int(overlap) // 8, 0)
         retain = "0" if retain_first else ""
+        # Resolve the names against CORE's vocabulary, not ours, and say what it accepts —
+        # these raise ValueError, which used to escape and fail the render outright.
+        _sched_name = self._CTX_SCHEDULE_ALIASES.get(str(schedule), str(schedule))
         try:
-            handler = _cw.IndexListContextHandler(
-                context_schedule=_cw.get_matching_context_schedule(schedule),
-                fuse_method=_cw.get_matching_fuse_method(fuse),
-                context_length=latent_len,
-                context_overlap=latent_overlap,
-                context_stride=1,
-                closed_loop=False,
-                dim=2,
-                freenoise=bool(freenoise),
-                cond_retain_index_list=retain,
-                latent_retain_index_list=retain,
-                split_conds_to_windows=False,
-            )
-        except TypeError:
-            return None  # signature drifted from the one this was written against
+            _schedule = _cw.get_matching_context_schedule(_sched_name)
+        except ValueError:
+            _known = ", ".join(sorted(getattr(_cw, "CONTEXT_MAPPING", {}) or {}))
+            return None, None, (f"context_window_schedule={schedule!r} is not a schedule this "
+                                f"ComfyUI knows{f' — it accepts {_known}' if _known else ''}")
+        try:
+            _fuse = _cw.get_matching_fuse_method(str(fuse))
+        except ValueError:
+            _known = ", ".join(sorted(getattr(_cw, "FUSE_MAPPING", {}) or {}))
+            return None, None, (f"context_window_fuse={fuse!r} is not a blend this ComfyUI "
+                                f"knows{f' — it accepts {_known}' if _known else ''}")
+        kwargs = dict(
+            context_schedule=_schedule,
+            fuse_method=_fuse,
+            context_length=latent_len,
+            context_overlap=latent_overlap,
+            context_stride=1,
+            closed_loop=False,
+            dim=2,
+            freenoise=bool(freenoise),
+            cond_retain_index_list=retain,
+            latent_retain_index_list=retain,
+            split_conds_to_windows=False,
+        )
+        # Core's handler has gained and lost keywords over time (latent_retain_index_list is
+        # absent on some builds). Passing one it doesn't take raised TypeError and the whole
+        # feature was then reported as "core too old", which is a different and misleading
+        # thing. Drop the extras instead, and name the one knob that stops working.
+        _dropped = []
+        try:
+            import inspect as _inspect
+            _accepted = set(_inspect.signature(_cw.IndexListContextHandler).parameters)
+            if "kwargs" not in _accepted:
+                _dropped = [k for k in kwargs if k not in _accepted]
+                for k in _dropped:
+                    kwargs.pop(k)
+        except (TypeError, ValueError):
+            pass
+        try:
+            handler = _cw.IndexListContextHandler(**kwargs)
+        except TypeError as exc:
+            return None, None, (f"this ComfyUI's context-window handler takes different "
+                                f"arguments than expected ({exc})")
         prev = model.model_options.get("context_handler")
         had_prev = "context_handler" in model.model_options
         model.model_options["context_handler"] = handler
@@ -4621,7 +4687,11 @@ class FunPackLTXAVSceneChainSampler:
                 except Exception:
                     pass
 
-        return _remove, latent_len
+        _note = None
+        if retain_first and "latent_retain_index_list" in _dropped:
+            _note = ("this ComfyUI's context-window handler has no latent_retain_index_list, "
+                     "so 'pin anchor in every window' applies to conditioning only")
+        return _remove, latent_len, _note
 
     def _build_plateau_cache_wrapper(self, model, threshold):
         """Plateau step-cache (MixCache/Chorus-family, adapted to LTX2.3's distilled schedule).
@@ -5039,7 +5109,7 @@ class FunPackLTXAVSceneChainSampler:
                detail_upsampler="None", detail_strength=1.0, detail_threshold=0.35,
                detail_max_area=0.35, detail_denoise=0.85, detail_mode="repair",
                context_windows=False, context_window_length=145, context_window_overlap=40,
-               context_window_schedule="uniform_standard", context_window_fuse="pyramid",
+               context_window_schedule="standard_uniform", context_window_fuse="pyramid",
                context_window_freenoise=True, context_window_retain_first=False,
                cut_opening_frames=0,
                second_pass=False, second_pass_op="none", second_pass_sigmas=None,
@@ -5223,7 +5293,17 @@ class FunPackLTXAVSceneChainSampler:
         if first_scene_seed is None:
             first_scene_seed = int(seed)
 
-        steps_per_scene = max(1, int(len(sigmas)) - 1)
+        # A second pass samples every scene twice, so its steps have to be in the total or
+        # the bar overflows on scene 1 and jumps backwards on scene 2 (each scene's offset
+        # is a multiple of steps_per_scene). The pass-2 schedule is one node input shared by
+        # every scene, so it can be measured once here — and validated the same way the loop
+        # will, so an unusable schedule doesn't inflate the total for a pass that gets skipped.
+        _pass2_steps = 0
+        if second_pass:
+            _sp_probe, _ = self._second_pass_schedule(second_pass_sigmas)
+            if _sp_probe is not None:
+                _pass2_steps = max(0, int(_sp_probe.numel()) - 1)
+        steps_per_scene = max(1, (int(len(sigmas)) - 1) + _pass2_steps)
         total_sampling_steps = scene_count * steps_per_scene
         pbar = None
         try:
@@ -5367,19 +5447,21 @@ class FunPackLTXAVSceneChainSampler:
                 # Context windows: core-owned, installed first so every FunPack wrapper below
                 # sits inside the per-window forward rather than around the whole clip.
                 if context_windows:
-                    _ctx = self._install_context_windows(
+                    _ctx_remove, _ctx_latent_len, _ctx_reason = self._install_context_windows(
                         model, context_window_length, context_window_overlap,
                         context_window_schedule, context_window_fuse,
                         context_window_freenoise, context_window_retain_first)
-                    if _ctx is None:
+                    if _ctx_remove is None:
+                        # Every reason here is a mismatch with the installed core, so it is
+                        # the same for every scene — print it once, report it on each.
                         if not _ctx_unsupported_reported:
-                            print("[FunPackSceneChain] context_windows requested but this ComfyUI "
-                                  "build has no LTXAV context-window support (needs the CORE-3 "
-                                  "context-windows change, ComfyUI >= v0.29.0) — skipped.")
+                            print(f"[FunPackSceneChain] context_windows requested but "
+                                  f"{_ctx_reason} — skipped.")
                             _ctx_unsupported_reported = True
-                        run_mechanisms.append("context_windows(SKIPPED: ComfyUI core too old)")
+                        run_mechanisms.append(f"context_windows(SKIPPED: {_ctx_reason})")
                     else:
-                        _ctx_remove, _ctx_latent_len = _ctx
+                        if _ctx_reason:
+                            run_mechanisms.append(f"context_windows NOTE: {_ctx_reason}")
                         # Core engages windowing only when the scene is longer than the window,
                         # and logs that decision itself; say so here too so a scene that silently
                         # sampled whole doesn't read as the feature being broken.
@@ -5568,6 +5650,10 @@ class FunPackLTXAVSceneChainSampler:
                     _sp_b, _sp_reason = self._second_pass_schedule(second_pass_sigmas)
                     if _sp_b is None:
                         run_mechanisms.append(f"second_pass(SKIPPED: {_sp_reason})")
+                _scene_label = (f"scene {scene_index + 1}/{scene_count}"
+                                if scene_count > 1 else "")
+                self._set_phase(f"{_scene_label}{' · ' if _scene_label else ''}"
+                                f"{'pass 1 of 2' if _sp_b is not None else 'sampling'}")
                 _full = self._sample_chunk(
                     model, sampler, sigmas, scene_seed, cfg, scene_positive,
                     scene_negative, chunk, **_sample_kwargs)
@@ -5611,6 +5697,12 @@ class FunPackLTXAVSceneChainSampler:
                             "unpinned and may drift from the reference image.")
                     _sp_kw = dict(_sample_kwargs)
                     _sp_kw["step_offset"] = _sample_kwargs["step_offset"] + (int(sigmas.numel()) - 1)
+                    # Announced BEFORE it runs: the after-the-fact run_mechanisms line says
+                    # a second pass happened, which is no help while you are waiting on one.
+                    self._set_phase(f"{_scene_label}{' · ' if _scene_label else ''}pass 2 of 2")
+                    print(f"[FunPack AV] second pass starting"
+                          f"{' on ' + _scene_label if _scene_label else ''}: "
+                          f"{int(_sp_b.numel()) - 1} steps from sigma {float(_sp_b[0].item()):g}")
                     sampled = self._sample_chunk(
                         model, sampler, _sp_b, scene_seed + 4242, cfg, scene_positive,
                         scene_negative, _sp_state, **_sp_kw)
@@ -5628,6 +5720,9 @@ class FunPackLTXAVSceneChainSampler:
                         run_mechanisms.append(
                             f"plateau_cache(skipped {_reused}/{_total} plateau fwd, thr={plateau_cache_threshold})")
             finally:
+                # Nothing is sampling once this scene is out of the sampler — including on an
+                # interrupt, which is exactly when a stale "pass 2 of 2" would linger.
+                self._set_phase("")
                 if _ctx_remove is not None:
                     _ctx_remove()
                 self._remove_v2a_scale(_v2a_handles)
@@ -5972,7 +6067,7 @@ class FunPackLTXAVSceneChainSampler:
                             alg_guide_blur_strength=2.0, alg_guide_blur_sigma_threshold=0.975,
                             plateau_cache=False, plateau_cache_threshold=0.975,
                             context_windows=False, context_window_length=145,
-                            context_window_overlap=40, context_window_schedule="uniform_standard",
+                            context_window_overlap=40, context_window_schedule="standard_uniform",
                             context_window_fuse="pyramid", context_window_freenoise=True,
                             context_window_retain_first=False,
                             cut_opening_frames=0,
diff --git a/tests/test_context_windows.py b/tests/test_context_windows.py
index d979dffb..af70496f 100644
--- a/tests/test_context_windows.py
+++ b/tests/test_context_windows.py
@@ -11,6 +11,18 @@ core's windowing math. What IS ours, and what these cover:
 3. Install/remove leaves the shared model exactly as found, including on an interrupt
    mid-scene — the same guarantee _strip_funpack_scene_wrappers gives the function
    wrappers, but for patcher wrappers and the context_handler model_option.
+4. The NAMES are core's, not ours. The knob shipped with readable-but-wrong spellings
+   ("uniform_standard"); core calls them the other way round ("standard_uniform"), so
+   every schedule except "batched" raised ValueError out of the sampler and failed the
+   whole render. Core's names are the choices now, the old ones are aliased, and an
+   unknown one is refused with a reason naming what core does accept.
+5. A keyword this core does not take is DROPPED, not fatal. latent_retain_index_list is
+   absent on some builds; passing it raised TypeError, which was reported as "ComfyUI
+   core too old" — so a core that fully supports windowing had the feature silently
+   switched off. Install anyway and name the knob that stops working.
+
+Install returns (remove_fn, latent_len, note) or (None, None, reason): every failure here
+is a mismatch with the installed core, and reporting the WRONG one is how (5) hid.
 """
 import sys
 import types
@@ -52,8 +64,24 @@ def _install_fake_core(monkeypatch, ltxav_support=True, accept_latent_retain=Tru
         return _Handler(**kwargs)
 
     cw.IndexListContextHandler = _handler
-    cw.get_matching_context_schedule = lambda s: f"sched:{s}"
-    cw.get_matching_fuse_method = lambda f: f"fuse:{f}"
+    # Core's real vocabulary (comfy.context_windows ContextSchedules / ContextFuseMethods),
+    # and core's real behaviour on anything else: ValueError.
+    cw.CONTEXT_MAPPING = dict.fromkeys(
+        ["standard_uniform", "standard_static", "looped_uniform", "batched"], object())
+    cw.FUSE_MAPPING = dict.fromkeys(["pyramid", "relative", "flat", "overlap-linear"], object())
+
+    def _sched(name):
+        if name not in cw.CONTEXT_MAPPING:
+            raise ValueError(f"Unknown context_schedule '{name}'.")
+        return f"sched:{name}"
+
+    def _fuse_of(name):
+        if name not in cw.FUSE_MAPPING:
+            raise ValueError(f"Unknown fuse_method '{name}'.")
+        return f"fuse:{name}"
+
+    cw.get_matching_context_schedule = _sched
+    cw.get_matching_fuse_method = _fuse_of
 
     def _prep(model):
         calls["prepare"] += 1
@@ -93,23 +121,27 @@ def _install(sampler, model, **overrides):
 def test_refuses_on_core_without_ltxav_window_support(monkeypatch):
     model, calls = _install_fake_core(monkeypatch, ltxav_support=False)
     s = samplers.FunPackLTXAVSceneChainSampler()
-    assert _install(s, model) is None
+    remove, _, reason = _install(s, model)
+    assert remove is None and "LTXAV context-window support" in reason
     # Nothing installed: a refusal must not half-configure the shared model.
     assert "context_handler" not in model.model_options
     assert calls["prepare"] == 0 and calls["sampler_sample"] == 0
 
 
-def test_refuses_when_handler_signature_drifted(monkeypatch):
+def test_refuses_when_the_handler_rejects_an_argument_outright(monkeypatch):
+    """A TypeError we could not see coming from the signature. Still a refusal — but one
+    that reports the argument mismatch instead of blaming the core version."""
     model, calls = _install_fake_core(monkeypatch, accept_latent_retain=False)
     s = samplers.FunPackLTXAVSceneChainSampler()
-    assert _install(s, model) is None
+    remove, _, reason = _install(s, model)
+    assert remove is None and "different" in reason
     assert "context_handler" not in model.model_options
 
 
 def test_real_frames_convert_to_latent_frames_like_core_node(monkeypatch):
     model, _ = _install_fake_core(monkeypatch)
     s = samplers.FunPackLTXAVSceneChainSampler()
-    remove, latent_len = _install(s, model, length=145, overlap=40)
+    remove, latent_len, _ = _install(s, model, length=145, overlap=40)
     # Core's LTXVContextWindows: ((145 - 1) // 8) + 1 = 19, 40 // 8 = 5.
     assert latent_len == 19
     handler = model.model_options["context_handler"]
@@ -122,7 +154,7 @@ def test_real_frames_convert_to_latent_frames_like_core_node(monkeypatch):
 def test_retain_first_sets_both_cond_and_latent_retain(monkeypatch):
     model, _ = _install_fake_core(monkeypatch)
     s = samplers.FunPackLTXAVSceneChainSampler()
-    remove, _ = _install(s, model, retain_first=True)
+    remove, _, _ = _install(s, model, retain_first=True)
     handler = model.model_options["context_handler"]
     # i2v anchors live in the noise latent, not only in conditioning channels, so both
     # lists must be set — cond alone would drop the anchor from later windows.
@@ -134,7 +166,7 @@ def test_retain_first_sets_both_cond_and_latent_retain(monkeypatch):
 def test_freenoise_off_skips_the_sampler_sample_wrapper(monkeypatch):
     model, calls = _install_fake_core(monkeypatch)
     s = samplers.FunPackLTXAVSceneChainSampler()
-    remove, _ = _install(s, model, freenoise=False)
+    remove, _, _ = _install(s, model, freenoise=False)
     assert calls["prepare"] == 1
     assert calls["sampler_sample"] == 0
     remove()
@@ -143,7 +175,7 @@ def test_freenoise_off_skips_the_sampler_sample_wrapper(monkeypatch):
 def test_remove_restores_model_options_and_drops_both_wrappers(monkeypatch):
     model, calls = _install_fake_core(monkeypatch)
     s = samplers.FunPackLTXAVSceneChainSampler()
-    remove, _ = _install(s, model)
+    remove, _, _ = _install(s, model)
     assert "context_handler" in model.model_options
     remove()
     assert "context_handler" not in model.model_options
@@ -159,7 +191,7 @@ def test_remove_restores_a_pre_existing_foreign_handler(monkeypatch):
     foreign = object()
     model.model_options["context_handler"] = foreign
     s = samplers.FunPackLTXAVSceneChainSampler()
-    remove, _ = _install(s, model)
+    remove, _, _ = _install(s, model)
     assert model.model_options["context_handler"] is not foreign
     remove()
     assert model.model_options["context_handler"] is foreign
@@ -172,3 +204,80 @@ def test_scene_latent_frame_count_reads_the_video_stream():
     # Unreadable latent reports None rather than raising: this value is only ever used
     # for the scene report, never for control flow.
     assert s._context_scene_latent_frames({"samples": None}) is None
+
+
+# ── the names are core's, not ours ──────────────────────────────────────────
+
+def test_every_schedule_the_node_offers_is_one_core_knows(monkeypatch):
+    """The bug in one line: the node offered spellings core has never had, so choosing any
+    of them raised ValueError out of the sampler and killed the render."""
+    model, _ = _install_fake_core(monkeypatch)
+    s = samplers.FunPackLTXAVSceneChainSampler()
+    offered = s.INPUT_TYPES()["optional"]["context_window_schedule"][0]
+    assert set(offered) <= set(sys.modules["comfy.context_windows"].CONTEXT_MAPPING)
+    for name in offered:
+        model, _ = _install_fake_core(monkeypatch)
+        assert _install(s, model, schedule=name)[0] is not None, name
+
+
+def test_the_old_reversed_spellings_still_resolve(monkeypatch):
+    """A project saved before the names were corrected must keep generating, not fail."""
+    s = samplers.FunPackLTXAVSceneChainSampler()
+    for old, new in (("uniform_standard", "standard_uniform"),
+                     ("static_standard", "standard_static"),
+                     ("uniform_looped", "looped_uniform")):
+        model, _ = _install_fake_core(monkeypatch)
+        remove, _, reason = _install(s, model, schedule=old)
+        assert remove is not None, (old, reason)
+        assert model.model_options["context_handler"].kwargs["context_schedule"] == f"sched:{new}"
+
+
+def test_an_unknown_schedule_is_refused_with_what_core_accepts(monkeypatch):
+    model, calls = _install_fake_core(monkeypatch)
+    s = samplers.FunPackLTXAVSceneChainSampler()
+    remove, _, reason = _install(s, model, schedule="nonsense")
+    assert remove is None
+    assert "nonsense" in reason and "standard_uniform" in reason
+    # A refusal must not half-configure the shared model.
+    assert "context_handler" not in model.model_options
+    assert calls["prepare"] == 0
+
+
+def test_an_unknown_fuse_method_is_refused_with_what_core_accepts(monkeypatch):
+    model, _ = _install_fake_core(monkeypatch)
+    s = samplers.FunPackLTXAVSceneChainSampler()
+    remove, _, reason = _install(s, model, fuse="wobble")
+    assert remove is None
+    assert "wobble" in reason and "overlap-linear" in reason
+
+
+# ── a keyword this core does not take ───────────────────────────────────────
+
+class _NoLatentRetainHandler:
+    """The shape of the build that reported itself as 'core too old': core's handler minus
+    latent_retain_index_list, declared in the signature so it can be seen before calling."""
+    def __init__(self, context_schedule, fuse_method, context_length=1, context_overlap=0,
+                 context_stride=1, closed_loop=False, dim=0, freenoise=False,
+                 cond_retain_index_list=(), split_conds_to_windows=False):
+        self.kwargs = dict(context_schedule=context_schedule, context_length=context_length,
+                           cond_retain_index_list=cond_retain_index_list)
+
+
+def test_an_unsupported_keyword_is_dropped_and_windowing_still_runs(monkeypatch):
+    model, calls = _install_fake_core(monkeypatch)
+    sys.modules["comfy.context_windows"].IndexListContextHandler = _NoLatentRetainHandler
+    s = samplers.FunPackLTXAVSceneChainSampler()
+    remove, latent_len, note = _install(s, model, retain_first=True)
+    assert remove is not None and latent_len == 19
+    assert calls["prepare"] == 1
+    # The one knob that really does stop working is named, not swallowed.
+    assert "latent_retain_index_list" in note
+    remove()
+
+
+def test_no_note_when_retain_first_is_off(monkeypatch):
+    """Nothing was lost, so nothing to report — a note here would be noise on every scene."""
+    model, _ = _install_fake_core(monkeypatch)
+    sys.modules["comfy.context_windows"].IndexListContextHandler = _NoLatentRetainHandler
+    s = samplers.FunPackLTXAVSceneChainSampler()
+    assert _install(s, model, retain_first=False)[2] is None
diff --git a/tests/test_run_phase.py b/tests/test_run_phase.py
new file mode 100644
index 00000000..721f6b6e
--- /dev/null
+++ b/tests/test_run_phase.py
@@ -0,0 +1,52 @@
+"""run_phase — the live "what is the sampler doing" label behind the progress readout.
+
+The one invariant that actually breaks in production: the WRITER (samplers.py) reaches this
+module as a package-relative import and the READER (movie_editor's bridge) imports FunPack
+modules top-level by name, so the two can hold different module objects. State in module
+globals would be two separate copies and the label would never arrive. It lives on `sys`
+for exactly that reason, and this pins it down.
+"""
+import importlib.util
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(ROOT))
+
+import run_phase  # noqa: E402
+
+
+def _second_import():
+    """A second, independent module object for the same file — what the other import path
+    produces at runtime."""
+    spec = importlib.util.spec_from_file_location("other_pkg.run_phase", ROOT / "run_phase.py")
+    mod = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(mod)
+    return mod
+
+
+def test_both_import_paths_see_the_same_label():
+    other = _second_import()
+    run_phase.set_phase("scene 2/3 · pass 2 of 2")
+    assert other.current()["label"] == "scene 2/3 · pass 2 of 2"
+    other.clear()
+    assert run_phase.current()["label"] == ""
+
+
+def test_seq_only_ever_increases():
+    """A poller uses it to tell "still the same phase" from "this phase came round again",
+    so it must never reset — not even when the label is cleared."""
+    before = run_phase.current()["seq"]
+    run_phase.set_phase("a")
+    run_phase.set_phase("a")
+    run_phase.clear()
+    assert run_phase.current()["seq"] == before + 3
+
+
+def test_a_bad_label_never_raises():
+    """This is a readout on the sampling path: it must not be able to fail a render."""
+    run_phase.set_phase(None)
+    assert run_phase.current()["label"] == ""
+    run_phase.set_phase(12)
+    assert run_phase.current()["label"] == "12"
+    run_phase.clear()
diff --git a/tests/test_scene_chain_sampler.py b/tests/test_scene_chain_sampler.py
index 3d199e89..45e23a4a 100644
--- a/tests/test_scene_chain_sampler.py
+++ b/tests/test_scene_chain_sampler.py
@@ -2,6 +2,7 @@ import sys
 import types
 from pathlib import Path
 
+import pytest
 import torch
 
 sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
@@ -67,6 +68,10 @@ def fake_sample_custom(model, noise, cfg, sampler, sigmas, positive, negative, l
         "positive": positive,
         "negative": negative,
         "cfg": cfg,
+        "steps": max(0, int(sigmas.numel()) - 1),
+        # What the sampler is telling the UI it's doing, AS this call runs — the point of
+        # the label is that it is live, so reading it afterwards would prove nothing.
+        "phase": run_phase.current()["label"],
         "latent_image": _sample_snapshot(latent_image),
         "noise_mask": _sample_snapshot(noise_mask),
     })
@@ -90,6 +95,21 @@ comfy_sample_mod = types.ModuleType("comfy.sample")
 comfy_samplers_mod = types.ModuleType("comfy.samplers")
 comfy_utils_mod = types.ModuleType("comfy.utils")
 
+
+class FakeProgressBar:
+    """Records what the sampler declared as the run's total step count."""
+    last = None
+
+    def __init__(self, total):
+        self.total = int(total)
+        self.value = 0
+        FakeProgressBar.last = self
+
+    def update_absolute(self, value, total=None, preview=None):
+        self.value = int(value)
+
+
+comfy_utils_mod.ProgressBar = FakeProgressBar
 comfy_nested_mod.NestedTensor = FakeNestedTensor
 comfy_sample_mod.prepare_noise = fake_prepare_noise
 comfy_sample_mod.sample_custom = fake_sample_custom
@@ -111,7 +131,8 @@ sys.modules.setdefault("comfy.sample", comfy_sample_mod)
 sys.modules.setdefault("comfy.samplers", comfy_samplers_mod)
 sys.modules.setdefault("comfy.utils", comfy_utils_mod)
 
-from samplers import FunPackLTXAVSceneChainSampler
+import run_phase  # noqa: E402
+from samplers import FunPackLTXAVSceneChainSampler  # noqa: E402
 
 
 class FakeVAE:
@@ -738,3 +759,95 @@ def test_plateau_cache_keys_cond_and_uncond_separately():
     assert stats["computed"] == 2  # cond + uncond each computed once
     assert stats["reused"] == 2    # then each reused once
     assert calls["n"] == 2
+
+
+# ── second pass: the progress bar and the phase readout ─────────────────────
+
+@pytest.fixture
+def live_stubs():
+    """Force this file's comfy fakes onto whatever module objects are actually live.
+
+    The module-level `sys.modules.setdefault` above only wins when this file is imported
+    FIRST — under the full suite another test module has usually registered bare comfy
+    stubs already, so the fakes here are silently discarded and every sample()-calling test
+    in this file fails on the missing attribute. Snapshot/restore rather than leaving them
+    behind, so the next module's expectations are not the ones broken instead."""
+    targets = [
+        (sys.modules["comfy.sample"], "prepare_noise", fake_prepare_noise),
+        (sys.modules["comfy.sample"], "sample_custom", fake_sample_custom),
+        (sys.modules["comfy.utils"], "ProgressBar", FakeProgressBar),
+        (sys.modules["comfy.nested_tensor"], "NestedTensor", FakeNestedTensor),
+        (sys.modules["comfy"], "sample", sys.modules["comfy.sample"]),
+        (sys.modules["comfy"], "utils", sys.modules["comfy.utils"]),
+        (sys.modules["comfy"], "nested_tensor", sys.modules["comfy.nested_tensor"]),
+    ]
+    saved = [(mod, name, getattr(mod, name, _MISSING)) for mod, name, _ in targets]
+    for mod, name, value in targets:
+        setattr(mod, name, value)
+    yield
+    for mod, name, value in saved:
+        if value is _MISSING:
+            delattr(mod, name)
+        else:
+            setattr(mod, name, value)
+
+
+_MISSING = object()
+
+
+def _second_pass_run(scene_count=2, main=torch.tensor([1.0, 0.5, 0.0]),
+                     second=torch.tensor([0.4, 0.2, 0.0])):
+    sample_calls.clear()
+    run_phase.clear()
+    node = FunPackLTXAVSceneChainSampler()
+    return node.sample(
+        model=FakeModel(),
+        vae=FakeVAE(),
+        positive=[scene_cond(i) for i in range(scene_count)],
+        negative=[(torch.zeros(1, 2, 3), {})],
+        sampler=object(),
+        sigmas=main,
+        seed=10,
+        latent_template={"samples": torch.zeros(1, 2, 5, 3, 3)},
+        num_frames_per_scene=5,
+        frame_overlap=0,
+        cfg=1.5,
+        max_scenes=8,
+        second_pass=True,
+        second_pass_sigmas=second,
+    )
+
+
+def test_second_pass_progress_total_counts_both_passes(live_stubs):
+    """A second pass samples every scene twice. If its steps aren't in the total, the bar
+    overflows during scene 1 and then jumps BACKWARDS at scene 2, whose offset is a
+    multiple of the (too small) per-scene stride."""
+    _second_pass_run(scene_count=2)
+    # 2 main steps + 2 second-pass steps, per scene, over 2 scenes.
+    assert [c["steps"] for c in sample_calls] == [2, 2, 2, 2]
+    assert FakeProgressBar.last.total == 2 * (2 + 2)
+
+
+def test_progress_total_ignores_an_unusable_second_pass_schedule(live_stubs):
+    """The loop skips a malformed schedule with a note, so the total must not reserve steps
+    for a pass that never runs — the bar would stall short of the end."""
+    _second_pass_run(scene_count=2, second=torch.tensor([0.4, 0.2]))  # doesn't reach 0
+    assert [c["steps"] for c in sample_calls] == [2, 2]
+    assert FakeProgressBar.last.total == 2 * 2
+
+
+def test_second_pass_says_which_pass_is_running(live_stubs):
+    """The run report names the second pass only after the fact, which is no help while
+    you're waiting on one. The live label has to say it AS it happens."""
+    _second_pass_run(scene_count=2)
+    assert [c["phase"] for c in sample_calls] == [
+        "scene 1/2 · pass 1 of 2", "scene 1/2 · pass 2 of 2",
+        "scene 2/2 · pass 1 of 2", "scene 2/2 · pass 2 of 2",
+    ]
+    # ...and nothing is sampling once the node returns.
+    assert run_phase.current()["label"] == ""
+
+
+def test_phase_label_drops_the_scene_number_on_a_single_scene_run(live_stubs):
+    _second_pass_run(scene_count=1)
+    assert [c["phase"] for c in sample_calls] == ["pass 1 of 2", "pass 2 of 2"]

From 64575128387de3174d3eb0e74d10b53e780b938b Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Fri, 31 Jul 2026 18:00:12 +0300
Subject: [PATCH 27/29] second_pass_op: show the upsampler it depends on, and
 say why it was skipped
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Answering "how does sharpen operate — I never saw the upsampler download?":
it uses the same file segmented detailing does, resolved the same way (any
model already in models/latent_upscale_models wins; the ~1 GB official file is
downloaded only when that folder is empty). So no download is expected on a
machine that already has one — but nothing in the Editor said so.

The upsampler picker rendered only under Experimental, and only while segmented
detailing was on, so choosing 'sharpen' alone gave no model control and no hint
that a 1 GB file was involved. It now also renders in the Second pass group
whenever an operation is selected, and the knob's hint states the dependency
and that the pass still runs (operation skipped, reason in the scene report)
when the file can't be obtained.

That reason is also worth something now: a failure said only "no latent
upsampler could be loaded", which is the same message for a missing
huggingface_hub, a failed download and an unreadable file. The real cause is
carried into the scene report and printed to the console once — previously only
the successful download printed, so a silent skip read as the op having run.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 movie_editor/frontend/engine_settings.js | 22 +++++++++++++++++-----
 samplers.py                              | 16 ++++++++++++----
 2 files changed, 29 insertions(+), 9 deletions(-)

diff --git a/movie_editor/frontend/engine_settings.js b/movie_editor/frontend/engine_settings.js
index 6caee4fb..5982abba 100644
--- a/movie_editor/frontend/engine_settings.js
+++ b/movie_editor/frontend/engine_settings.js
@@ -229,7 +229,7 @@
     { name: "cut_opening_frames", label: "Cut the opening (frames)", kind: "int", default: 0, min: 0, max: 512, step: 8,
       hint: "Let the i2v anchor do its work, then cut it out of the clip. The anchor is a pinned frame at position 0, so it carries character detail, style and composition better than anything that weakens it on the way in (ALG blurs it and loses detail; Best-FaceID tokens approximate it and lose some too) — but it is also literally the first frame you see. The scene is generated exactly as normal, with the anchor pinned at full strength the whole way and no extra sampling, and this many frames are then dropped off the FRONT of the finished clip: an i2v generation that reads as t2v. 0 = off. 8 (one latent frame) removes just the anchor itself, which is usually not enough — the anchor is followed by a settling-in stretch where the shot is still leaving the reference still and little is happening, and on a prompt asking for immediate action that dead time is exactly what you want gone. 48 was the value that worked on a 768×768×305@30 chain with a quick-cut prompt; treat it as a starting point for this pipeline, not a universal default. NOTHING IS REGROWN: the scene comes out that much SHORTER than the length you set, and the audio is cropped to match — every surviving frame was generated as part of one continuous shot, with no invented ending. Needs an anchor image; skipped (with the reason in the scene report) on continuation scenes and on scenes carrying guide frames or JoyAI audio memory." },
     { name: "second_pass_op", label: "Between-pass operation", kind: "combo", choices: ["none", "sharpen", "upscale_2x"], default: "none",
-      hint: "OPTIONAL operation applied to the latent between the two passes — 'none' by default, nothing runs unless you pick one. 'sharpen': one forward of Lightricks' trained 2x latent upsampler, resampled straight back to the original size. No video-model calls, so it costs a fraction of a step; pass 2 then re-denoises the sharpened latent, which is what makes it stick. It adds detail consistent with what's already there and CANNOT fix wrong structure (an extra finger stays an extra finger, just sharper). 'upscale_2x': the same upsampler, but kept at 2x — pass 2 runs at four times the pixels and the scene decodes at double resolution. That's 3-5x the cost of the second half, and it drops the i2v pin (the anchor and its mask are the old size, and rescaling them would be inventing an anchor), so the scene can drift from the reference image; the scene report says when that happens. Both use the same upsampler file as segmented detailing. Video only — audio is never reshaped." },
+      hint: "OPTIONAL operation applied to the latent between the two passes — 'none' by default, nothing runs unless you pick one. Both operations need the LTX 2.3 spatial upsampler in models/latent_upscale_models — the same ~1 GB file segmented detailing uses, found automatically or downloaded once on first use (watch the ComfyUI console). If it can't be obtained the second pass still runs, with the operation skipped and the reason in the scene report. 'sharpen': one forward of Lightricks' trained 2x latent upsampler, resampled straight back to the original size. No video-model calls, so it costs a fraction of a step; pass 2 then re-denoises the sharpened latent, which is what makes it stick. It adds detail consistent with what's already there and CANNOT fix wrong structure (an extra finger stays an extra finger, just sharper). 'upscale_2x': the same upsampler, but kept at 2x — pass 2 runs at four times the pixels and the scene decodes at double resolution. That's 3-5x the cost of the second half, and it drops the i2v pin (the anchor and its mask are the old size, and rescaling them would be inventing an anchor), so the scene can drift from the reference image; the scene report says when that happens. Both use the same upsampler file as segmented detailing. Video only — audio is never reshaped." },
     { name: "context_windows", label: "Context windows (long scenes)", kind: "bool", default: false,
       hint: "EXPERIMENTAL: denoise a scene that's LONGER than the model's comfortable window as overlapping windows instead of one giant pass — ComfyUI core's own mechanism, audio-aware on LTX (it maps each video window to its audio window and re-slices anchors, guides and JoyAI memory per window). Engages only on scenes longer than the window length below; shorter scenes are untouched and pay nothing. Cost at the defaults (145/40) is about 1.45× the per-frame work, since each window re-does its 40-frame overlap — offset by attention getting cheaper the longer the scene is (quadratic in one pass, near-flat when windowed). Roughly break-even around 200 frames, a net win past ~300. Needs ComfyUI v0.29.0 or newer; on older builds it's skipped with a note in the scene report. UNVALIDATED LIVE." },
     { name: "context_window_length", label: "Window length (frames)", kind: "int", default: 145, min: 9, max: 2049, step: 8, dependsOn: "context_windows",
@@ -571,6 +571,13 @@
     // all that is left here is the optional between-pass operation.
     const g = group(pane, "Second pass");
     renderKnobList(g, st, ["second_pass_op"]);
+    const si = st.project.sampler_inputs || {};
+    if (si.second_pass_op && si.second_pass_op !== "none") {
+      // Both operations are one forward of the same trained latent upsampler segmented
+      // detailing uses, so the model choice belongs here too — otherwise picking 'sharpen'
+      // silently depends on a file the user was never shown.
+      renderDetailUpsampler(pane, si, "Between-pass operation: upsampler model");
+    }
   }
 
   function renderChainContinuity(pane, st) {
@@ -696,9 +703,12 @@
     return _detailUpsamplerChoices;
   }
 
-  function renderDetailUpsampler(pane, si) {
-    if (!si.segmented_detailing) return;
-    const g = group(pane, "Segmented detailing: upsampler model");
+  // Two features load this same file: segmented detailing and the second pass's
+  // between-pass operation (sharpen / upscale_2x). It used to render only under
+  // Experimental and only while detailing was on, so someone using 'sharpen' alone got no
+  // upsampler control and no warning that a ~1 GB download was involved.
+  function renderDetailUpsampler(pane, si, title) {
+    const g = group(pane, title || "Latent upsampler model");
     if (!_detailUpsamplerChoices) {
       g.append(hintEl("Loading upsampler list…"));
       ensureDetailUpsamplerChoices();
@@ -741,7 +751,9 @@
     renderChainKnobsView(pane, st, "chain_experimental", "Experimental",
       "Research techniques — off by default; expect quality/overhead trade-offs.");
     const si = st.project.sampler_inputs || {};
-    renderDetailUpsampler(pane, si);
+    if (si.segmented_detailing) {
+      renderDetailUpsampler(pane, si, "Segmented detailing: upsampler model");
+    }
     if (!si.identity_transfer_enabled) return;
     const g = group(pane, "Best-FaceID: ArcFace projector");
     if (!_loraChoices) {
diff --git a/samplers.py b/samplers.py
index 902a8ec8..5cb9d88a 100644
--- a/samplers.py
+++ b/samplers.py
@@ -5675,14 +5675,22 @@ class FunPackLTXAVSceneChainSampler:
                                 _detail_upsampler_model = _det.load_latent_upsampler(_r)
                             except Exception as _exc:  # noqa: BLE001
                                 _detail_disabled_reason = str(_exc)
+                                # resolve_upsampler_name prints when it DOWNLOADS; nothing
+                                # printed when it can't, so a silent skip looked like the op
+                                # having run. Say it on the console too, once.
+                                print(f"[FunPackSceneChain] second_pass_op={second_pass_op} "
+                                      f"needs the latent upsampler and it could not be "
+                                      f"loaded: {_detail_disabled_reason} — the second pass "
+                                      f"still runs, without the operation.")
                         _sp_state, _op_note = self._second_pass_operate(
                             _sp_state, second_pass_op, _detail_upsampler_model, vae)
                         if _op_note:
+                            # "no upsampler could be loaded" on its own doesn't say WHY —
+                            # missing huggingface_hub, a failed download, an unreadable file
+                            # are all different fixes. Carry the real reason through.
+                            if _detail_upsampler_model is None and _detail_disabled_reason:
+                                _op_note = f"{_op_note} ({_detail_disabled_reason})"
                             run_mechanisms.append(_op_note)
-                        elif _detail_disabled_reason:
-                            run_mechanisms.append(
-                                f"second_pass_op={second_pass_op} skipped: upsampler "
-                                f"unavailable ({_detail_disabled_reason})")
                     # A second pass must KEEP the i2v anchor pinned — otherwise pass 2
                     # re-denoises the reference frame and the scene drifts away from the
                     # image it was supposed to start from.

From 2011b18b9576cdea3cba29561079d5c36db9b686 Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Fri, 31 Jul 2026 18:10:10 +0300
Subject: [PATCH 28/29] fix: don't reject projects saved with the old
 context_window_schedule names
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Renaming the combo's choices to core's spellings broke queueing for anyone who
had one of the old ones saved: ComfyUI validates combo VALUES at queue time,
before the node ever runs, so the alias map added with the rename never got a
chance. The three legacy names are back in the list (they resolve through the
alias map at runtime), and the Editor now displays a stored legacy value as the
name it maps to and writes that back, so the dropdown can't show one setting
while another runs.

And that rejection was unreadable. ComfyUI's top-level `error` for a validation
failure is a fixed blob ("Prompt outputs failed validation", details ""); the
part naming the node, the widget and the bad value is in `node_errors`, which
`error or node_errors` never reached because the blob is always truthy. Every
rejected prompt therefore reported the same nothing. Both are formatted now:

  Prompt outputs failed validation; FunPackLTXAVSceneChainSampler: Value not in
  list — context_window_schedule: 'static_standard' not in [...]

Also: the progress poll no longer imports anything. current_progress() reads
run_phase's label straight off `sys`. It fires every 700ms on ComfyUI's event
loop WHILE the worker thread samples, and that is not a path to do import work
on — the direct read is both cheaper and the correct one, since run_phase keeps
its state there anyway.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 movie_editor/backend/bridge.py           | 46 +++++++++++++++++++++---
 movie_editor/frontend/engine_settings.js |  7 +++-
 run_phase.py                             |  5 +++
 samplers.py                              |  7 +++-
 tests/test_context_windows.py            | 18 ++++++++--
 tests/test_run_phase.py                  | 12 +++++++
 6 files changed, 85 insertions(+), 10 deletions(-)

diff --git a/movie_editor/backend/bridge.py b/movie_editor/backend/bridge.py
index 1036d1af..36993599 100644
--- a/movie_editor/backend/bridge.py
+++ b/movie_editor/backend/bridge.py
@@ -580,6 +580,38 @@ class ComfyError(RuntimeError):
 EDITOR_CLIENT_ID = "funpack-movie-editor"
 
 
+def _format_prompt_rejection(data: dict, status: int) -> str:
+    """Why ComfyUI refused a prompt, in words.
+
+    Its top-level `error` for a validation failure is a fixed blob ("Prompt outputs failed
+    validation", details ""), and the part that names the node, the widget and the bad value
+    lives in `node_errors` — which the old `error or node_errors` never reached, because the
+    generic blob is always truthy. So every rejected prompt reported the same nothing.
+    """
+    parts = []
+    err = data.get("error")
+    if isinstance(err, dict):
+        head = str(err.get("message") or err.get("type") or "").strip()
+        detail = str(err.get("details") or "").strip()
+        if head:
+            parts.append(f"{head} ({detail})" if detail else head)
+    elif err:
+        parts.append(str(err))
+    for node_id, entry in (data.get("node_errors") or {}).items():
+        if not isinstance(entry, dict):
+            parts.append(f"node {node_id}: {entry}")
+            continue
+        who = str(entry.get("class_type") or f"node {node_id}")
+        for item in entry.get("errors") or []:
+            if not isinstance(item, dict):
+                parts.append(f"{who}: {item}")
+                continue
+            msg = str(item.get("message") or item.get("type") or "").strip()
+            detail = str(item.get("details") or "").strip()
+            parts.append(f"{who}: {msg}{f' — {detail}' if detail else ''}".strip())
+    return "; ".join(p for p in parts if p) or f"HTTP {status}"
+
+
 async def queue_prompt(graph: dict, client_id: Optional[str] = None,
                        extra_data: Optional[dict] = None) -> dict:
     payload = {"prompt": graph, "client_id": client_id or uuid.uuid4().hex}
@@ -589,7 +621,7 @@ async def queue_prompt(graph: dict, client_id: Optional[str] = None,
         async with s.post(_url("/prompt"), json=payload) as r:
             data = await r.json()
             if r.status >= 400 or data.get("node_errors"):
-                raise ComfyError(data.get("error") or data.get("node_errors") or f"HTTP {r.status}")
+                raise ComfyError(_format_prompt_rejection(data, r.status))
             return data
 
 
@@ -669,10 +701,14 @@ def current_progress() -> dict:
     _install_progress_hook()
     label = ""
     try:
-        # Top-level by name (never a relative import past this package — see
-        # _ensure_funpack_path). run_phase keeps its state on `sys` precisely so it does not
-        # matter whether the sampler's copy and this one are the same module object.
-        label = _funpack_attr("run_phase", "current")().get("label") or ""
+        # Read run_phase's state straight off `sys` — deliberately NO import on this path.
+        # The editor polls this every 700ms DURING sampling, on ComfyUI's event loop, so it
+        # must do nothing that can block behind the worker thread. run_phase keeps its state
+        # there anyway (its writer and any reader can hold different module objects), which
+        # makes the direct read both the cheapest and the correct one.
+        _phase = getattr(sys, "_funpack_run_phase", None)
+        if isinstance(_phase, dict):
+            label = str(_phase.get("label") or "")
     except Exception:  # noqa: BLE001 — a readout must never break the progress poll
         pass
     return {"value": _progress["value"], "max": _progress["max"], "label": label}
diff --git a/movie_editor/frontend/engine_settings.js b/movie_editor/frontend/engine_settings.js
index 5982abba..ff2c21bd 100644
--- a/movie_editor/frontend/engine_settings.js
+++ b/movie_editor/frontend/engine_settings.js
@@ -237,6 +237,7 @@
     { name: "context_window_overlap", label: "Window overlap (frames)", kind: "int", default: 40, min: 0, max: 512, step: 8, dependsOn: "context_windows",
       hint: "How many frames consecutive windows share. This is the only thing carrying motion and appearance across a window boundary, and also the only extra compute this costs. Too low shows as a seam or a motion hitch at the boundary; too high pays for frames you already have." },
     { name: "context_window_schedule", label: "Window schedule", kind: "combo", choices: ["standard_uniform", "standard_static", "looped_uniform", "batched"], default: "standard_uniform", dependsOn: "context_windows",
+      legacy: { uniform_standard: "standard_uniform", static_standard: "standard_static", uniform_looped: "looped_uniform" },
       hint: "How windows are laid out each step (ComfyUI core's own schedule names). 'standard_uniform' (default) shifts the grid between steps so boundaries never bake in — safest. 'standard_static' keeps fixed cut points (cheapest, but a bad boundary stays bad). 'looped_uniform' wraps the end into the start for looping content. 'batched' uses disjoint chunks with no overlap logic (fastest, weakest continuity)." },
     { name: "context_window_fuse", label: "Window blend", kind: "combo", choices: ["pyramid", "relative", "flat", "overlap-linear"], default: "pyramid", dependsOn: "context_windows",
       hint: "How overlapping windows are weighted when merged. 'pyramid' (default) fades each window toward its edges so seams go soft. 'flat' averages equally (can smear). Change this if boundaries look ghosted rather than merely misaligned." },
@@ -330,7 +331,11 @@
       }
     } else if (k.kind === "combo") {
       ctrl = el("select"); ctrl.dataset.k = "si-" + k.name;
-      (k.choices || []).forEach((c) => { const o = el("option", null, c); o.value = c; if (c === val) o.selected = true; ctrl.append(o); });
+      // A renamed choice: show what the stored value MEANS, and write the new name back, so
+      // the dropdown never quietly displays a different setting from the one that will run.
+      const shown = (k.legacy && k.legacy[val]) || val;
+      if (shown !== val) S.setSamplerInput(k.name, shown);
+      (k.choices || []).forEach((c) => { const o = el("option", null, c); o.value = c; if (c === shown) o.selected = true; ctrl.append(o); });
       ctrl.onchange = () => S.setSamplerInputNow(k.name, ctrl.value);
     } else if (k.kind === "text") {
       ctrl = el("input"); ctrl.type = "text";
diff --git a/run_phase.py b/run_phase.py
index 40ef0b56..7e12f7e8 100644
--- a/run_phase.py
+++ b/run_phase.py
@@ -23,6 +23,11 @@ of truth".
 """
 import sys
 
+# Part of this module's contract, not an implementation detail: movie_editor's bridge READS
+# THIS ATTRIBUTE DIRECTLY rather than importing this module. That poll runs every 700ms on
+# ComfyUI's event loop while the worker thread is sampling, so it must not touch the import
+# system or anything else that can block. Renaming this key means updating bridge.py too
+# (tests/test_run_phase.py pins the two together).
 _SYS_KEY = "_funpack_run_phase"
 
 
diff --git a/samplers.py b/samplers.py
index 5cb9d88a..8d610f02 100644
--- a/samplers.py
+++ b/samplers.py
@@ -2501,7 +2501,12 @@ class FunPackLTXAVSceneChainSampler:
                     "default": 40, "min": 0, "max": 512, "step": 8,
                     "tooltip": "How many real frames consecutive windows share. This is the ONLY thing carrying motion/appearance continuity across a window boundary, and it is also the only extra compute this feature costs (overlap/length = the redundant fraction). Too low and boundaries show as a seam or a motion hitch; too high and you pay for frames you already have.",
                 }),
-                "context_window_schedule": (["standard_uniform", "standard_static", "looped_uniform", "batched"], {
+                # The three legacy spellings stay in the LIST, not just in the alias map:
+                # ComfyUI validates combo values at QUEUE time, before the node ever runs, so
+                # a project saved with the old name would be rejected outright and the alias
+                # would never get a chance. They resolve to core's names below.
+                "context_window_schedule": (["standard_uniform", "standard_static", "looped_uniform", "batched",
+                                             "uniform_standard", "static_standard", "uniform_looped"], {
                     "default": "standard_uniform",
                     "tooltip": "How the windows are laid out across the scene, per step. These are ComfyUI core's own schedule names (comfy.context_windows). 'standard_uniform' (default, core's own LTXV default) shifts the window grid between steps so boundaries land in different places each step and never bake in — the safest general choice. 'standard_static' keeps the same fixed cut points every step (cheapest, but a bad boundary stays bad). 'looped_uniform' wraps the last window into the first, for seamless looping content. 'batched' denoises disjoint chunks with no overlap logic (fastest, weakest continuity). Projects saved with the old reversed spellings (uniform_standard / static_standard / uniform_looped) are still accepted and mapped onto these.",
                 }),
diff --git a/tests/test_context_windows.py b/tests/test_context_windows.py
index af70496f..1498aaab 100644
--- a/tests/test_context_windows.py
+++ b/tests/test_context_windows.py
@@ -208,18 +208,30 @@ def test_scene_latent_frame_count_reads_the_video_stream():
 
 # ── the names are core's, not ours ──────────────────────────────────────────
 
-def test_every_schedule_the_node_offers_is_one_core_knows(monkeypatch):
+def test_every_schedule_the_node_offers_actually_resolves(monkeypatch):
     """The bug in one line: the node offered spellings core has never had, so choosing any
-    of them raised ValueError out of the sampler and killed the render."""
+    of them raised ValueError out of the sampler and killed the render. Every name the combo
+    accepts must now reach a real core schedule — directly or through the alias map."""
     model, _ = _install_fake_core(monkeypatch)
     s = samplers.FunPackLTXAVSceneChainSampler()
     offered = s.INPUT_TYPES()["optional"]["context_window_schedule"][0]
-    assert set(offered) <= set(sys.modules["comfy.context_windows"].CONTEXT_MAPPING)
+    known = set(sys.modules["comfy.context_windows"].CONTEXT_MAPPING)
+    assert known <= set(offered)  # nothing core supports is missing from the knob
     for name in offered:
         model, _ = _install_fake_core(monkeypatch)
         assert _install(s, model, schedule=name)[0] is not None, name
 
 
+def test_the_legacy_names_stay_in_the_combo_list_not_only_in_the_alias_map():
+    """ComfyUI validates combo values at QUEUE time, before the node runs. Dropping the old
+    spellings from the list would reject a saved project outright and the alias would never
+    get a chance — which is a worse failure than the one being fixed."""
+    offered = samplers.FunPackLTXAVSceneChainSampler().INPUT_TYPES()[
+        "optional"]["context_window_schedule"][0]
+    for legacy in samplers.FunPackLTXAVSceneChainSampler._CTX_SCHEDULE_ALIASES:
+        assert legacy in offered, legacy
+
+
 def test_the_old_reversed_spellings_still_resolve(monkeypatch):
     """A project saved before the names were corrected must keep generating, not fail."""
     s = samplers.FunPackLTXAVSceneChainSampler()
diff --git a/tests/test_run_phase.py b/tests/test_run_phase.py
index 721f6b6e..f62c5224 100644
--- a/tests/test_run_phase.py
+++ b/tests/test_run_phase.py
@@ -50,3 +50,15 @@ def test_a_bad_label_never_raises():
     run_phase.set_phase(12)
     assert run_phase.current()["label"] == "12"
     run_phase.clear()
+
+
+def test_the_bridge_reads_the_same_sys_key_without_importing_this_module():
+    """movie_editor's progress poll runs every 700ms on ComfyUI's event loop WHILE the
+    worker thread samples, so it reads the label straight off `sys` rather than importing
+    anything. That makes the key name a contract between two files — pin it."""
+    src = (ROOT / "movie_editor" / "backend" / "bridge.py").read_text()
+    assert run_phase._SYS_KEY == "_funpack_run_phase"
+    assert f'getattr(sys, "{run_phase._SYS_KEY}"' in src
+    # ...and the poll must not have grown an import back.
+    poll = src.split("def current_progress(")[1].split("\ndef ")[0]
+    assert "import_module" not in poll and "_funpack_attr" not in poll

From 44a93735240ad6fafcfd76043e1cb74c3f6a869e Mon Sep 17 00:00:00 2001
From: digital-garbage <133010426+digital-garbage@users.noreply.github.com>
Date: Fri, 31 Jul 2026 18:17:06 +0300
Subject: [PATCH 29/29] Release 3.4.1: CHANGELOG, README, version bump

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
---
 CHANGELOG.md   | 63 ++++++++++++++++++++++++++++++++++++++++++++++++++
 README.md      |  8 +++++++
 pyproject.toml |  2 +-
 3 files changed, 72 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index c2f63b07..6fb5096a 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,7 +2,38 @@
 
 ## [Unreleased]
 
+## [3.4.1] - 2026-07-31
+
 ### Added
+- **A second sampling pass on the Chain Sampler.** Give it a schedule and every scene is
+  sampled twice: pass 1 runs the main sigmas in full, then pass 2 runs its own schedule in
+  full, starting from pass 1's finished clip. Nothing is cut short and nothing is derived —
+  total steps are simply the two added up — and pass 2 re-enters through ComfyUI's ordinary
+  img2img noise scaling, so **its first sigma is a literal strength dial** (0.8 reworks the
+  shot, 0.4 polishes, 0.2 is detail work). The i2v anchor stays pinned across the split. In
+  the Cutting Room it is one field, **Second pass schedule**, under FunPack Studio ▸ Sampler
+  algorithm: typing a schedule enables the pass, clearing it turns the pass off.
+- **An optional operation between the two passes** (`none` by default — nothing runs unless
+  you pick one). `sharpen` runs one forward of Lightricks' trained 2× latent upsampler and
+  resamples straight back to the original size: no video-model calls, a fraction of a step,
+  and pass 2 then re-denoises the result, which is what makes it stick. `upscale_2x` keeps
+  the 2×, so pass 2 runs at four times the pixels and the scene decodes at double resolution
+  (3–5× the cost of the second half, and the i2v pin is dropped — the scene report says so).
+  Both use the same upsampler file segmented detailing does, and the model picker now appears
+  alongside the operation instead of only under segmented detailing.
+- **Cut the opening off i2v scenes** (`cut_opening_frames`, Chain Sampler ▸ Timing & Seed).
+  The anchor is a pinned frame at position 0: it carries identity, style and composition
+  better than anything that weakens it on the way in — and it is also literally the first
+  frame you see, so every i2v scene opens on the exact reference still. The scene is
+  generated exactly as normal, anchor at full strength, **no extra sampling**, and the
+  opening is then cut off the finished clip: an i2v generation that reads as t2v. Nothing is
+  regrown, so the scene comes out that much shorter and the audio is cropped to match.
+- **Context windows** for scenes longer than the model's comfortable window (ComfyUI core's
+  own mechanism, audio-aware on LTX — nothing ported). Engages only past the window length,
+  so shorter scenes pay nothing.
+- **The progress readout says what is running**, not just a step count: `sampling 17/26 ·
+  scene 2/3 · pass 2 of 2`. The second pass also announces itself on the ComfyUI console the
+  moment it starts, rather than only in the run report afterwards.
 - **Prompt `$name` variables in Easy Gen** — the shorthand-for-a-full-phrase layer the
   Cutting Room's Composer already had (`$vid = "High quality, high fidelity realistic video,
   motion blur, cinematic fog"`). A **$ Variables** button in the prompt bar opens its own
@@ -19,9 +50,41 @@
   indistinguishable from a real crash at the API level), and any partial media it did write
   is still shown.
 
+- **Easy Gen re-attaches to a running generation after a page reload** — the Cutting Room
+  already did.
+
 ### Changed
 - **Variable values are now auto-growing text boxes** (both UIs) instead of one-line inputs —
   a long phrase was effectively uneditable in a single-line field.
+- **Plateau step-cache and context windows are mutually exclusive** — the cache cannot tell
+  one window from another within a step, so it is skipped with a note in the scene report.
+
+### Fixed
+- **Context windows never worked.** The schedule names were ComfyUI core's spelled backwards
+  (`uniform_standard` where core says `standard_uniform`), so every choice except `batched`
+  raised a `ValueError` out of the sampler and **failed the whole render**. Core's names are
+  the choices now; the old spellings are still accepted and mapped onto them, so a saved
+  project keeps generating. An unknown name is refused with a reason naming what your
+  ComfyUI accepts, instead of escaping as an exception.
+- The same call also passed a keyword core's window handler does not always take, which was
+  reported as *"ComfyUI core too old"* — silently switching off a feature that core fully
+  supports. Unsupported keywords are dropped now, with a note naming the one setting that
+  degrades.
+- **A rejected prompt now says why.** ComfyUI's top-level error for a validation failure is a
+  fixed blob ("Prompt outputs failed validation", no details); the part naming the node, the
+  widget and the bad value is in `node_errors`, which the editor never read — so every
+  rejected prompt reported the same nothing. Both are shown.
+- **Bypass no longer refuses a node over an output nothing uses.** A node that emits an extra
+  output the graph never wires (an IC-LoRA loader's `latent_downscale_factor`, say) could not
+  be bypassed at all, because a passthrough was demanded for every output rather than for the
+  ones actually consumed.
+- **The progress bar counted only the first pass**, so a second pass overflowed it and then
+  jumped backwards at the next scene.
+- **Identity transfer** follows ComfyUI's new RoPE matrix layout.
+- **Models & Pipeline** treats ComfyUI V3 MultiType widgets as widgets rather than required
+  sockets, so a node using them no longer reads as unsatisfied.
+- The latent upsampler loads on ComfyUI v0.29.0, which moved it onto DynamicVram and made
+  `operations` a required argument.
 
 ## [3.4.0] - 2026-07-24
 
diff --git a/README.md b/README.md
index 71fc8afb..0c646b0c 100644
--- a/README.md
+++ b/README.md
@@ -74,6 +74,14 @@ and several bugfixes (a bypass toggle that could silently do nothing, a state-sy
 could revert Models & Pipeline edits, and more) — see the [CHANGELOG](CHANGELOG.md) for the
 full list.
 
+**3.4.1** adds a **second sampling pass** on the Chain Sampler — give it a schedule and every
+scene is sampled twice, with an optional latent sharpen/2× upscale between the passes — plus
+**cut the opening** for i2v scenes (keep the anchor's identity transfer at full strength, then
+cut the reference still out of the finished clip), **context windows** for scenes longer than
+the model's comfortable window, and a progress readout that says which scene and which pass is
+running. Context windows, which never actually worked before, are fixed — see the
+[CHANGELOG](CHANGELOG.md) for the full list.
+
 See [`docs/MovieEditor.md`](docs/MovieEditor.md) for complete Cutting Room documentation.
 
 ## Installation
diff --git a/pyproject.toml b/pyproject.toml
index 24fba925..5d40e6b0 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -2,7 +2,7 @@
 [project]
 name = "ComfyUI-FunPack" # Unique identifier for your node. Immutable after creation.
 description = "An AI movie studio inside ComfyUI: the Cutting Room browser-based video editor with timeline, per-scene prompts and one-click montage generation, plus a self-improving engine that learns from your ratings. Includes the full node stack (Studio, Refiner V2, LTXAV Scene Chain Sampler) for classic graph workflows."
-version = "3.4.0" # Custom Node version. Must be semantically versioned.
+version = "3.4.1" # Custom Node version. Must be semantically versioned.
 license = { text = "GNU GPL v3" }
 dependencies  = [] # Filled in from requirements.txt