@hugpy/video-intelligence-ui 0.1.0 → 0.3.0

package/src/stations/studio/{StudioMovieComposer.tsx.bak-sessions-20260812 → StudioMovieComposer.tsx.bak-declutter-20260813}

@@ -66,7 +66,8 @@ import {
   type JobStatus,
 } from "../../video/contract";
 import { getSessionId } from "../../session";
-import { useMediaLibrary } from "../../video/mediaLibrary";
+import { addToLibrary, useMediaLibrary } from "../../video/mediaLibrary";
+import { UnnamedWarnPanel, WarnUnnamedToggle, useWarnUnnamedPref } from "../../video/UnnamedWarn";
 import { GoalComposer } from "../GoalComposer";
 import { usePromptAssist, type AssistExtras } from "../../video/usePromptAssist";
 import { PromptAssistButtons } from "../../video/PromptAssistButtons";
@@ -131,7 +132,9 @@ import { useIdentityProfiles } from "./useIdentityProfiles";
 // CINEMA SESSIONS (k91): the durable movie sessions on the studio-movies root (resume /
 // pause / watch what rendered), plus the shared live-pace line this composer reuses for
 // its OWN in-flight render. Both live next door so there is one renderer for each.
-import { StudioMovieSessions, MovieLiveProgress } from "./StudioMovieSessions";
+// Cinema sessions moved to the Active display's Sessions panel (operator ask
+// 2026-08-12) — this file keeps only the live-pace renderer for its own render.
+import { MovieLiveProgress } from "./StudioMovieSessions";
 
 // B3: the movie endpoint is now a promoted config literal (mirrors studioI2VEnqueueUrl),
 // replacing the earlier inline `${hugpyConfig.apiBase}/video/studio/movie` derivation.
@@ -283,6 +286,18 @@ interface GoalRow {
   seed: string;
   branchFrame: string;
   joint: JointMode;
+  // FULL PER-SEGMENT KNOBS (operator ask 2026-08-12): the cinema route has
+  // accepted per-goal model_id/steps/cfg/context_frames overrides all along
+  // (StudioMovieGoal — "honored when set, not dead fields"); the editor just
+  // never offered them. Same string idiom as seed/branchFrame: blank ⇒ the key
+  // is dropped from the goal body and the segment inherits the movie-level
+  // value (or the router/model default).
+  modelId: string;
+  steps: string;
+  cfg: string;
+  contextFrames: string;
+  // per-segment CLIP LENGTH in frames (2026-08-13); blank = movie default.
+  frames: string;
 }
 
 // The counter is SESSION-persisted (not a module `let`) now that the goal rows
@@ -297,10 +312,15 @@ function blankGoal(joint: JointMode = "still"): GoalRow {
     key: newGoalKey(),
     prompt: "",
     negative: "",
-    stdNegative: false,
+    stdNegative: true,
     seed: "",
     branchFrame: "",
     joint,
+    modelId: "",
+    steps: "",
+    cfg: "",
+    contextFrames: "",
+    frames: "",
   };
 }
 
@@ -571,15 +591,35 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
   // in-flight job state stay on plain useState on purpose.
   //
   // Goal timeline — at least one row; row 0 is the root (t2v).
-  const [goals, setGoals] = useSessionState<GoalRow[]>("studio.movie.goals", () => [
+  const [goalsRaw, setGoals] = useSessionState<GoalRow[]>("studio.movie.goals", () => [
     blankGoal(),
     blankGoal(),
   ]);
+  // Rows restored from a session written BEFORE the per-segment knob round
+  // (2026-08-12) lack modelId/steps/cfg/contextFrames — normalize to the blank
+  // ("inherit") value so `.trim()` never meets undefined. useMemo, not a write:
+  // the stored rows heal on the next real edit.
+  const goals = useMemo(
+    () =>
+      goalsRaw.map((g) => ({
+        modelId: "",
+        steps: "",
+        cfg: "",
+        contextFrames: "",
+        frames: "",
+        ...g,
+      })),
+    [goalsRaw],
+  );
 
   // Movie-level knobs (mirror the clip surface's defaults + idiom where reusable).
   // Default 480×480: the wan2.1-vace-1.3b IDENTITY sweet spot — the only budget-fitting
   // id-capable model on this fleet tops out at 832×480, so a 512×512 default cannot serve
   // id_lock on it (no_capable_model). 832×480 widescreen is the other valid id envelope.
+  // EXPLICIT SEGMENT LENGTH (operator 2026-08-13): movie-level default frames
+  // per segment; a segment's own frames (below) overrides. Blank = each bound
+  // model's default (81 real). Clamped + 4k+1-snapped by the spine.
+  const [framesDefault, setFramesDefault] = useSessionState("studio.movie.frames", "");
   const [width, setWidth] = useSessionState("studio.movie.width", 480);
   const [height, setHeight] = useSessionState("studio.movie.height", 480);
   const [fps, setFps] = useSessionState("studio.movie.fps", 24);
@@ -1102,18 +1142,54 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
   // The row's RESOLVED operation only chooses which mode the primary button invokes;
   // both explicit buttons stay live underneath, so a router mistake costs one click,
   // never a paragraph of the user's work.
+  // The last AUTO-derived movie title. A name the operator typed is sacred; a
+  // name this ref minted may be replaced by the next Generate (operator
+  // 2026-08-13: "purely a product of the same generation method").
+  const autoTitleRef = useRef("");
+
   const runRowAssist = useCallback(
     (i: number, mode: "detail" | "generate") => {
       const g = goals[i];
       if (!g) return;
-      void assist.runAssist(mode, g.prompt, (p) => setGoalField(i, { prompt: p }), {
-        context: rowContext(i),
-      });
+      void (async () => {
+        let fresh = "";
+        await assist.runAssist(mode, g.prompt, (p) => {
+          fresh = p;
+          setGoalField(i, { prompt: p });
+        }, { context: rowContext(i) });
+        if (mode !== "generate" || !fresh.trim()) return;
+        // NEGATIVE RIDES ALONG (operator 2026-08-13): the generated exclusion
+        // list APPENDS to this goal's typed negative, never clobbers it
+        // (composeNegative dedupes the std terms at payload time).
+        await assist.runNegative(
+          { subject: fresh, extra: { context: rowContext(i) } },
+          (neg) => {
+            const cur = (g.negative ?? "").trim().replace(/,\s*$/, "");
+            setGoalField(i, { negative: cur ? `${cur}, ${neg}` : neg });
+          },
+        );
+        // NAME RIDES ALONG: derive a title from the generated prompt when the
+        // movie has none — or when the current one was itself auto-derived.
+        const t = movieTitle.trim();
+        if (t === "" || t === autoTitleRef.current) {
+          const derived = fresh
+            .split(/[.,;\n]/)[0]
+            .trim()
+            .split(/\s+/)
+            .slice(0, 7)
+            .join(" ")
+            .slice(0, 48);
+          if (derived) {
+            autoTitleRef.current = derived;
+            setMovieTitle(derived);
+          }
+        }
+      })();
       // The text is about to change, so the old classification no longer describes it.
       intentText.current[g.key] = "";
       setIntents((prev) => ({ ...prev, [g.key]: null }));
     },
-    [assist, goals, rowContext, setGoalField],
+    [assist, goals, rowContext, setGoalField, movieTitle, setMovieTitle],
   );
 
   // ── negative generation (§1b) — an exclusion list for THIS shot ──
@@ -1269,7 +1345,7 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
   }, [pendingFocusKey, goals]);
 
   // ── build the exact request body the route reads ──
-  const buildBody = useCallback((): { body: Record<string, unknown> } | { err: string } => {
+  const buildBody = useCallback((titleOverride?: string): { body: Record<string, unknown> } | { err: string } => {
     if (goals.length < 1) return { err: "Add at least one goal (the root segment)." };
     for (let i = 0; i < goals.length; i++) {
       if (goals[i].prompt.trim() === "") {
@@ -1279,6 +1355,24 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
       if (s !== "" && !Number.isInteger(Number(s))) {
         return { err: `Goal ${i + 1} seed must be a whole number (or blank).` };
       }
+      // Per-segment sampler overrides — the SAME bounds as the movie-level knobs
+      // below (and the schema's _check_steps_cfg): blank = inherit.
+      const gSteps = goals[i].steps.trim();
+      if (gSteps !== "" && (!Number.isInteger(Number(gSteps)) || Number(gSteps) < 1 || Number(gSteps) > 100)) {
+        return { err: `Goal ${i + 1} steps must be a whole number in [1, 100] (or blank to inherit).` };
+      }
+      const gCfg = goals[i].cfg.trim();
+      if (gCfg !== "" && (Number.isNaN(Number(gCfg)) || Number(gCfg) < 0 || Number(gCfg) > 20)) {
+        return { err: `Goal ${i + 1} CFG must be a number in [0, 20] (or blank to inherit).` };
+      }
+      const gFrames = goals[i].frames.trim();
+      if (gFrames !== "" && (!Number.isInteger(Number(gFrames)) || Number(gFrames) < 1)) {
+        return { err: `Goal ${i + 1} length must be a whole number of frames \u2265 1 (or blank to inherit).` };
+      }
+      const gCtx = goals[i].contextFrames.trim();
+      if (gCtx !== "" && (!Number.isInteger(Number(gCtx)) || Number(gCtx) < 1)) {
+        return { err: `Goal ${i + 1} context frames must be a whole number ≥ 1 (or blank to inherit).` };
+      }
       // A "cut" carries no frame, so its branch-frame input is disabled + ignored; only
       // validate a branch frame for a still / vace_extend joint.
       if (i > 0 && goals[i].joint !== "cut") {
@@ -1302,6 +1396,10 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
     // Movie-level sampler overrides — same bounds the clip surface (and the movie
     // schema's _check_steps_cfg) enforce: steps int [1,100], cfg number [0,20]. Blank
     // drops the key (model default).
+    const framesDefNum = framesDefault.trim() === "" ? undefined : Number(framesDefault);
+    if (framesDefNum !== undefined && (!Number.isInteger(framesDefNum) || framesDefNum < 1)) {
+      return { err: "Segment length must be a whole number of frames \u2265 1 (or blank for model defaults)." };
+    }
     const stepsNum = steps.trim() === "" ? undefined : Number(steps);
     if (
       stepsNum !== undefined &&
@@ -1325,6 +1423,13 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
       // empty user negative + a tick still sends the standard exclusions.
       const effNegative = composeNegative(g.negative, g.stdNegative);
       if (effNegative !== "") node.negative = effNegative;
+      // Per-segment model/sampler overrides (2026-08-12): blank drops the key so
+      // the segment inherits the movie-level pin/override (or the router/model
+      // default) — the exact fallback chain StudioMovieGoal documents.
+      if (g.modelId.trim() !== "") node.model_id = g.modelId.trim();
+      if (g.steps.trim() !== "") node.steps = Number(g.steps);
+      if (g.cfg.trim() !== "") node.cfg = Number(g.cfg);
+      if (g.frames.trim() !== "") node.frames = Number(g.frames);
       // joint_mode + branch_frame are meaningless on the root (segment 0 has no parent).
       if (i > 0) {
         // Send a non-default joint_mode ("vace_extend" | "cut"); "still" is the route default.
@@ -1334,12 +1439,18 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
           const bf = g.branchFrame.trim();
           if (bf !== "") node.branch_frame = Number(bf);
         }
+        // context_frames is only consulted for a vace_extend joint (schema note) —
+        // sending it otherwise would imply a knob that does nothing.
+        if (g.joint === "vace_extend" && g.contextFrames.trim() !== "") {
+          node.context_frames = Number(g.contextFrames);
+        }
       }
       return node;
     });
 
     const body: Record<string, unknown> = {
       resolution: { width, height, fps },
+      frames: framesDefNum,
       seed,
       vram_budget_gb: budgetNum,
       // Movie-level model pin + sampler overrides (blank ⇒ key dropped = router/model
@@ -1353,7 +1464,7 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
       // The movie's NAME (k91) — free text, display-only: it never changes what renders,
       // it is what the sessions list shows instead of a bare dir id. Blank drops the key
       // (the schema takes title=None and the session lists as "untitled").
-      title: movieTitle.trim() ? movieTitle.trim() : undefined,
+      title: (titleOverride ?? movieTitle).trim() ? (titleOverride ?? movieTitle).trim() : undefined,
       // Optional root conditioning still — the route jail-resolves this abs uri and
       // renders segment 0 i2v (drops back to t2v when absent). Mirrors the clip surface.
       start_image: startImage ? startImage.uri : undefined,
@@ -1373,10 +1484,13 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
   // name. It is a warning, not a gate: the run row then offers "Generate without a
   // name", and `onGenerate(true)` skips the check. Cleared whenever a name is typed.
   const [nameWarn, setNameWarn] = useState(false);
+  // The warning is an EXPLICIT PER-SECTION OPTION now (operator 2026-08-13),
+  // DEFAULT OFF, remembered in localStorage — shared UnnamedWarn seam.
+  const [warnUnnamed, setWarnUnnamed] = useWarnUnnamedPref("cinema");
 
   const onGenerate = useCallback(
-    (skipNameCheck = false) => {
-      const built = buildBody();
+    (skipNameCheck = false, titleOverride?: string) => {
+      const built = buildBody(titleOverride);
       if ("err" in built) {
         setFormMsg(built.err);
         return;
@@ -1384,18 +1498,40 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
       // Warn ONCE per unnamed submit. An unnamed movie is still fully renderable — the
       // cost is later, in a sessions list where it reads as "untitled · 7f3a91c2…" and
       // nobody can tell which paused render is which.
-      if (!skipNameCheck && movieTitle.trim() === "") {
+      if (!skipNameCheck && warnUnnamed && movieTitle.trim() === "") {
         setNameWarn(true);
         setFormMsg(null);
         return;
       }
       setNameWarn(false);
       setFormMsg(null);
+      if (titleOverride && titleOverride.trim()) setMovieTitle(titleOverride.trim());
       job.run(built.body);
     },
-    [buildBody, job, movieTitle],
+    [buildBody, job, movieTitle, setMovieTitle, warnUnnamed],
   );
 
+  // SESSION LIBRARY PUSH (operator 2026-08-13): a finished movie's outputs
+  // land in the Session Library IMMEDIATELY — every segment clip plus the
+  // assembled movie (outputs[-1] when assembly produced one) — tagged
+  // generate_movie so the sidebar's Videos section lists them newest-first.
+  // addToLibrary de-dups by uri, so re-renders of the same result are no-ops.
+  useEffect(() => {
+    const r = job.result;
+    if (!r || r.ok === false || !r.outputs || r.outputs.length === 0) return;
+    for (const ref of r.outputs) {
+      if (!ref?.uri || !ref?.asset_id) continue;
+      addToLibrary(ref, "cinema", movieTitle.trim() || "movie", {
+        genKind: "generate_movie",
+        prompt: goals[0]?.prompt,
+        groupId: job.jobId ?? undefined,
+      });
+    }
+    // movieTitle/goals deliberately excluded: push once per RESULT, labelled
+    // with whatever the fields held when it landed.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [job.result, job.jobId]);
+
   // ── derive playback refs from the terminal result ──
   // Outputs = [segment clips…, movie.mp4 LAST] (the runner appends the assembled
   // movie only when assembly produced one). Pair each segment ref with its manifest
@@ -1759,12 +1895,10 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
       {settingsHost ? createPortal(settingsNode, settingsHost) : null}
       {/* (The intro prose moved into the sidebar "About Cinema" expander — k89.) */}
 
-      {/* ── CINEMA SESSIONS (k91) — every movie already on the studio-movies root, with
-             what it rendered and the two actions on it. FIRST in the composer because it
-             is the recovery surface: an operator whose 14-segment render lost its tab
-             comes back here to resume it, and a session buried under the authoring
-             controls is a session nobody finds. Its poll runs only while it is open. ── */}
-      <StudioMovieSessions />
+      {/* ── CINEMA SESSIONS: relocated (2026-08-12). The recovery surface now lives in
+             the Active display's Sessions panel (▤ Active drawer / the /active station),
+             sectioned per surface (Scene · Movie · Clip · Cinema) — reachable from every
+             station instead of only this composer. ── */}
 
       {/* ── MOVIE NAME — what this session will be called in the list above. Kept at the
              top of the authoring column (not in the sidebar with `project`) because it is
@@ -1792,8 +1926,84 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
             if (e.target.value.trim() !== "") setNameWarn(false);
           }}
         />
+        <WarnUnnamedToggle checked={warnUnnamed} onChange={setWarnUnnamed} />
       </section>
 
+      {/* ── MOVIE SETTINGS, IN-COLUMN (operator 2026-08-13: "not seeing model,
+             fps, dimension inputs for cinema") — the geometry/model/sampler knobs
+             live in the left-sidebar Settings tab via portal, which is easy to
+             miss (and absent when no host mounts). This expander mirrors the
+             SAME state — two views, one truth, like the Clip card. ── */}
+      <PromptCardSettings label="movie settings — model · size · fps · steps · cfg · budget">
+        <div className="vi-knob vi-studio-knob-wide" style={{ minWidth: "16rem" }}>
+          <label htmlFor="vi-moviecol-model">model — whole movie</label>
+          <select
+            id="vi-moviecol-model"
+            className="vi-knob-select"
+            value={modelId}
+            disabled={disableSubmit}
+            onChange={(e) => setModelId(e.target.value)}
+          >
+            <option value="">Auto — router picks by capability/budget</option>
+            {movieModels.length > 0 && (
+              <optgroup label="Bound by a ratified movie segment">
+                {movieModels.map((id) => (
+                  <option key={id} value={id}>{id}</option>
+                ))}
+              </optgroup>
+            )}
+            {(showAllModels || !renderLoaded || (modelId !== "" && !movieModels.includes(modelId))) && (
+              <optgroup label={renderLoaded ? "Other studio models — unverified for a movie segment" : "Studio models"}>
+                {STUDIO_MODEL_IDS.filter((id) => !movieModels.includes(id)).map((id) => (
+                  <option key={id} value={id}>{id}{renderLoaded ? " · unverified" : ""}</option>
+                ))}
+              </optgroup>
+            )}
+          </select>
+        </div>
+        <div className="vi-knob" style={{ maxWidth: "7rem" }}>
+          <label htmlFor="vi-moviecol-width">width</label>
+          <input id="vi-moviecol-width" className="vi-knob-input" type="number" min={64} step={8}
+                 value={width} onChange={(e) => setWidth(Number(e.target.value) || 0)} />
+        </div>
+        <div className="vi-knob" style={{ maxWidth: "7rem" }}>
+          <label htmlFor="vi-moviecol-height">height</label>
+          <input id="vi-moviecol-height" className="vi-knob-input" type="number" min={64} step={8}
+                 value={height} onChange={(e) => setHeight(Number(e.target.value) || 0)} />
+        </div>
+        <div className="vi-knob" style={{ maxWidth: "6rem" }}>
+          <label htmlFor="vi-moviecol-fps">fps</label>
+          <input id="vi-moviecol-fps" className="vi-knob-input" type="number" min={1}
+                 value={fps} onChange={(e) => setFps(Number(e.target.value) || 0)} />
+        </div>
+        <div className="vi-knob" style={{ maxWidth: "12rem" }}>
+          <label htmlFor="vi-moviecol-frames">length — frames / segment</label>
+          <input id="vi-moviecol-frames" className="vi-knob-input" type="number" min={1}
+                 value={framesDefault} placeholder="model default (81)"
+                 onChange={(e) => setFramesDefault(e.target.value)} />
+          <span className="vi-knob-hint">
+            {framesDefault.trim() !== "" && Number(framesDefault) > 0 && fps > 0
+              ? `every segment \u2248 ${(Number(framesDefault) / fps).toFixed(1)}s @ ${fps}fps (a segment\u2019s own length overrides)`
+              : `blank = model default \u2014 81f \u2248 ${fps > 0 ? (81 / fps).toFixed(1) : "?"}s @ ${fps}fps per segment`}
+          </span>
+        </div>
+        <div className="vi-knob" style={{ maxWidth: "7rem" }}>
+          <label htmlFor="vi-moviecol-steps">steps</label>
+          <input id="vi-moviecol-steps" className="vi-knob-input" type="number" min={1} max={100}
+                 value={steps} placeholder="model default" onChange={(e) => setSteps(e.target.value)} />
+        </div>
+        <div className="vi-knob" style={{ maxWidth: "7rem" }}>
+          <label htmlFor="vi-moviecol-cfg">cfg</label>
+          <input id="vi-moviecol-cfg" className="vi-knob-input" type="number" min={0} max={20} step={0.5}
+                 value={cfg} placeholder="model default" onChange={(e) => setCfg(e.target.value)} />
+        </div>
+        <div className="vi-knob" style={{ maxWidth: "9rem" }}>
+          <label htmlFor="vi-moviecol-vram">VRAM budget GB</label>
+          <input id="vi-moviecol-vram" className="vi-knob-input" type="number" min={1}
+                 value={vramBudget} placeholder="autofit" onChange={(e) => setVramBudget(e.target.value)} />
+        </div>
+      </PromptCardSettings>
+
       {/* ── Movie start switcher (operator ask 2026-07-12, verbatim): "It needs to be
              choosable by the user: any library clip, image, or scene to start — or
              start fresh with a prompt to generate a clip. This static starting clip is
@@ -2302,11 +2512,20 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
               />
               </div>
 
-            {/* k88 — seed / joint / branch-from-frame fold into the shared settings
-                expander (collapsed by default); the joint DESCRIPTOR stays visible
-                in the card header above. */}
+            {/* k88 — the shared settings expander (collapsed by default); the joint
+                DESCRIPTOR stays visible in the card header above.
+                2026-08-12: grew from seed-only to the FULL per-segment knob set the
+                route has always accepted (StudioMovieGoal): model pin, steps, cfg,
+                and (vace_extend rows) context frames. Every knob blank ⇒ the key is
+                dropped and the segment inherits the movie-level value — Movie-tab
+                (k92) parity, minus the share ticks (here the movie level IS the
+                shared value, so "inherit" already says it). */}
             <PromptCardSettings
-              label={i === 0 ? "settings — seed" : "settings — seed · joint · branch"}
+              label={
+                i === 0
+                  ? "settings — seed · model · steps · cfg · length"
+                  : "settings — seed · model · steps · cfg · length · joint · branch"
+              }
             >
               <div className="vi-knob" style={{ maxWidth: "10rem" }}>
                 <label htmlFor={`vi-movie-seed-${g.key}`}>seed (optional)</label>
@@ -2320,6 +2539,88 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
                   onChange={(e) => setGoalField(i, { seed: e.target.value })}
                 />
               </div>
+              <div className="vi-knob" style={{ maxWidth: "16rem" }}>
+                <label htmlFor={`vi-movie-goalmodel-${g.key}`}>model — this segment</label>
+                <select
+                  id={`vi-movie-goalmodel-${g.key}`}
+                  className="vi-knob-select"
+                  value={g.modelId}
+                  onChange={(e) => setGoalField(i, { modelId: e.target.value })}
+                >
+                  <option value="">
+                    {modelId.trim() ? `Inherit — ${modelId.trim()}` : "Inherit — router picks"}
+                  </option>
+                  {movieModels.length > 0 && (
+                    <optgroup label="Bound by a ratified movie segment">
+                      {movieModels.map((id) => (
+                        <option key={id} value={id}>
+                          {id}
+                        </option>
+                      ))}
+                    </optgroup>
+                  )}
+                  {(showAllModels || !renderLoaded || (g.modelId !== "" && !movieModels.includes(g.modelId))) && (
+                    <optgroup label={renderLoaded ? "Other studio models — unverified for a movie segment" : "Studio models"}>
+                      {STUDIO_MODEL_IDS.filter((id) => !movieModels.includes(id)).map((id) => (
+                        <option key={id} value={id}>
+                          {id}
+                          {renderLoaded ? " · unverified" : ""}
+                        </option>
+                      ))}
+                    </optgroup>
+                  )}
+                </select>
+                <span className="vi-knob-hint">
+                  Pin a model for THIS segment only. Inherit = the movie-level pin, else the
+                  capability router. An unroutable pin errors on the job, never silently swaps.
+                </span>
+              </div>
+              <div className="vi-knob" style={{ maxWidth: "8rem" }}>
+                <label htmlFor={`vi-movie-goalsteps-${g.key}`}>steps</label>
+                <input
+                  id={`vi-movie-goalsteps-${g.key}`}
+                  className="vi-knob-input"
+                  type="number"
+                  min={1}
+                  max={100}
+                  value={g.steps}
+                  placeholder={steps.trim() || "inherit"}
+                  onChange={(e) => setGoalField(i, { steps: e.target.value })}
+                />
+                <span className="vi-knob-hint">1–100 · blank = movie/model default</span>
+              </div>
+              <div className="vi-knob" style={{ maxWidth: "8rem" }}>
+                <label htmlFor={`vi-movie-goalcfg-${g.key}`}>cfg</label>
+                <input
+                  id={`vi-movie-goalcfg-${g.key}`}
+                  className="vi-knob-input"
+                  type="number"
+                  min={0}
+                  max={20}
+                  step={0.5}
+                  value={g.cfg}
+                  placeholder={cfg.trim() || "inherit"}
+                  onChange={(e) => setGoalField(i, { cfg: e.target.value })}
+                />
+                <span className="vi-knob-hint">0–20 · blank = movie/model default</span>
+              </div>
+              <div className="vi-knob" style={{ maxWidth: "11rem" }}>
+                <label htmlFor={`vi-movie-goalframes-${g.key}`}>length — frames</label>
+                <input
+                  id={`vi-movie-goalframes-${g.key}`}
+                  className="vi-knob-input"
+                  type="number"
+                  min={1}
+                  value={g.frames}
+                  placeholder={framesDefault.trim() || "model default"}
+                  onChange={(e) => setGoalField(i, { frames: e.target.value })}
+                />
+                <span className="vi-knob-hint">
+                  {g.frames.trim() !== "" && Number(g.frames) > 0 && fps > 0
+                    ? `\u2248 ${(Number(g.frames) / fps).toFixed(1)}s @ ${fps}fps`
+                    : "blank = movie default \u00b7 clamped to the model ceiling, snapped to 4k+1"}
+                </span>
+              </div>
               {i > 0 && (
                 <>
                   <div className="vi-knob" style={{ maxWidth: "13rem" }}>
@@ -2363,6 +2664,24 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
                         : "Frame index into the previous segment's clip (0-based). Blank ⇒ its last frame (parent plays in full)."}
                     </span>
                   </div>
+                  {g.joint === "vace_extend" && (
+                    <div className="vi-knob" style={{ maxWidth: "10rem" }}>
+                      <label htmlFor={`vi-movie-goalctx-${g.key}`}>context frames</label>
+                      <input
+                        id={`vi-movie-goalctx-${g.key}`}
+                        className="vi-knob-input"
+                        type="number"
+                        min={1}
+                        value={g.contextFrames}
+                        placeholder="movie default"
+                        onChange={(e) => setGoalField(i, { contextFrames: e.target.value })}
+                      />
+                      <span className="vi-knob-hint">
+                        How many of the parent&apos;s trailing frames carry motion through this
+                        VACE join. Blank = the movie-level default.
+                      </span>
+                    </div>
+                  )}
                 </>
               )}
             </PromptCardSettings>
@@ -2474,31 +2793,14 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
       {/* ── UNNAMED-MOVIE NUDGE — a warning with a way through, never a gate. Sits
              right above Generate because that is where the decision is made. ── */}
       {nameWarn && (
-        <div
-          className="vi-studio-required-callout"
-          role="alert"
-          style={{
-            display: "flex",
-            alignItems: "center",
-            gap: "0.6rem",
-            flexWrap: "wrap",
-            marginBottom: "0.6rem",
+        <UnnamedWarnPanel
+          noun="movie"
+          onProceed={(name) => {
+            setNameWarn(false);
+            onGenerate(true, name);
           }}
-        >
-          <span>
-            This movie has no name — it will list as “untitled” beside a bare id in
-            Cinema sessions, which is hard to tell apart from every other unnamed render
-            when you come back to resume one.
-          </span>
-          <button
-            type="button"
-            className="vi-btn vi-btn-sm vi-btn-ghost"
-            disabled={disableSubmit}
-            onClick={() => onGenerate(true)}
-          >
-            Generate without a name
-          </button>
-        </div>
+          onDismiss={() => setNameWarn(false)}
+        />
       )}
 
       {/* ── run row ── */}

package/src/stations/studio/StudioPlane.tsx

@@ -28,7 +28,7 @@
 // (StudioClipsStation) and the Generate station's "studio" mode (StudioGenerateMode) — so the
 // workbench is identical and a job enqueued from either is byte-identical. The only per-mount
 // difference is `registerBridge` (the standalone station owns the "Send to Studio" target).
-import { useCallback, useEffect, useRef, useState } from "react";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
 // Sub-tab input memory for the staged source + item strip — see
 // video/sessionForm.ts.
 import { useSessionState } from "../../video/sessionForm";
@@ -38,6 +38,7 @@ import { StudioAssistLogPanel } from "./StudioAssistLogPanel";
 import type { MediaRef } from "../../video/contract";
 import { useStudioPresets } from "../../video/useStudioPresets";
 import { useStudioClips } from "./studioShared";
+import { useMediaLibrary } from "../../video/mediaLibrary";
 import {
   makeStudioItem,
   applyOp,
@@ -140,10 +141,40 @@ export function StudioPlane({ registerBridge = false, lockedSurfaceMode }: Studi
   // now it re-syncs to the newest playable clip on every clip-list change, same as the
   // comment always claimed — gated on `pinned` so a manual pick/clear (see above) is
   // respected instead of being clobbered by the next poll tick.
+  // Session-library media from OTHER tabs (cinema movies, scene clips/frames, crops,
+  // …) — everything that finished anywhere and carries pixels, deduped against the
+  // studio clip catalog by uri (the studio-clips poll mirrors every playable clip
+  // into the library, so without the dedup each clip would list twice). Operator
+  // ask 2026-08-27: generated media from ANY tab auto-displays in this viewer, and
+  // "Play from library" offers recent generations — not just studio_i2v clips.
+  const libraryAll = useMediaLibrary();
+  const libraryMedia = useMemo(() => {
+    const clipUris = new Set(
+      clipsState.clips.map((c) => c.output?.uri).filter((u): u is string => !!u),
+    );
+    return libraryAll
+      .filter(
+        (it) =>
+          (it.ref.kind === "video" || it.ref.kind === "image") &&
+          !!it.ref.uri &&
+          !clipUris.has(it.ref.uri),
+      )
+      .sort((a, b) => b.addedAt - a.addedAt);
+  }, [libraryAll, clipsState.clips]);
+
   useEffect(() => {
     if (pinned) return;
-    setSelected(clipsState.clips.find((c) => c.playable)?.job_id ?? null);
-  }, [clipsState.clips, pinned]);
+    const clip = clipsState.clips.find((c) => c.playable) ?? null;
+    const clipAt = clip ? (clip.updated ?? clip.created ?? 0) * 1000 : -1;
+    // "history" items are server back-fill stamped with the MOUNT time, not the
+    // generation time — following them would surface stale renders as "newest".
+    const item = libraryMedia.find((it) => it.origin !== "history") ?? null;
+    if (item && item.addedAt > clipAt) {
+      setSelected(`lib:${item.ref.asset_id}`);
+    } else {
+      setSelected(clip?.job_id ?? null);
+    }
+  }, [clipsState.clips, libraryMedia, pinned]);
 
   // Manual pick from the viewer's "▤ Play from library" panel — pins so auto-follow
   // leaves the choice alone.
@@ -249,6 +280,7 @@ export function StudioPlane({ registerBridge = false, lockedSurfaceMode }: Studi
           plane mounts get them for free — see the `pinned` note above. */}
       <StudioViewer
         clips={clipsState.clips}
+        library={libraryMedia}
         selected={selected}
         pinned={pinned}
         onPick={pickViewerClip}