@hugpy/video-intelligence-ui 0.1.1 → 0.3.0

package/src/stations/studio/StudioMovieComposer.tsx

@@ -68,6 +68,7 @@ import {
 import { getSessionId } from "../../session";
 import { addToLibrary, useMediaLibrary } from "../../video/mediaLibrary";
 import { UnnamedWarnPanel, WarnUnnamedToggle, useWarnUnnamedPref } from "../../video/UnnamedWarn";
+import { LengthRow } from "../../video/LengthRow";
 import { GoalComposer } from "../GoalComposer";
 import { usePromptAssist, type AssistExtras } from "../../video/usePromptAssist";
 import { PromptAssistButtons } from "../../video/PromptAssistButtons";
@@ -98,6 +99,16 @@ import {
   type PromptFieldMode,
   type SpreadGoalInput,
 } from "../../video/spreadAssist";
+// k121 COORDINATION REVIEW — the words-vs-knobs check that rides every spread.
+// Reader + badge live in their own files so this component stays an editor.
+import {
+  knobPatch,
+  readCoordinationReport,
+  segmentReview,
+  type CoordinationDecision,
+  type CoordinationReport,
+} from "../../video/coordinationReport";
+import { CoordinationBadge, CoordinationSummary, decisionKey } from "./coordinationBadge";
 // B3: the visual spliced row + branch-frame scrubber (the picture half). Pure math
 // lives in movieTimeline.ts; both are new files beside this composer.
 import { StudioSplicedRow, StudioPendingRow } from "./StudioSplicedRow";
@@ -231,6 +242,11 @@ const progressSegmentSchema = z
     prompt: z.string().nullable().optional(),
     status: z.string().nullable().optional(),
     resumed: z.boolean().nullable().optional(),
+    // k120 slice 2 — set when continuity refresh rewrote this segment's prompt:
+    // the authored original + the runner's one-line note (what the previous
+    // segment's closing frame actually showed, or why the rewrite was skipped).
+    prompt_authored: z.string().nullable().optional(),
+    refresh_note: z.string().nullable().optional(),
   })
   .passthrough();
 
@@ -312,6 +328,25 @@ const MODEL_FRAME_CEILING = 81;
 function newGoalKey(): string {
   return `goal_${nextSessionSeq("studio.movie.goalKeySeq")}`;
 }
+// ── CINEMA PRODUCER (k120 slice 1) — POST /video/producer/plan reply shape.
+// The server owns validation/repair; this guard only refuses a reply the row
+// mapper below could not consume.
+const producerPlanSchema = z.object({
+  title: z.string().optional(),
+  logline: z.string().optional(),
+  total_seconds: z.number().optional(),
+  segments: z
+    .array(
+      z.object({
+        prompt: z.string(),
+        negative: z.string().optional(),
+        seconds: z.number(),
+        joint: z.string(),
+      }),
+    )
+    .min(1),
+});
+
 function blankGoal(joint: JointMode = "still"): GoalRow {
   return {
     key: newGoalKey(),
@@ -789,6 +824,11 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
   // The non-destructive result notice: what changed, what did NOT, every warning.
   // Dismissible; it never edits anything on its own.
   const [spreadNotice, setSpreadNotice] = useState<string[] | null>(null);
+  // k121: the last spread's coordination review, and the proposals the operator
+  // has already answered (accepted or rejected). Both are VIEW state — the
+  // report is a fact about the last generate, and re-generating replaces it.
+  const [coordination, setCoordination] = useState<CoordinationReport | null>(null);
+  const [coordSettled, setCoordSettled] = useState<Set<string>>(() => new Set());
 
   const selectedCount = useMemo(
     () => goals.reduce((n, g) => (selectedKeys.has(g.key) ? n + 1 : n), 0),
@@ -1026,6 +1066,28 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
     [],
   );
 
+  // k121 ACCEPT / REJECT for a `proposed` coordination decision. A proposal is
+  // anything that REMOVES coordination (dropping a carry, shortening a clip,
+  // swapping an identity) or that spends real work (an IDENTITY_CAPTURE) — the
+  // backend deliberately never applies those itself, so this is where a human
+  // says yes. Both answers are recorded, so a rejected proposal stops asking
+  // rather than nagging on every re-render.
+  const acceptCoordination = useCallback(
+    (d: CoordinationDecision) => {
+      const patch = knobPatch(d);
+      if (patch) {
+        setGoals((prev) =>
+          prev.map((g) => (g.key === d.segment_id ? { ...g, ...(patch as Partial<GoalRow>) } : g)),
+        );
+      }
+      setCoordSettled((prev) => new Set(prev).add(decisionKey(d)));
+    },
+    [],
+  );
+  const rejectCoordination = useCallback((d: CoordinationDecision) => {
+    setCoordSettled((prev) => new Set(prev).add(decisionKey(d)));
+  }, []);
+
   // SPLIT-TO-FIT (operator 2026-08-13): a length ask beyond the model ceiling
   // becomes VISIBLE continuation segments — motion-carried (vace_extend),
   // length-distributed, each editable — never submit-time magic. The
@@ -1080,21 +1142,98 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
   }, []);
 
   // ── SEGMENTS STEPPER (spec §2) — say how many shots this movie has, up front ──
-  // Materializes rows to reach N, TRUNCATES from the tail to shrink to N. Truncation
-  // is the branch scrubber's own precedent (onBranchFromSegment below drops the rows
-  // after the branch point rather than refusing) — and like it, the affordance names
-  // what it will drop instead of dropping it silently. New rows inherit the joint of
-  // the last row so a movie built as "extend motion" stays that way as it grows.
-  const MAX_SEGMENTS = 24;
-  const setSegmentCount = useCallback((n: number) => {
-    if (!Number.isInteger(n) || n < 1 || n > MAX_SEGMENTS) return;
-    setGoals((prev) => {
-      if (n === prev.length) return prev;
-      if (n < prev.length) return prev.slice(0, n);
-      const joint: JointMode = prev[prev.length - 1]?.joint ?? "still";
-      return [...prev, ...Array.from({ length: n - prev.length }, () => blankGoal(joint))];
+  // Materializes rows to reach N; shrinking to N PARKS the tail rows in a
+  // session-scoped stash instead of deleting them (operator 2026-08-27: 3 edited
+  // segments → count 1 → count 5 must bring the 3 edited rows back, not mint
+  // blanks). Growing revives parked rows first — they keep their keys, so
+  // per-key sidecars (ticks, field modes, intents) re-attach — and only then
+  // mints blanks, which inherit the joint of the last row so a movie built as
+  // "extend motion" stays that way as it grows. No upper cap: the count takes
+  // any integer ≥ 1.
+  const [goalStash, setGoalStash] = useSessionState<GoalRow[]>("studio.movie.goalStash", () => []);
+
+  // ── 🎬 PRODUCER (k120 slice 1) — premise → /video/producer/plan → rows. ──
+  // The plan's per-segment seconds convert to frames against the CURRENT movie
+  // fps (frames is what rides the wire; fps is movie-level). Existing edited
+  // rows are parked in the stash first, never deleted.
+  const [premise, setPremise] = useSessionState<string>("studio.movie.premise", "");
+  const [producerNote, setProducerNote] = useSessionState<string>(
+    "studio.movie.producerNote",
+    "",
+  );
+  const [producing, setProducing] = useState(false);
+  const [produceError, setProduceError] = useState<string | null>(null);
+  // k120 slice 2 — render-time continuity: the runner rewrites each next segment
+  // from the previous segment's ACTUAL closing frame. Auto-enabled by a
+  // successful Produce (a scripted movie wants it); always operator-untickable.
+  const [continuityRefresh, setContinuityRefresh] = useSessionState<boolean>(
+    "studio.movie.continuityRefresh",
+    false,
+  );
+  const produceMovie = useCallback(async () => {
+    const p = premise.trim();
+    if (!p || producing) return;
+    setProducing(true);
+    setProduceError(null);
+    const res = await request<unknown>(hugpyConfig.producerPlanUrl, {
+      method: "POST",
+      body: JSON.stringify({ premise: p }),
+      headers: { "Content-Type": "application/json" },
+      meta: { specKey: "studio", operation: "studio.producer.plan" },
     });
-  }, []);
+    setProducing(false);
+    if (!res.ok) {
+      setProduceError(describeAppError(errorOf(res)));
+      return;
+    }
+    const parsed = producerPlanSchema.safeParse(okValue(res));
+    if (!parsed.success) {
+      setProduceError("The producer reply did not match the expected plan shape.");
+      return;
+    }
+    const plan = parsed.data;
+    const effFps = fps > 0 ? fps : 24;
+    const rows = plan.segments.map((s, i) => {
+      const joint: JointMode =
+        i === 0
+          ? "still"
+          : s.joint === "cut" || s.joint === "still" || s.joint === "vace_extend"
+            ? (s.joint as JointMode)
+            : "vace_extend";
+      return {
+        ...blankGoal(joint),
+        prompt: s.prompt,
+        negative: s.negative ?? "",
+        frames: String(Math.max(1, Math.round(s.seconds * effFps))),
+      };
+    });
+    if (goals.some((g) => g.prompt.trim() !== "")) {
+      setGoalStash((st) => [...goals, ...st]);
+    }
+    setGoals(rows);
+    setProducerNote([plan.title, plan.logline].filter(Boolean).join(" — "));
+    setContinuityRefresh(true);
+  }, [premise, producing, goals, fps]);
+
+  const setSegmentCount = useCallback(
+    (n: number) => {
+      if (!Number.isInteger(n) || n < 1 || n === goals.length) return;
+      if (n < goals.length) {
+        const cut = goals.slice(n);
+        setGoalStash((st) => [...cut, ...st]);
+        setGoals(goals.slice(0, n));
+        return;
+      }
+      const revived = goalStash.slice(0, n - goals.length);
+      if (revived.length) setGoalStash((st) => st.slice(revived.length));
+      const joint: JointMode = goals[goals.length - 1]?.joint ?? "still";
+      const fresh = Array.from({ length: n - goals.length - revived.length }, () =>
+        blankGoal(joint),
+      );
+      setGoals([...goals, ...revived, ...fresh]);
+    },
+    [goals, goalStash],
+  );
 
   // ── the row → wire projection ──
   // ONE place turns editor rows into typed segment references, so the per-row assist
@@ -1283,7 +1422,26 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
         // An explicit Generate on a SELECTED row is meant to replace that row's prose —
         // that is the point of selecting it. A blank returned negative still falls back
         // to what the user wrote rather than blanking it.
-        return { ...g, prompt: hit.prompt, negative: hit.negative || g.negative };
+        //
+        // k121: the row also carries the KNOBS the coordination review turned for
+        // it (ratchet-safe ones only — the backend never removes carry on its own).
+        // ``hit.knobs`` is MECHANICS: no prose from any other row reaches here.
+        const k = hit.knobs ?? {};
+        const applyKnobs: Partial<GoalRow> = {};
+        if (typeof k.joint_mode === "string") {
+          applyKnobs.joint = k.joint_mode as GoalRow["joint"];
+        }
+        if (typeof k.seed === "number") applyKnobs.seed = String(k.seed);
+        if (typeof k.frames === "number") applyKnobs.frames = String(k.frames);
+        if ("branch_frame" in k) {
+          applyKnobs.branchFrame = k.branch_frame == null ? "" : String(k.branch_frame);
+        }
+        return {
+          ...g,
+          prompt: hit.prompt,
+          negative: hit.negative || g.negative,
+          ...applyKnobs,
+        };
       }),
     );
     for (const key of applied) {
@@ -1295,6 +1453,11 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
       return next;
     });
     if (res.steering_seed != null) setSteeringSeed(res.steering_seed);
+    // k121: a fresh review replaces the old one, and the answered set resets with
+    // it — a proposal answered against last generation's prose says nothing about
+    // this one.
+    setCoordination(readCoordinationReport(res.coordination));
+    setCoordSettled(new Set());
     setSpreadNotice(spreadNoticeLines(res, applied));
   }, [
     assist,
@@ -1521,9 +1684,13 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
       reference_images:
         !selectedProfile && references.length ? references.map((r) => r.uri) : undefined,
       goals: goalBodies,
+      // k120 slice 2 — PRODUCER CONTINUITY REFRESH: the runner rewrites each
+      // non-root segment's prompt from a vision read of the frame the previous
+      // segment actually ended on. Off drops the key (schema default False).
+      continuity_refresh: continuityRefresh || undefined,
     };
     return { body };
-  }, [goals, width, height, fps, seed, vramBudget, modelId, steps, cfg, negative, project, movieTitle, startImage, references, selectedProfile]);
+  }, [goals, width, height, fps, seed, vramBudget, modelId, steps, cfg, negative, project, movieTitle, startImage, references, selectedProfile, continuityRefresh]);
 
   // NAME NUDGE (k91) — set when a submit was held back only because the movie has no
   // name. It is a warning, not a gate: the run row then offers "Generate without a
@@ -2016,22 +2183,17 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
           <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>
+        {/* LENGTH ROW (operator 2026-08-13): fps | frames/segment | seconds —
+            any two set the third; dimmed = derived, last-touched wins. This is
+            the MOVIE default; a segment's own length overrides it. */}
+        <LengthRow
+          idPrefix="vi-moviecol-len"
+          fps={fps}
+          onFps={(n) => setFps(n)}
+          frames={framesDefault}
+          onFrames={setFramesDefault}
+          framesPlaceholder="model default (81) / segment"
+        />
         <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}
@@ -2060,6 +2222,56 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
              the follows-hint, and .vi-gen-part-actions (auto-pushed reorder/remove). No
              new look invented — the same classes GenerateStation.tsx uses. */}
       <section aria-label="Goals" className="vi-studio-composer vi-movie-timeline">
+        {/* ── 🎬 PRODUCER (k120 slice 1) — a premise in, a full script out: the
+               plan decides segment count, per-segment prompt/negative/length and
+               how each shot joins the previous one (vace_extend = continue from
+               the last frame). Rows land below as ordinary editable rows; the
+               previous rows are parked in the stash, not deleted. */}
+        <div className="vi-knob" style={{ marginBottom: "0.6rem" }}>
+          <label htmlFor="vi-movie-premise">🎬 producer</label>
+          <div
+            style={{ display: "flex", gap: "0.5rem", alignItems: "flex-start", flexWrap: "wrap" }}
+          >
+            <textarea
+              id="vi-movie-premise"
+              className="vi-knob-input"
+              rows={2}
+              style={{ flex: "1 1 24rem", resize: "vertical" }}
+              placeholder="Premise / logline — the producer writes the whole script: segments, prompts, lengths, joins"
+              value={premise}
+              onChange={(e) => setPremise(e.target.value)}
+              disabled={producing}
+            />
+            <button
+              type="button"
+              className="vi-btn vi-btn-accent"
+              disabled={producing || premise.trim() === ""}
+              onClick={() => void produceMovie()}
+              title="Generate a full script from the premise: segment count, per-segment prompts, negatives, lengths and joins. Current rows are parked in the stash."
+            >
+              {producing ? "Producing…" : "🎬 Produce"}
+            </button>
+          </div>
+          <label
+            className="vi-comfy-hint"
+            style={{ display: "inline-flex", alignItems: "center", gap: "0.35rem" }}
+            title="During the render, a vision model reads the frame each segment actually ended on and a text model rewrites the next segment's prompt to open from that state — true segment-to-segment continuity. Advisory: any failure keeps the authored prompt."
+          >
+            <input
+              type="checkbox"
+              checked={continuityRefresh}
+              onChange={(e) => setContinuityRefresh(e.target.checked)}
+            />
+            continuity refresh — rewrite each next segment from the previous segment's rendered
+            last frame
+          </label>
+          {producerNote ? <span className="vi-knob-hint">{producerNote}</span> : null}
+          {produceError ? (
+            <p className="vi-error" role="alert">
+              {produceError}
+            </p>
+          ) : null}
+        </div>
         {/* ── SEGMENT COUNT + GROUP ASSIST BAR (STUDIO-SPREAD-SPEC §2) ──
                Say how many shots the movie has, tick the ones you want written, and
                write them in ONE coherent pass. The count materializes or truncates
@@ -2071,9 +2283,9 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
             label: "Segments",
             value: goals.length,
             min: 1,
-            max: MAX_SEGMENTS,
             onChange: setSegmentCount,
-            title: `How many shots this movie has (1–${MAX_SEGMENTS}). Lowering it removes rows from the END of the timeline.`,
+            title:
+              "How many shots this movie has. Lowering it parks rows from the END of the timeline; raising it brings them back before adding blanks.",
           }}
           noun="segment"
           selectedCount={selectedCount}
@@ -2160,6 +2372,18 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
           </div>
         )}
 
+        {/* k121: what the review DID to this set, in one line. Present even when
+            nothing changed — "reviewed and fine" has to be visible, because the
+            incident this exists for looked exactly like "nothing happened". */}
+        {coordination && (
+          <CoordinationSummary
+            status={coordination.status}
+            counts={coordination.counts}
+            notes={coordination.notes}
+            onDismiss={() => setCoordination(null)}
+          />
+        )}
+
         <ol className="vi-gen-parts">
           {goals.map((g, i) => (
             <PromptCard
@@ -2180,6 +2404,13 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
               /* The joint descriptor STAYS in the header (the joint SELECT moved
                  into the settings expander below — k88). */
               headerHint={
+                <CoordinationBadge
+                  review={segmentReview(coordination, g.key)}
+                  onAccept={acceptCoordination}
+                  onReject={rejectCoordination}
+                  settled={coordSettled}
+                  disabled={disableSubmit}
+                >
                 <span className="vi-comfy-hint" style={{ opacity: 0.75 }}>
                   {i === 0
                     ? references.length
@@ -2193,6 +2424,7 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
                         ? "extends motion from the previous segment"
                         : "continues from a frame of the previous segment"}
                 </span>
+                </CoordinationBadge>
               }
               canMoveUp={i > 0}
               canMoveDown={i < goals.length - 1}
@@ -2667,23 +2899,18 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
                 />
                 <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>
-                {Number(g.frames.trim() || framesDefault.trim()) > MODEL_FRAME_CEILING && (
+              {/* LENGTH ROW (per-goal): fps is MOVIE-level here (fixed/grey) —
+                  frames<->seconds derive against it. Blank = movie default. */}
+              <LengthRow
+                idPrefix={`vi-movie-goal-len-${g.key}`}
+                fps={fps}
+                fpsFixedReason="Movie-level — one fps per movie; change it in movie settings above."
+                frames={g.frames}
+                onFrames={(v) => setGoalField(i, { frames: v })}
+                framesPlaceholder={framesDefault.trim() || "movie default (81)"}
+              />
+              {Number(g.frames.trim() || framesDefault.trim()) > MODEL_FRAME_CEILING && (
+                <div className="vi-knob" style={{ flexBasis: "100%" }}>
                   <button
                     type="button"
                     className="vi-btn vi-btn-sm"
@@ -2692,8 +2919,8 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
                   >
                     ✂ split into {Math.ceil(Number(g.frames.trim() || framesDefault.trim()) / MODEL_FRAME_CEILING)} segments to fit
                   </button>
-                )}
-              </div>
+                </div>
+              )}
               {/* UNIFORM-CARD PLACEHOLDERS (operator 2026-08-13): geometry and
                   budget are MOVIE-level by server contract (one StudioMovieSpec
                   geometry per movie) — shown greyed with the reason, never
@@ -2708,11 +2935,6 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
                 <input id={`vi-movie-goalh-${g.key}`} className="vi-knob-input" disabled value={height}
                        title="Movie-level — one geometry per movie (StudioMovieSpec); change it in movie settings above." />
               </div>
-              <div className="vi-knob" style={{ maxWidth: "6rem" }}>
-                <label htmlFor={`vi-movie-goalfps-${g.key}`}>fps</label>
-                <input id={`vi-movie-goalfps-${g.key}`} className="vi-knob-input" disabled value={fps}
-                       title="Movie-level — one fps per movie; change it in movie settings above." />
-              </div>
               <div className="vi-knob" style={{ maxWidth: "9rem" }}>
                 <label htmlFor={`vi-movie-goalvram-${g.key}`}>VRAM budget GB</label>
                 <input id={`vi-movie-goalvram-${g.key}`} className="vi-knob-input" disabled
@@ -2941,7 +3163,22 @@ export function StudioMovieComposer({ settingsHost }: StudioMovieComposerProps =
                 <span style={{ fontVariantNumeric: "tabular-nums", opacity: 0.7, minWidth: "5.5rem" }}>
                   seg {s.index + 1} · {statusBadge(s.status, s.resumed)}
                 </span>
-                <span style={{ opacity: 0.85, wordBreak: "break-word" }}>{s.prompt ?? ""}</span>
+                <span style={{ opacity: 0.85, wordBreak: "break-word" }}>
+                  {s.prompt ?? ""}
+                  {s.refresh_note ? (
+                    <span
+                      className="vi-comfy-hint"
+                      style={{ display: "block", opacity: 0.75 }}
+                      title={
+                        s.prompt_authored
+                          ? `authored prompt: ${s.prompt_authored}`
+                          : undefined
+                      }
+                    >
+                      🎬 {s.refresh_note}
+                    </span>
+                  ) : null}
+                </span>
               </li>
             ))}
           </ul>

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}